并发编程目录

1. Java并发编程实战的作品目录

对本书的赞誉
译者序
前言
第1章简介
1.1并发简史
1.2线程的优势
1.2.1发挥多处理器的强大能力
1.2.2建模的简单性
1.2.3异步事件的简化处理
1.2.4响应更灵敏的用户界面
1.3线程带来的风险
1.3.1安全性问题
1.3.2活跃性问题
1.3.3性能问题
1.4线程无处不在
第一部分基础知识
第2章线程安全性
2.1什么是线程安全性
2.2原子性
2.2.1竞态条件
2.2.2示例：延迟初始化中的竞态条件
2.2.3复合操作
2.3加锁机制
2.3.1内置锁
2.3.2重入
2.4用锁来保护状态
2.5活跃性与性能
第3章对象的共享
3.1可见性
3.1.1失效数据
3.1.2非原子的64位操作
3.1.3加锁与可见性
3.1.4Volatile变量
3.2发布与逸出
3.3线程封闭
3.3.1Ad-hoc线程封闭
3.3.2栈封闭
3.3.3ThreadLocal类
3.4不变性
3.4.1Final域
3.4.2示例：使用Volatile类型来发布不可变对象
3.5安全发布
3.5.1不正确的发布：正确的对象被破坏
3.5.2 不可变对象与初始化安全性
3.5.3安全发布的常用模式
3.5.4事实不可变对象
3.5.5可变对象
3.5.6安全地共享对象
第4章对象的组合
4.1设计线程安全的类
4.1.1收集同步需求
4.1.2依赖状态的操作
4.1.3状态的所有权
4.2实例封闭
4.2.1Java监视器模式
4.2.2示例：车辆追踪
4.3线程安全性的委托
4.3.1示例：基于委托的车辆追踪器
4.3.2独立的状态变量
4.3.3当委托失效时
4.3.4发布底层的状态变量
4.3.5示例：发布状态的车辆追踪器
4.4在现有的线程安全类中添加功能
4.4.1客户端加锁机制
4.4.2组合
4.5将同步策略文档化
第5章基础构建模块
5.1同步容器类
5.1.1同步容器类的问题
5.1.2迭代器与Concurrent-ModificationException
5.1.3隐藏迭代器
5.2并发容器
5.2.1ConcurrentHashMap
5.2.2额外的原子Map操作
5.2.3CopyOnWriteArrayList
5.3阻塞队列和生产者-消费者模式
5.3.1示例：桌面搜索
5.3.2串行线程封闭
5.3.3双端队列与工作密取
5.4阻塞方法与中断方法
5.5同步工具类
5.5.1闭锁
5.5.2FutureTask
5.5.3信号量
5.5.4栅栏
5.6构建高效且可伸缩的结果缓存
第二部分结构化并发应用程序
第6章任务执行
6.1在线程中执行任务
6.1.1串行地执行任务
6.1.2显式地为任务创建线程
6.1.3无限制创建线程的不足
6.2Executor框架
6.2.1示例：基于Executor的Web服务器
6.2.2执行策略
6.2.3线程池
6.2.4Executor的生命周期
6.2.5延迟任务与周期任务
6.3找出可利用的并行性
6.3.1示例：串行的页面渲染器
6.3.2携带结果的任务Callable与Future
6.3.3示例：使用Future实现页面渲染器
6.3.4在异构任务并行化中存在的局限
6.3.5CompletionService:Executor与BlockingQueue
6.3.6示例：使用CompletionService实现页面渲染器
6.3.7为任务设置时限
6.3.8示例：旅行预定门户网站
第7章取消与关闭
第8章线程池的使用
第9章图形用户界面应用程序
第三部分活跃性、性能与测试
第10章避免活跃性危险
第11章性能与可伸缩性
第12章并发程序的测试
第四部分高级主题
第13章显式锁
第14章构建自定义的同步工具
第15章原子变量与非阻塞同步机制
第16章Java内存模型
附录A并发性标注
参考文献

2. Java编程思想的作品目录

读者评论
前言 第1章 对象导论
1.1 抽象过程
1.2 每个对象都有一个接口
1.3 每个对象都提供服务
1.4 被隐藏的具体实现
1.5 复用具体实现
1.6 继承
1.6.1 “是一个”（is-a）与“像是一个”（is-like-a）关系
1.7 伴随多态的可互换对象
1.8 单根继承结构
1.9 容器
1.9.1 参数化类型（范型）
1.10 对象的创建和生命期
1.11 异常处理：处理错误
1.12 并发编程
1.13 Java与Internet
1.13.1 Web是什么
1.13.2客户端编程
1.13.3 服务器端编程
1.22 总结
第2章 一切都是对象
2.1 用引用操纵对象
2.2 必须由你创建所有对象
2.2.1 存储到什么地方
2.2.2 特例：基本类型
2.2.3 Java中的数组
2.3 永远不需要销毁对象
2.3.1 作用域
2.3.2 对象的作用域
2.4 创建新的数据类型：类
2.4.1 域和方法
2.4.2 基本成员默认值
2.5 方法、参数和返回值
2.5.1 参数列表
2.6 构建一个Java程序
2.6.1 名字可见性
2.6.2 运用其他构件
2.6.3 static 关键字
2.7 你的第一个Java程序
编译和运行
2.8 注释和嵌入式文档
2.8.1 注释文档
2.8.2 语法
2.8.3 嵌入式HTML
2.8.4 一些标签示例
2.8.5 文档示例
2.9 编码风格
2.10 总结
2.11 练习
第3章 操作符
3.1 更简单的打印语句
3.2 使用Java操作符
3.3 优先级
3.4 赋值
3.4.1 方法调用中的别名问题
3.5 算术操作符
3.5.1 一元加、减操作符
3.6 自动递增和递减
3.7 关系操作符
3.7.1 测试对象的等价性
3.8 逻辑操作符
3.8.1 短路
3.9 直接常量
3.9.1 指数记数法
3.10 按位操作符
3.11 移位操作符
3.12 三元操作符 if-else
3.13 字符串操作符 + 和 +=
3.14 使用操作符时常犯的错误
3.15 类型转换操作符
3.15.1 截尾和舍入
3.15.2提升
3.16 Java没有“sizeof”
3.17 操作符小结
3.18 总结
第4章 控制执行流程
4.1 true和false
4.2 if-else
4.3 迭代
4.3.1 do-while
4.3.2 for
4.3.3 逗号操作符
4.4 Foreach语法
4.5 return
4.6 break和 continue
4.7 臭名昭著的“goto”
4.8 switch
4.9 总结
第5章 初始化与清理
5.1 用构造器确保初始化
5.2 方法重载
5.2.1 区分重载方法
5.2.2 涉及基本类型的重载
5.2.3 以返回值区分重载方法
5.3 缺省构造器
5.4 this关键字
5.4.1 在构造器中调用构造器
5.4.2 static的含义
5.5 清理：终结处理和垃圾回收
5.5.1 finalize()的用途何在
5.5.2 你必须实施清理
5.5.3 终结条件
5.5.4 垃圾回收器如何工作
5.6 成员初始化
5.6.1 指定初始化
5.7 构造器初始化
5.7.1 初始化顺序
5.7.2. 静态数据的初始化
5.7.3. 显式的静态初始化
5.7.4. 非静态实例初始化
5.8 数组初始化
5.8.1 可变参数列表
5.9 枚举类型
5.10 总结
第6章 访问权限控制
第7章 复用类
第8章 多态
第9章 接口
第10章 内部类
第11章 持有对象
第12章 通过异常处理错误
第13章 字符串
第14章 类型信息
第15章 泛型
第16章 数组
第17章 容器深入研究
第18章 Java I/O系统
第19章 枚举类型
第20章 注解
第21章 并发
第22章 图形化用户界面
附录A 补充材料
可下载的补充材料
Thinking in C：Java的基础
Java编程思想 研讨课
Hands-on Java研讨课CD
Thinking in Objects研讨课
Thinking in Enterprise Java
Thinking in Patterns(with Java)
Thinking in Patterns研讨课
设计咨询与复审
附录B 资源
软件
编辑器与IDE
书籍
分析与设计
Python
我的著作列表
索引

3. UNIX环境高级编程的作品目录

第1章UNIX基础知识1
1.1引言1
1.2UNIX体系结构1
1.3登录1
1.4文件和目录3
1.5输入和输出6
1.6程序和进程8
1.7出错处理10
1.8用户标识12
1.9信号14
1.10时间值15
1.11系统调用和库函数16
1.12小结17
习题18
第2章UNIX标准化及实现19
2.1引言19
2.2UNIX标准化19
2.2.1ISO C19
2.2.2IEEE POSIX20
2.2.3Single UNIX Specification25
2.2.4FIPS26
2.3UNIX系统实现26
2.3.1SVR426
2.3.24.4BSD27
2.3.3FreeBSD27
2.3.4Linux27
2.3.5Mac OS X28
2.3.6Solaris28
2.3.7其他UNIX系统28
2.4标准和实现的关系28
2.5限制29
2.5.1ISO C限制29
2.5.2POSIX限制30
2.5.3XSI限制32
2.5.4sysconf、pathconf和fpathconf函数32
2.5.5不确定的运行时限制38
2.6选项42
2.7功能测试宏44
2.8基本系统数据类型45
2.9标准之间的冲突45
2.10小结46
习题46
第3章文件I/O47
3.1引言47
3.2文件描述符47
3.3open函数48
3.4creat函数49
3.5close函数50
3.6lseek函数50
3.7read函数53
3.8write函数54
3.9I/O的效率54
3.10文件共享56
3.11原子操作59
3.12p和p2函数60
3.13sync、fsync和fdatasync函数61
3.14fcntl函数62
3.15ioctl函数66
3.16/dev/fd67
3.17小结68
习题68
第4章文件和目录71
4.1引言71
4.2stat、fstat和lstat函数71
4.3文件类型72
4.4设置用户ID和设置组ID74
4.5文件访问权限75
4.6新文件和目录的所有权77
4.7access函数77
4.8umask函数79
4.9chmod和fchmod函数81
4.10粘住位83
4.11chown、fchown和lchown函数84
4.12文件长度85
4.13文件截短86
4.14文件系统86
4.15link、unlink、remove和rename函数89
4.16符号链接91
4.17symlink和readlink函数94
4.18文件的时间94
4.19utime函数95
4.20mkdir和rmdir函数97
4.21读目录98
4.22chdir、fchdir和getcwd函数102
4.23设备特殊文件104
4.24文件访问权限位小结106
4.25小结106
习题107
第5章标准I/O库109
5.1引言109
5.2流和FILE对象109
5.3标准输入、标准输出和标准出错110
5.4缓冲110
5.5打开流112
5.6读和写流114
5.7每次一行I/O116
5.8标准I/O的效率117
5.9二进制I/O119
5.10定位流120
5.11格式化I/O121
5.12实现细节125
5.13临时文件127
5.14标准I/O的替代软件130
5.15小结130
习题130
第6章系统数据文件和信息133
6.1引言133
6.2口令文件133
6.3阴影口令136
6.4组文件137
6.5附加组ID138
6.6实现的区别139
6.7其他数据文件139
6.8登录账户记录140
6.9系统标识141
6.10时间和日期例程142
6.11小结146
习题146
第7章进程环境147
7.1引言147
7.2main函数147
7.3进程终止147
7.4命令行参数151
7.5环境表152
7.6C程序的存储空间布局152
7.7共享库154
7.8存储器分配154
7.9环境变量157
7.10setjmp和longjmp函数159
7.11getrlimit和setrlimit函数164
7.12小结168
习题168
第8章进程控制171
8.1引言171
8.2进程标识符171
8.3fork函数172
8.4vfork函数176
8.5exit函数178
8.6wait和waitpid函数179
8.7waitid函数183
8.8wait3和wait4函数184
8.9竞争条件185
8.10exec函数188
8.11更改用户ID和组ID192
8.12解释器文件196
8.13system函数200
8.14进程会计203
8.15用户标识208
8.16进程时间208
8.17小结210
习题211
第9章进程关系213
9.1引言213
9.2终端登录213
9.3网络登录216
9.4进程组218
9.5会话219
9.6控制终端220
9.7tcgetpgrp、tcsetpgrp和tcgetsid函数221
9.8作业控制222
9.9shell执行程序225
9.10孤儿进程组228
9.11FreeBSD实现230
9.12小结231
习题232
第10章信号233
10.1引言233
10.2信号概念233
10.3signal函数240
10.4不可靠的信号242
10.5中断的系统调用244
10.6可重入函数246
10.7SIGCLD语义248
10.8可靠信号术语和语义250
10.9kill和raise函数251
10.10alarm和pause函数252
10.11信号集256
10.12sigprocmask函数258
10.13sigpending函数259
10.14sigaction函数261
10.15sigsetjmp和siglongjmp函数266
10.16sigsuspend函数268
10.17abort函数274
10.18system函数276
10.19sleep函数280
10.20作业控制信号282
10.21其他特征284
10.22小结285
习题285
第11章线程287
11.1引言287
11.2线程概念287
11.3线程标识288
11.4线程的创建288
11.5线程终止291
11.6线程同步297
11.7小结311
习题311
第12章线程控制313
12.1引言313
12.2线程限制313
12.3线程属性314
12.4同步属性318
12.5重入324
12.6线程私有数据328
12.7取消选项331
12.8线程和信号333
12.9线程和fork336
12.10线程和I/O339
12.11小结340
习题340
第13章守护进程341
13.1引言341
13.2守护进程的特征341
13.3编程规则342
13.4出错记录345
13.5单实例守护进程348
13.6守护进程的惯例350
13.7客户进程-服务器进程模型354
13.8小结354
习题354
第14章高级I/O355
14.1引言355
14.2非阻塞I/O355
14.3记录锁357
14.4STREAMS370
14.5I/O多路转接379
14.5.1select和pselect函数381
14.5.2poll函数384
14.6异步I/O386
14.6.1系统V异步I/O386
14.6.2BSD异步I/O387
14.7readv和writev函数387
14.8readn和writen函数389
14.9存储映射I/O390
14.10小结395
习题396
第15章进程间通信397
15.1引言397
15.2管道398
15.3popen和pclose函数403
15.4协同进程408
15.5FIFO412
15.6XSI IPC415
15.6.1标识符和键415
15.6.2权限结构416
15.6.3结构限制417
15.6.4优点和缺点417
15.7消息队列418
15.8信号量422
15.9共享存储427
15.10客户进程-服务器进程属性432
15.11小结434
习题434
第16章网络IPC：套接字437
16.1引言437
16.2套接字描述符437
16.3寻址439
16.3.1字节序440
16.3.2地址格式441
16.3.3地址查询442
16.3.4将套接字与地址绑定449
16.4建立连接450
16.5数据传输452
16.6套接字选项464
16.7带外数据466
16.8非阻塞和异步I/O467
16.9小结468
习题468
第17章高级进程间通信469
17.1引言469
17.2基于STREAMS的管道469
17.2.1命名的STREAMS管道472
17.2.2唯一连接473
17.3UNIX域套接字476
17.3.1命名UNIX域套接字477
17.3.2唯一连接478
17.4传送文件描述符482
17.4.1经由基于STREAMS的管道传送文件描述符484
17.4.2经由UNIX域套接字传送文件描述符486
17.5open服务器版本1493
17.6open服务器版本2498
17.7小结505
习题505
第18章终端I/O507
18.1引言507
18.2综述507
18.3特殊输入字符512
18.4获得和设置终端属性516
18.5终端选项标志516
18.6stty命令522
18.7波特率函数523
18.8行控制函数524
18.9终端标识524
18.10规范模式529
18.11非规范模式532
18.12终端的窗口大小537
18.13termcap，terminfo和curses539
18.14小结540
习题540
第19章伪终端541
19.1引言541
19.2概述541
19.3打开伪终端设备544
19.3.1基于STREAMS的伪终端547
19.3.2基于BSD的伪终端549
19.3.3基于Linux的伪终端551
19.4pty_fork函数553
19.5pty程序555
19.6使用pty程序559
19.7高级特性564
19.8小结565
习题565
第20章数据库函数库567
20.1引言567
20.2历史567
20.3函数库568
20.4实现概述569
20.5集中式或非集中式572
20.6并发574
20.7构造函数库574
20.8源代码575
20.9性能598
20.10小结600
习题601
第21章与网络打印机通信603
21.1引言603
21.2网络打印协议603
21.3超文本传输协议605
21.4打印假脱机技术605
21.5源代码607
21.6小结644
习题645
附录A函数原型647
附录B其他源代码677
附录C部分习题答案685
参考书目709
索引715

4. 代码整洁之道的作品目录

第1章整洁代码1
1.1要有代码21.2糟糕的代码2
1.3混乱的代价3
1.3.1华丽新设计4
1.3.2态度
1.3.3迷题5
1.3.4整洁代码的艺术5
1.3.5什么是整洁代码6
1.4思想流派10
1.5我们是作者11
1.6童子军军规12
1.7前传与原则121.8小结12
1.9文献13
第2章有意义的命名15
2.1介绍15
2.2名副其实16
2.3避免误导17
2.4做有意义的区分18
2.5使用读得出来的名称19
2.6使用可搜索的名称202.7避免使用编码21
2.7.1匈牙利语标记法21
2.7.2成员前缀21
2.7.3接口和实现22
2.8避免思维映射22
2.9 类名23
2.10方法名23
2.11别扮可爱23
2.12每个概念对应一个词24
2.13别用双关语24
2.14使用解决方案领域名称25
2.15使用源自所涉问题领域的名称25
2.16添加有意义的语境25
2.17不要添加没用的语境27
2.18最后的话27
第3章函数29
3.1短小32
3.2只做一件事33
3.3每个函数一个抽象层级34
3.4switch语句35
3.5使用描述性的名称36
3.6函数参数37
3.6.1一元函数的普遍形式38
3.6.2标识参数38
3.6.3二元函数38
3.6.4三元函数39
3.6.5参数对象39
3.6.6参数列表40
3.6.7动词与关键字40
3.7无副作用40
3.8分隔指令与询问42
3.9使用异常替代返回错误码423.9.1抽离Try/Catch代码块43
3.9.2错误处理就是一件事44
3.9.3Error.java依赖磁铁44
3.10别重复自己44
3.11结构化编程45
3.12如何写出这样的函数45
3.13小结45
3.14SetupTeardownIncluder程序463.15文献48
第4章注释49
4.1注释不能美化糟糕的代码50
4.2用代码来阐述51
4.3好注释51
4.3.1法律信息51
4.3.2提供信息的注释51
4.3.3对意图的解释52
4.3.4阐释534.3.5警示53
4.3.6TODO注释54
4.3.7放大54
4.3.8公共API中的Javadoc55
4.4坏注释55
4.4.1喃喃自语55
4.4.2多余的注释56
4.4.3误导性注释58
4.4.4循规式注释58
4.4.5日志式注释594.4.6废话注释59
4.4.7可怕的废话61
4.4.8能用函数或变量时就别用注释62
4.4.9位置标记62
4.4.10括号后面的注释62
4.4.11归属与署名63
4.4.12注释掉的代码63
4.4.13HTML注释64
4.4.14非本地信息64
4.4.15信息过多65
4.4.16不明显的联系654.4.17函数头66
4.4.18非公共代码中的Javadoc66
4.4.19范例66
4.5文献69
第5章格式71
5.1格式的目的72
5.2垂直格式72
5.2.1向报纸学习73
5.2.2概念间垂直方向上的区隔735.2.3垂直方向上的靠近74
5.2.4垂直距离75
5.2.5垂直顺序79
5.3横向格式79
5.3.1水平方向上的区隔与靠近80
5.3.2水平对齐81
5.3.3缩进82
5.3.4空范围84
5.4团队规则84
5.5鲍勃大叔的格式规则85
第6章对象和数据结构876.1数据抽象87
6.2数据、对象的反对称性89
6.3得墨忒耳律91
6.3.1火车失事91
6.3.2混杂92
6.3.3隐藏结构92
6.4数据传送对象93
6.5小结946.6文献94
第7章错误处理95
7.1使用异常而非返回码96
7.2先写Try-Catch-Finally语句97
7.3使用不可控异常98
7.4给出异常发生的环境说明99
7.5依调用者需要定义异常类99
7.6定义常规流程100
7.7别返回null值101
7.8别传递null值102
7.9小结1037.10 文献104
第8章边界105
8.1使用第三方代码106
8.2浏览和学习边界107
8.3学习log4j108
8.4学习性测试的好处不只是免费110
8.5使用尚不存在的代码110
8.6整洁的边界111
8.7文献112
第9章单元测试113
9.1TDD三定律1149.2保持测试整洁115
9.3整洁的测试116
9.3.1面向特定领域的测试语言118
9.3.2双重标准119
9.4每个测试一个断言121
9.5F.I.R.S.T.122
9.6小结123
9.7文献124
第10章类125
10.1类的组织126
10.2类应该短小126
10.2.1单一权责原则128
10.2.2内聚129
10.2.3保持内聚性就会得到许多短小的类130
10.3为了修改而组织136
10.4文献139
第11章系统141
11.1如何建造一个城市142
11.2将系统的构造与使用分开142
11.2.1分解main143
11.2.2工厂143
11.2.3依赖注入144
11.3扩容145
11.4Java代理148
11.5纯Java AOP框架150
11.6AspectJ的方面152
11.7测试驱动系统架构15311.8优化决策154
11.9明智使用添加了可论证价值的标准154
11.10 系统需要领域特定语言154
11.11 小结155
11.12 文献155
第12章迭进157
12.1通过迭进设计达到整洁目的157
12.2简单设计规则1：运行所有测试15812.3简单设计规则2～4：重构158
12.4不可重复159
12.5表达力161
12.6尽可能少的类和方法162
12.7小结162
12.8文献162
第13章并发编程163
13.1为什么要并发16413.2挑战165
13.3并发防御原则166
13.3.1单一权责原则166
13.3.2推论：限制数据作用域166
13.3.3推论：使用数据复本167
13.3.4推论：线程应尽可能地独立167
13.4了解Java库167
13.5了解执行模型168
13.5.1生产者-消费者模型16913.5.2读者-作者模型169
13.5.3宴席哲学家169
13.6警惕同步方法之间的依赖169
13.7保持同步区域微小170
13.8很难编写正确的关闭代码170
13.9测试线程代码171
13.9.1将伪失败看作可能的线程问题171
13.9.2先使非线程代码可工作171
13.9.3编写可插拔的线程代码172
13.9.4编写可调整的线程代码172
13.9.5运行多于处理器数量的线程17213.9.6在不同平台上运行172
13.9.7装置试错代码173
13.9.8硬编码173
13.9.9自动化174
13.10小结175
13.11文献175
第14章逐步改进176
14.1Args的实现17714.2Args：草稿183
14.2.1所以我暂停了195
14.2.2渐进195
14.3字符串参数197
14.4小结234
第15章JUnit内幕235
15.1JUnit框架236
15.2小结249第16章重构SerialDate251
16.1首先，让它能工作252
16.2让它做对254
16.3小结266
16.4文献267
第17章味道与启发269
17.1注释270
17.2环境271
17.3函数271
17.4一般性问题272
17.5Java28817.6名称291
17.7测试294
17.8小结295
17.9文献296
附录A并发编程II297
A.1客户端/服务器的例子297
A.1.1服务器297
A.1.2添加线程代码298A.1.3观察服务器端299
A.1.4小结301
A.2执行的可能路径301
A.2.1路径数量302
A.2.2深入挖掘303
A.2.3小结305
A.3了解类库305
A.3.1Executor框架305
A.3.2非锁定的解决方案306
A.3.3非线程安全类307
A.4方法之间的依赖可能破坏并发代码308A.4.1容忍错误309
A.4.2基于客户代码的锁定309
A.4.3基于服务端的锁定311
A.5提升吞吐量312
A.5.1单线程条件下的吞吐量313
A.5.2多线程条件下的吞吐量313
A.6死锁314
A.6.1互斥315
A.6.2上锁及等待315
A.6.3无抢先机制315
A.6.4循环等待315
A.6.5不互斥316
A.6.6不上锁及等待316
A.6.7满足抢先机制317
A.6.8不做循环等待317
A.7测试多线程代码317
A.8测试线程代码的工具支持320
A.9小结320
A.10 教程：完整代码范例321
A.10.1客户端/服务器非线程代码321
A.10.2使用线程的客户端/服务器代码324
附录Borg.jfree.date.SerialDate327
结束语389

5. 深入理解计算机系统的目录2

第1章计算机系统漫游1
1.1信息就是位+上下文1
1.2程序被其他程序翻译成不同的格式3
1.3了解编译系统如何工作是大有益处的4
1.4处理器读并解释存储在存储器中的指令5
1.4.1系统的硬件组成5
1.4.2运行hello程序7
1.5高速缓存至关重要7
1.6存储设备形成层次结构9
1.7操作系统管理硬件10
1.7.1进程11
1.7.2线程12
1.7.3虚拟存储器12
1.7.4文件13
1.8系统之间利用网络通信13
1.9重要主题15
1.9.1并发和并行15
1.9.2计算机系统中抽象的重要性17
1.10小结17
参考文献说明18
.第一部分程序结构和执行
第2章信息的表示和处理20
2.1信息存储22
2.1.1十六进制表示法22
2.1.2字25
2.1.3数据大小25
2.1.4寻址和字节顺序26
2.1.5表示字符串31
2.1.6表示代码31
2.1.7布尔代数简介32
2.1.8c语言中的位级运算34
2.1.9c语言中的逻辑运算36
2.1.10c语言中的移位运算36
2.2整数表示38
2.2.1整型数据类型38
2.2.2无符号数的编码39
2.2.3补码编码40
2.2.4有符号数和无符号数之间的转换44
2.2.5c语言中的有符号数与无符号数47
2.2.6扩展一个数字的位表示49
2.2.7截断数字51
2.2.8关于有符号数与无符号数的建议52
2.3整数运算54
2.3.1无符号加法54
2.3.2补码加法57
2.3.3补码的非59
2.3.4无符号乘法60
2.3.5补码乘法60
2.3.6乘以常数63
2.3.7除以2的幂64
2.3.8关于整数运算的最后思考67
2.4浮点数67
2.4.1二进制小数68
2.4.2ieee浮点表示70
2.4.3数字示例71
2.4.4舍入74
2.4.5浮点运算76
2.4.6c语言中的浮点数77
2.5小结79
参考文献说明80
家庭作业80
练习题答案90
第3章程序的机器级表示102
3.1历史观点103
3.2程序编码105
3.2.1机器级代码106
3.2.2代码示例107
3.2.3关于格式的注解109
3.3数据格式111
3.4访问信息112
3.4.1操作数指示符112
3.4.2数据传送指令114
3.4.3数据传送示例116
3.5算术和逻辑操作118
3.5.1加载有效地址118
3.5.2一元操作和二元操作119
3.5.3移位操作120
3.5.4讨论120
3.5.5特殊的算术操作122
3.6控制123
3.6.1条件码124
3.6.2访问条件码125
3.6.3跳转指令及其编码127
3.6.4翻译条件分支129
3.6.5循环132
3.6.6条件传送指令139
3.6.7switch语句144
3.7过程149
3.7.1栈帧结构149
3.7.2转移控制150
3.7.3寄存器使用惯例151
3.7.4过程示例152
3.7.5递归过程156
3.8数组分配和访问158
3.8.1基本原则158
3.8.2指针运算159
3.8.3嵌套的数组159
3.8.4定长数组161
3.8.5变长数组163
3.9异质的数据结构164
3.9.1结构164
3.9.2联合167
3.9.3数据对齐170
3.10综合：理解指针172
3.11应用：使用gdb调试器174
3.12存储器的越界引用和缓冲区溢出175
3.13x86-64：将ia32扩展到64位183
3.13.1x86-64的历史和动因184
3.13.2x86-64简介185
3.13.3访问信息187
3.13.4控制192
3.13.5数据结构200
3.13.6关于x86-64的总结性评论200
3.14浮点程序的机器级表示201
3.15小结201
参考文献说明202
家庭作业202
练习题答案212
第4章处理器体系结构230
4.1y86指令集体系结构231
4.1.1程序员可见的状态231
4.1.2y86指令232
4.1.3指令编码233
4.1.4y86异常237
4.1.5y86程序237
4.1.6一些y86指令的详情241
4.2逻辑设计和硬件控制语言hcl242
4.2.1逻辑门243
4.2.2组合电路和hcl布尔表达式243
4.2.3字级的组合电路和hcl整数表达式245
4.2.4集合关系248
4.2.5存储器和时钟248
4.3y86的顺序实现250
4.3.1将处理组织成阶段250
4.3.2seq硬件结构258
4.3.3seq的时序259
4.3.4seq阶段的实现262
4.4流水线的通用原理267
4.4.1计算流水线268
4.4.2流水线操作的详细说明269
4.4.3流水线的局限性271
4.4.4带反馈的流水线系统272
4.5y86的流水线实现273
4.5.1seq+：重新安排计算阶段273
4.5.2插入流水线寄存器276
4.5.3对信号进行重新排列和标号277
4.5.4预测下一个pc279
4.5.5流水线冒险280
4.5.6用暂停来避免数据冒险283
4.5.7用转发来避免数据冒险285
4.5.8加载/使用数据冒险288
4.5.9异常处理289
4.5.10pipe各阶段的实现291
4.5.11流水线控制逻辑297
4.5.12性能分析305
4.5.13未完成的工作306
4.6小结308
参考文献说明309
家庭作业309
练习题答案314
第5章优化程序性能324
5.1优化编译器的能力和局限性325
5.2表示程序性能328
5.3程序示例330
5.4消除循环的低效率332
5.5减少过程调用336
5.6消除不必要的存储器引用336
5.7理解现代处理器340
5.7.1整体操作340
5.7.2功能单元的性能343
5.7.3处理器操作的抽象模型344
5.8循环展开348
5.9提高并行性351
5.9.1多个累积变量351
5.9.2重新结合变换354
5.10优化合并代码的结果小结358
5.11一些限制因素359
5.11.1寄存器溢出359
5.11.2分支预测和预测错误处罚360
5.12理解存储器性能363
5.12.1加载的性能363
5.12.2存储的性能364
5.13应用：性能提高技术369
5.14确认和消除性能瓶颈369
5.14.1程序剖析370
5.14.2使用剖析程序来指导优化371
5.14.3amdahl定律374
5.15小结375
参考文献说明375
家庭作业376
练习题答案378
第6章存储器层次结构382
6.1 存储技术382
6.1.1随机访问存储器383
6.1.2磁盘存储389
6.1.3固态硬盘398
6.1.4存储技术趋势399
6.2局部性401
6.2.1对程序数据引用的局部性402
6.2.2取指令的局部性403
6.2.3局部性小结403
6.3存储器层次结构405
6.3.1存储器层次结构中的缓存406
6.3.2存储器层次结构概念小结408
6.4高速缓存存储器408
6.4.1通用的高速缓存存储器结构409
6.4.2直接映射高速缓存410
6.4.3组相联高速缓存416
6.4.4全相联高速缓存418
6.4.5有关写的问题420
6.4.6一个真实的高速缓存层次结构的解剖421
6.4.7高速缓存参数的性能影响422
6.5编写高速缓存友好的代码423
6.6综合：高速缓存对程序性能的影响426
6.6.1存储器山426
6.6.2重新排列循环以提高空间局部性430
6.6.3在程序中利用局部性433
6.7小结433
参考文献说明434
家庭作业434
练习题答案442
第二部分在系统上运行程序
第7章链接448
7.1编译器驱动程序449
7.2静态链接450
7.3目标文件450
7.4可重定位目标文件451
7.5符号和符号表452
7.6符号解析454
7.6.1链接器如何解析多重定义的全局符号455
7.6.2与静态库链接457
7.6.3链接器如何使用静态库来解析引用460
7.7重定位461
7.7.1重定位条目461
7.7.2重定位符号引用462
7.8可执行目标文件465
7.9加载可执行目标文件466
7.10动态链接共享库467
7.11从应用程序中加载和链接共享库468
7.12与位置无关的代码（pic）471
7.13处理目标文件的工具473
7.14小结473
参考文献说明474
家庭作业474
练习题答案479
第8章异常控制流480
8.1异常481
8.1.1异常处理481
8.1.2异常的类别482
8.1.3linux/ia32系统中的异常484
8.2进程487
8.2.1逻辑控制流487
8.2.2并发流487
8.2.3私有地址空间488
8.2.4用户模式和内核模式488
8.2.5上下文切换489
8.3系统调用错误处理491
8.4进程控制492
8.4.1获取进程id492
8.4.2创建和终止进程492
8.4.3回收子进程495
8.4.4让进程休眠499
8.4.5加载并运行程序500
8.4.6利用fork和execve运行程序502
8.5信号504
8.5.1信号术语505
8.5.2发送信号506
8.5.3接收信号509
8.5.4信号处理问题511
8.5.5可移植的信号处理516
8.5.6显式地阻塞和取消阻塞信号517
8.5.7同步流以避免讨厌的并发错误517
8.6非本地跳转521
8.7操作进程的工具524
8.8小结524
参考文献说明525
家庭作业525
练习题答案530
第9章虚拟存储器534
9.1物理和虚拟寻址535
9.2地址空间535
9.3虚拟存储器作为缓存的工具536
9.3.1dram缓存的组织结构537
9.3.2页表537
9.3.3页命中538
9.3.4缺页538
9.3.5分配页面539
9.3.6又是局部性救了我们539
9.4虚拟存储器作为存储器管理的工具540
9.5虚拟存储器作为存储器保护的工具541
9.6地址翻译542
9.6.1结合高速缓存和虚拟存储器544
9.6.2利用tlb加速地址翻译545
9.6.3多级页表546
9.6.4综合：端到端的地址翻译547
9.7案例研究：intel core i7/linux存储器系统550
9.7.1core i7地址翻译551
9.7.2linux虚拟存储器系统554
9.8存储器映射556
9.8.1再看共享对象557
9.8.2再看fork函数558
9.8.3再看execve函数559
9.8.4使用mmap函数的用户级存储器映射559
9.9动态存储器分配561
9.9.1malloc和free函数561
9.9.2为什么要使用动态存储器分配563
9.9.3分配器的要求和目标564
9.9.4碎片565
9.9.5实现问题565
9.9.6隐式空闲链表565
9.9.7放置已分配的块567
9.9.8分割空闲块567
9.9.9获取额外的堆存储器567
9.9.10合并空闲块568
9.9.11带边界标记的合并568
9.9.12综合：实现一个简单的分配器570
9.9.13显式空闲链表576
9.9.14分离的空闲链表576
9.10垃圾收集578
9.10.1垃圾收集器的基本知识579
9.10.2mark&sweep垃圾收集器580
9.10.3c程序的保守mark&sweep580
9.11c程序中常见的与存储器有关的错误581
9.11.1间接引用坏指针582
9.11.2读未初始化的存储器582
9.11.3允许栈缓冲区溢出582
9.11.4假设指针和它们指向的对象是相同大小的583
9.11.5造成错位错误583
9.11.6引用指针，而不是它所指向的对象583
9.11.7误解指针运算584
9.11.8引用不存在的变量584
9.11.9引用空闲堆块中的数据584
9.11.10引起存储器泄漏585
9.12小结585
参考文献说明586
家庭作业586
练习题答案589
第三部分程序间的交互和通信
第10章系统级i/o596
10.1unix i/o596
10.2打开和关闭文件597
10.3读和写文件598
10.4用rio包健壮地读写599
10.4.1rio的无缓冲的输入输出函数600
10.4.2rio的带缓冲的输入函数600
10.5读取文件元数据604
10.6共享文件606
10.7i/o重定向608
10.8标准i/o609
10.9综合：我该使用哪些i/o函数610
10.10小结611
参考文献说明612
家庭作业612
练习题答案612
第11章网络编程614
11.1客户端-服务器编程模型614
11.2网络615
11.3全球ip因特网618
11.3.1ip地址619
11.3.2因特网域名620
11.3.3因特网连接623
11.4套接字接口625
11.4.1套接字地址结构625
11.4.2socket函数626
11.4.3connect函数626
11.4.4open_clientfd函数627
11.4.5bind函数628
11.4.6listen函数628
11.4.7open_listenfd函数628
11.4.8accept函数629
11.4.9echo客户端和服务器的示例630
11.5web服务器633
11.5.1web基础633
11.5.2web内容633
11.5.3http事务634
11.5.4服务动态内容636
11.6综合：tiny web服务器639
11.7小结645
参考文献说明645
家庭作业646
练习题答案646
第12章并发编程648
12.1基于进程的并发编程649
12.1.1基于进程的并发服务器649
12.1.2 关于进程的优劣651
12.2基于i/o多路复用的并发编程651
12.2.1基于i/o多路复用的并发事件驱动服务器653
12.2.2i/o多路复用技术的优劣657
12.3基于线程的并发编程657
12.3.1线程执行模型657
12.3.2posix线程658
12.3.3创建线程659
12.3.4终止线程659
12.3.5回收已终止线程的资源660
12.3.6分离线程660
12.3.7初始化线程660
12.3.8一个基于线程的并发服务器661
12.4多线程程序中的共享变量662
12.4.1线程存储器模型663
12.4.2将变量映射到存储器663
12.4.3共享变量664
12.5用信号量同步线程664
12.5.1进度图667
12.5.2信号量668
12.5.3使用信号量来实现互斥669
12.5.4利用信号量来调度共享资源670
12.5.5综合：基于预线程化的并发服务器674
12.6使用线程提高并行性676
12.7其他并发问题680
12.7.1线程安全680
12.7.2可重入性682
12.7.3在线程化的程序中使用已存在的库函数682
12.7.4竞争683
12.7.5死锁685
12.8小结687
参考文献说明687
家庭作业688
练习题答案691
附录a错误处理694
a.1unix系统中的错误处理694
a.2 错误处理包装函数696
参考文献698

6. java编程思想关于并发的那章怎么样

不知道你的是第几版。前面几章讲面向对象的最重要，是JAVA基本的思想和机制，好像一直到容器那章之前吧。
中间的讲API的可以选择性的看看，新手的话还是多学学例子，对于快速上手比较好。不过能边实践边看的话效果最好，因为API使用这东西很多都靠经验积累。
后面的讲异常和多线程的也比较重要，属于JAVA语言比较精华的部分。
建议前面几章一定要吃透背熟，看后面的例子就不会有什么问题了。异常和多线程精读。

接下来有一定实践经验后去读《effective java》第二版，提升境界之作

再然后去读java虚拟机的书，据说这本不错http://book.360buy.com/10697182.html，我买了还没怎么看。还有这本《JAVA深度历险》http://book.douban.com/subject/1119896/，读过一次，很有意思

java学习我推荐以下几本：

Head First Java : 这本才是最适合入门的，也是整个Head First系列奠基之作。
Java Programming Language ： 恐怕没有人比java的作者Gosling更有资格诠释java背后的设计哲学和使用思想了，进阶之选。
Effective Java: 这本是真正的经典，以小见大，其中编程相关的内容已经超越了单一语言本身，无论是否java使用者都值得一看
Core Java: 在以前这本可以做参考手册，现在不好说。
从总的趋势来看，Java社区在逐渐转向scala或clojure，推荐继续学习这两门语言，并比较他们与java的优越之处。

7. Linux/UNIX网络编程的目录

序
前言
第1章TCP/IP简介
1.1概述
l.1.1基本的C/S服务模型
1.1.2OSI模型和TCP/IP四层结构
1.2IP协议介绍
1.2.lIP数据报的格式
1.2.2IP地址
1.2.3子网掩码(subnetmask)
1.3TCP协议介绍
1.3.1TCP连接的建立与终止
1.3.2TCP状态转换图
1.4LJDP协议
1.5端口号
1.6本章小结
1.7实战检验
理论巩固
第2章套接字编程简介
2.1套接字基础
2.2套接字的类型
2.3套接字地址结构
2.3.1I.Pv4套接字地址结构
2.3.2IPv6套接字地址结构
2.3.3两种套接字地址结构的比较
2.3.4通用套接字地址结构
2.4套接字基本函数
2.4.1字节排序函数
2.4.2字节操纵函数
2.4.3IP地址转换函数
.2.4.4isfdtype()函数
2.5值.结果参数
2.6本章小结
2.7实战检验
理论巩固
上机实战
第3章基本l'CP套接字编程
3，1TCP套接字编程
3.1.1socket()函数
3.1.2connect()函数
3.1.3bind()函数
3.1.4listen()函数
3.1.5accept()函数
3.1.6数据传输函数
3.1.7close()函数
3.2TCP套接字编程实例
3.3服务器的3种异常情况
3.3.1服务器主机崩溃
3.3.2服务器主机崩溃后重启
3.3.3服务器主机关闭
3.4本章小结
3.5实战检验+
理论巩固
上机实战
第4章基本UDP套接口编程
4.1UDP套接字编程
4.1.1recvfrom()函数
4.1.2sendto函数
4.2UDP套接字编程实例
4.3UDP中对数据报的各项处理
4.3.1数据报的丢失
4.3.2验证收到的响应
4.3.3服务器进程未运行
4.4connect函数用于
4.5本章小结
4.6实战检验
理论巩固
上机实战
第5章并发服务器
5.1服务器的分类
5.2多进程并发服务器
5.2.1进程基础
5.2.2进程创建
5.2.3进程终止L
5.2.4多进程并发服务器
5.2.5多进程并发服务器实例
5.3多线程服务器
5.3.1线程基础
5.3.2线程基础函数
5.3.3给新线程传递参数
5.3.4多线程并发服务器实例
5.3.5线程安全函数
5.3.6线程安全实例
5.3.7用函数参变量实现线程安全性
5.4本章小结
5.5实战检验
理论巩固
上机实战
第6章名字与地址转换编程；
6.1概述.
6.2域名系统.
6.3gethostbyname()函数
6.4RES—USE—INET6解析器选项
6.5gethostbyname2函数对IPv6的支持
6.6gethostbyaddr()函数
6.7uname()函数
6.8gethostname函数
6.9getservbyname和getservbyport函数
6.10getaddrinfo、gai_strerror.和host—serv函数
6.11freeaddrinfo函数
6.12使用getaddrinfo的了CP和IJD
6.13getnameinfo函数
6.14gethostbyaddr实例
6.15本章小结
6.16实战检验
理论巩固
上机实战
第7章IPv4和IPv6编程
7.1IPv4客户与IPv6服务器
7.2IPv6客户与IPv4服务器
7.3IPv6一ADDRFORM套接口选顼
7.4IPv6地址测试宏
7.5源代码的可移植性
7.6本章小结
7.7实战检验
理论巩固
上机实战
第8章守护进程和inetd超级服务器
8.1守护进程的原理
8.1.1启动守护进程
8.1.2输出守护进程消息
8.1.3syslog函数
8.1.4创建守护进程
8.1.5以守护进程方式运行的时间服务器
8.2inetd的工作原理
8.2.1概念
8.2.2工作流程
8.2.3inetd处理并发
8.3本章小结
8.4实战检验
理论巩固
上机实战
第9章I/0编程
9.1I/O模型
9.2select函数
9.3shutdown函数
9.4poll函数
9.5使用select函数的TCP例子
9.6高级的I/O编程
9.6.1recv和send函数
9.6.2recvmsg和sendmsg函数
9.7非阻塞connect
9.8ioctl函数
9.8.1套接口操作
9.8.2文件操作
9.8.3接口配置
9.8.4接口操作
9.8.5ARP操作
9.8.6路由表操作
9.9本章小结
9.10实战检验
理论巩固
上机实战
第10章广播与多播编程
10.1广播的概念
10.1.1广播的原理
10.1.2广播的示例
10.2多播概念
10.2.1多播与广播的比较
10.2.2多播套接口选项
10.2.3多播的实例
10.3本章小结
10.4理论与巩固
实战检验
上机实战
第1P章路由套接口编程
11.1概念和数据链路套接口地址结构
1].2sysctl操作
11.3接口名和索引函数
]1.4本章小结
11.5实战检验
理论与巩固
上机实战
第72章信号量编程
12.1信号的概念
12.2信号的概念及常见信号介绍
12.2.1signal函数
12.2.2处理SIGCHLD信号
12.2.3wait和waitpid函数
12.2.4kill和raise函数
12.2.5SIGPIPE信号
12.2.6alarm和pause函数
12.2.7sigprocmask函数
12.2.8sigpending函数
12.2.9sigaction函数
12.2.10sigsetjmp和siglongjmp函数
12.2.l1sigsuspend函数
12.2.12abort函数
12.2.13system函数
12.2.14sleep函数
12.3例子：使用SIGIO的UDP回射服务器程序
12.4，本章小结
12.5实战检验
理论巩固
上机实战
第P3章原始套接口与数据链路访问编程
13.1原始套接口创建
13.2原始套接口输出
]3.3原始套接口输入
13.4原始套接字编程实例
13.4.1实例l：拒绝服务攻击
13.4.2实例2：ICMP包的构建、发送和接收
13.4.3实例3：ping程序
13.5数据链路层访问
13.5.1BPF：BSD分组过滤器
13.5.2数据链路提供者DLPI
13.5.3Linux的SOCKPACKET20
13.5.4分组捕获函数库libpca
13.5.5libpcap的库函数
13.5.6数据链路层访问实例
13.6本章小结
13.7理论与巩固
实战检验
上机实战
第P4章实验指导
14.1Socket基本编程
14.2服务器与单客户的连接处理
14.3多进程服务器模板
14.4多线程编写模板
14.5线程专用数据TSD实现模板
参考文献

8. 深入理解计算机系统的目录1

1 A Tour of Computer Systems
1.1 Information is Bits + Context
1.2 Programs Are Translated by Other Programs into Different Forms
1.3 It Pays to Understand How Compilation Systems Work
1.4 Processors Read and Interpret Instructions Stored in Memory
1.5 Caches Matter
1.6 Storage Devices Form a Hierarchy
1.7 The Operating System Manages the Hardware
1.8 Systems CommunicateWith Other Systems Using Networks
1.9 The Next Step
1.10 Summary
Bibliographics Notes
Part I Program Structure and Execution
2 Representing and Manipulating Information
2.1 Information Storage
2.2 Integer Representations
2.3 Integer Arithmetic
2.4 Floating Point
2.5 Summary
Bibliographic Notes
Homework Problems
Solution to Practice Problems
3 Machine-Level Representation of Programs
3.1 A Historical Perspective
3.2 Program Encodings
3.3 Data Formats
3.4 Accessing Information
3.5 Arithmetic and Logical Operations
3.6 Control
3.7 Proceres
3.8 Array Allocation and Access
3.9 Heterogeneous Data Structures
3.10 Alignment
3.11 Putting it Together: Understanding Pointers
3.12 Life in the RealWorld: Using the GDB Debugger
3.13 Out-of-Bounds Memory References and Buffer Over
3.14 *Floating-Point Code
3.15 *Embedding Assembly Code in C Programs
3.16 Summary
Bibliographic Notes
Homework Problems
Solutions to Practice Problems
4 Processor Architecture
5 Optimizing Program Performance
6 The Memory Hierarchy
Part Ⅱ Running Programs on a System
7 Linking
8 Exceptional Control Flow
9 Measuring Program Execution Time
10 Virtual Memory
Part Ⅲ Interaction and Communication Between Programs
11 System-Level I/O
12 Network Programming
13 Concurrent Programming
A HCL Descriptions of Processor Control Logic
B Error Handling
Bibliography
Index
目录：
第1章 计算机系统漫游
1.1 信息就是比特+上下文
1.2 程序被其他程序翻译成不同的格式
1.3 了解编译系统如何工作是大有益处的
1.4 处理器读并解释储存在存储器中的指令
1.4.1 系统的硬件组成
1.4.2 执行hello程序
1.5 高速缓存
1.6 形成层次结构的存储设备
1.7 操作系统管理硬件
1.7.1 进程
1.7.2 线程
1.7.3 虚拟存储器
1.7.4 文件
1.8 利用网络系统和其他系统通信
1.9 下一步
1.10 小结
参考文献说明
第2章 信息的表示和处理
2.1 信息存储
2.2 整数表示
2.3 整数运算
2.4 浮点
2.5 小结
参考文献说明
家庭作业
练习题答案
第3章 程序的机器级表示
3.1 历史观点
3.2 程序编码
3.3 数据格式
3.4 访问信息
3.5 算术和逻辑操作
3.6 控制
3.7 过程
3.8 数组分配和访问
3.9 异类的数据结构
3.10 对齐（alignment）
3.11 综合：理解指针
3.12 现实生活：使用GDB调试器
3.13 存储器的越界引用和缓冲区溢出
3.14 *浮点代码
3.15 *在C程序中嵌入汇编代码
3.16 小结
第4章 处理器体系结构
4.1 Y86指令集体系结构
4.2 逻辑设计和硬件控制语言HCL 271
4.3 Y86的顺序（sequential）实现
4.4 流水线的通用原理
4.5 Y86的流水线实现
4.6小结
第5章 优化程序性能
5.1 优化编译器的能力和局限性
5.2 表示程序性能
5.3 程序示例
5.4 消除循环的低效率
5.5 减少过程调用
5.6 消除不必要的存储器引用
5.7 理解现代处理器
5.8 降低循环开销
5.9 转换到指针代码
5.10 提高并行性
5.11 综合：优化合并代码的效果小结
5.12 分支预测和预测错误处罚
5.13 理解存储器性能
5.14 现实生活：性能提高技术
5.15 确认和消除性能瓶颈
5.16 小结
第6章 存储器层次结构
6.1 存储技术
6.2 局部性
6.3 存储器层次结构
6.4 高速缓冲存储器
6.5 编写高速缓存友好的代码
6.6 综合：高速缓存对程序性能的影响
6.7 综合：利用你程序中的局部性
6.8 小结
参考文献说明
家庭作业
练习题答案
第7章链接
7.1编译器驱动程序
7.2静态链接
7.3目标文件
7.4可重定位目标文件
7.5符号和符号表
7.6符号解析
7.7重定
7.8可执行目标文件
7.9加载可执行目标文件
7.10动态链接共享库
7.11从应用程序中加载和链接共享库
7.12*与位置无关的代码（PIC）
7.13处理目标文件的工具
7.14小结
第8章 异常控制流
8.1异常
8.2进程
8.3系统调用和错误处理
8.4进程控制
8.5信号
8.6非本地跳转
8.7操作进程的工具
8.8小结
第9章 测量程序执行时间
9.1计算机系统上的时间流
9.2通过间隔计数（interval counting）来测量时间
9.3周期计数器
9.4用周期计数器来测量程序执行时间
9.5于gettimeofday函数的测量
9.6综合：一个实验协议
9.7展望未来
9.8现实生活：K次最优测量方法
9.9得到的经验教训
9.10小结
第10章 虚拟存储器
10.1物理和虚拟寻址
10.2地址空间
10.3VM作为缓存的工具
10.4 VM作为存储器管理的工具
10.5 VM作为存储器保护的工具
10.6 地址翻译
10.7 案例研究：Pentium/Linux存储器系统
10.8 存储器映射
10.9 动态存储器分配
10.10 垃圾收集
10.11 C程序中常见的与存储器有关的错误
10.12扼要重述一些有关虚拟存储器的关键概念
10.13 小结
第11章 系统级I/O
11.1 Unix I/O
11.2 打开和关闭文件
11.3 读和写文件
11.4 用RIO包进行健壮地读和写
11.5 读取文件元数据
11.6 共享文件
11.7 I/O重定向
11.8 标准I/O
11.9 综合：我该使用哪些I/O函数？
11.10 小结
第12章 网络编程
12.1 客户端-服务器编程模型
12.2 网络
12.3 全球IP因特网
12.4 套接字接口
12.5 Web服务器
12.6 综合：TINY Web服务器
12.7 小结
第13章 并 发 编 程
13.1 基于进程的并发编程
13.2 基于I/O 多路复用的并发编程
13.3 基于线程的并发编程
13.4 多线程程序中的共享变量
13.5 用信号量同步线程
13.6 综合：基于预线程化的并发服务器
13.7 其他并发性问题
13.8 小结
参考文献说明
家庭作业习题
练习题答案
附录A 处理器控制逻辑的 HCL描述
A.1 HCL参考手册
A.2 SEQ
A.3 SEQ+
A.4 PIPE
附录B 错 误 处 理
B.1 Unix系统中的错误处理
B.2 错误处理包装函数
B.3 csapp.h头文件
B.4 csapp.c源文件

9. Java编程思想第3版的目录

第1章 对象导论
1.1 抽象过程
1.2 每个对象都有一个接口
1.3 每个对象都提供服务
1.4 被隐藏的具体实现
1.5 复用具体实现
1.6 继承：复用接口
1.7 伴随多态的可互换对象
1.8 对象的创建、使用和生命期
1.8.1 集合与迭代器
1.8.2 单根继承结构
1.8.3 向下转型与模板/泛型
1.8.4 确保正确清理
1.9 异常处理：处理错误
1.10 并发性
1.11 持久性
1.12 Java与Internet
1.12.1 Web是什么
1.12.2 客户端编程
1.12.3 服务器端编程
1.12.4 应用
1.13 Java为什么成功
1.13.1 系统易于表达、易于理解
1.13.2 类库的巨大影响力
1.13.3 错误处理
1.13.4 大型程序设计
1.14 Java与C++
1.15 总结
第2章 一切都是对象
2.1 用引用操纵对象
2.2 必须由你创建所有对象
2.2.1 存储到什么地方
2.2.2 特例：基本类型
2.2.3 Java中的数组
2.3 永远不需要销毁对象
2.3.1 作用域
2.3.2 对象的作用域
2.4 创建新的数据类型：类
2.5 方法、参数和返回值
2.6 构建一个Java程序
2.6.1 名字可见性
2.6.2 运用其他构件
2.6.3 static 关键字
2.7 你的第一个Java程序
2.8 注释和嵌入式文档
2.8.1 注释文档
2.8.2 语法
2.8.3 嵌入式HTML
2.8.4 一些标签示例
2.8.5 文档示例
2.9 编码风格
2.10 总结
2.11 练习
第3章 控制程序流程
3.1 使用Java操作符
3.1.1 优先级
3.1.2 赋值
3.1.3 算术操作符
3.1.4 自动递增和递减
3.1.5 关系操作符
3.1.6 逻辑操作符
3.1.7 按位操作符
3.1.8 移位操作符
3.1.9 三元操作符 if-else
3.1.10 逗号操作符
3.1.11 字符串操作符+
3.1.12 使用操作符时常犯的错误
3.1.13 类型转换操作符
3.1.14 Java没有“sizeof”
3.1.15 再论优先级
3.1.16 操作符小结
3.2 执行流程控制
3.2.1 true和false
3.2.2 if-else
3.2.3 return
3.2.4 迭代
3.2.5 do-while
3.2.6 for
3.2.7 break和 continue
3.2.8 switch
3.3 总结
3.4 练习
第4章 初始化与清理
4.1 用构造器确保初始化
4.2 方法重载
4.2.1 区分重载方法
4.2.2 涉及基本类型的重载
4.2.3 以返回值区分重载方法
4.2.4 缺省构造器
4.2.5 this关键字
4.3 清理：终结处理和垃圾回收
4.3.1 finalize()的用途何在
4.3.2 你必须实施清理
4.3.3 终结条件
4.3.4 垃圾回收器如何工作
4.4 成员初始化
4.4.1 指定初始化
4.4.2 构造器初始化
4.5 数组初始化
4.6 总结
4.7 练习
第5章 隐藏具体实现
5.1 包：程序库单元
5.1.1 创建独一无二的包名
5.1.2 定制工具库
5.1.3 用 import改变行为
5.1.4 对使用包的忠告
5.2 Java访问权限修饰词
5.2.1 包访问权限
5.2.2 public:接口访问权限
5.2.3 private: 你无法访问
5.2.4 protected：继承访问权限
5.3 接口和实现
5.4 类的访问权限
5.5 总结
5.6 练习
第6章 复用类
6.1 组合语法
6.2 继承语法
6.3 结合使用组合和继承
6.3.1 确保正确清理
6.3.2 名称屏蔽
6.4 在组合与继承之间选择
6.5 protected关键字
6.6 增量开发
6.7 向上转型
6.8 final关键字
6.8.1 final 数据
6.8.2 final 方法
6.8.3 final 类
6.8.4 有关final的忠告
6.9 初始化及类的加载
6.10 总结
6.11 练习
第7章 多态
7.1 再论向上转型
7.2 转机
7.2.1 方法调用绑定
7.2.2 产生正确的行为
7.2.3 可扩展性
7.2.4 缺陷：“覆盖”私有方法
7.3 抽象类和抽象方法
7.4 构造器和多态
7.4.1 构造器的调用顺序
7.4.2 继承与清理
7.4.3 构造器内部的多态方法的行为
7.5 用继承进行设计
7.5.1 纯继承与扩展
7.5.2 向下转型与运行时类型识别
7.6 总结
7.7 练习
第8章 接口与内部类
……
第9章 通过异常处理错误
第10章 类型检查
第11章 对象的集合
第12章 Java I/O系统
第13章 并发
第14章 创建窗口与applet程序
第15章 发现问题
第16章 分析与设计
附录A 对象的传递与返回
附录B Java编程指南
附录C 补充材料
附录D 资源
索引