Java技术精髓

第一部分  概述                  
 第1章  一般性能                  
 1. 1　性能与优化                  
 1. 2　性能的生命周期                  
 1. 2. 1　编码前                  
 1. 2. 2　编码期间                  
 1. 2. 3　编码后                  
 1. 3　性能问题的类型                  
 1. 4　简单性能层                  
 1. 5　应用程序设计层                  
 1. 5. 1　不好的设计选择                  
 1. 5. 2　信息隐藏                  
 1. 6　物理层                  
 1. 6. 1　Java语言及其环境                  
 1. 6. 2  Java与其他环境的交互                  
 1. 6. 3  持久Java对象                  
 1. 6. 4　时间. 距离和空间                  
 第2章　识别Java性能的工具                  
 2. 1　Java特有的工具                  
 2. 1. 1　Java分析工具                  
 2. 1. 2　第三方Java分析工具                  
 2. 1. 3　简单的计时测量                  
 2. 1. 4  Verbosegc选项                  
 2. 2　PerfMonitor类                  
 2. 3  系统工具：Windows NT性能监视器                  
 2. 4　本章小结                  
 第3章  Java性能问题涉及的领域                  
 3. 1　基本的计时比较                  
 3. 2　即时编译和静态编译                  
 3. 3　创建和重用对象                  
 3. 4　使用常量                  
 3. 5　使用字符串                  
 3. 6　异常的用法                  
 3. 7　循环技术                  
 3. 7. 1　循环常量                  
 3. 7. 2　本地变量                  
 3. 7. 3　尽早地终止循环                  
 3. 8　造型技术                  
 3. 8. 1　避免丢失类信息                  
 3. 8. 2　避免Instanceof和造型相邻使用                  
 3. 8. 3　避免不必要的造型和Instanceof                  
 3. 9　同步                  
 3. 10　垃圾回收                  
 3. 11　集合                  
 3. 11. 1　集合框架                  
 3. 11. 2　一般用途的实现                  
 3. 11. 3　向量                  
 3. 11. 4　哈希表                  
 3. 12　本章小结                  
 第二部分　物理性能                  
 第4章　本地／远程问题                  
 4. 1　实现远程对象的可能途径                  
 4. 1. 1　远程方法调用                  
 4. 1. 2　企业级Java Bean                  
 4. 1. 3  SanFrancisco的基础层                  
 4. 2　远程访问的开销                  
 4. 2. 1　如何在Java中书写和使用远                  
 程服务程序                  
 4. 2. 2　改变方法调用的粒度                  
 4. 2. 3　远程访问的谱线                  
 4. 2. 4　对象粒度                  
 4. 2. 5　性能粒度的含义                  
 4. 2. 6　正确放置数据                  
 4. 2. 7　对象的亲合力                  
 4. 2. 8　划分                  
 4. 3　本章小结                  
 第5章　粒度                  
 5. 1　接口粒度                  
 5. 2　实现粒度                  
 5. 3　粒度和性能                  
 5. 3. 1　例1：一个细粒度设计                  
 5. 3. 2　例2：串行化定单行对象                  
 5. 4　本章小结                  
 第6章　瓶颈                  
 6. 1　为什么很难避免瓶颈                  
 6. 2　同步瓶颈                  
 6. 3　加锁瓶颈                  
 6. 3. 1　对象和加锁                  
 6. 3. 2　死锁和锁排序                  
 6. 4　垃圾回收瓶颈                  
 6. 5　分布式垃圾回收                  
 6. 6　本章小结                  
 第三部分　基准测试                  
 第7章　Java基准测试概述                  
 7. 1　Java测试程序                  
 7. 1. 1  Pendragon SoffeineMark 3. 0                  
 7. 1. 2  JMark 2. 0                  
 7. 1. 3  VolanoMark 2. 1                  
 7. 1. 4  SPECjvm 98                  
 7. 2　一个简单的测试程序                  
 7. 3　本章小结                  
 第8章　应用级基准测试                  
 8. 1　BOB基准测试                  
 8. 1. 1  TPC-C概述                  
 8. 1. 2　BOB结构                  
 8. 2　BOB的运行                  
 8. 3　BOB的实现                  
 8. 3. 1　测试程序基础结构                  
 8. 3. 2　测试程序事务                  
 8. 4　测试程序实体                  
 8. 5　本章小结                  
 第四部分　应用程序环境                  
 第9章　SanFrancisco及其性能                  
 9. 1  SanFrancisco概述                  
 9. 2　基础层                  
 9. 2. 1　基础层对象模型基类                  
 9. 2. 2　业务对象的生命周期                  
 9. 2. 3　实体的生命周期                  
 9. 2. 4　集合和查询                  
 9. 2. 5　其他基类                  
 9. 2. 6　基础对象模型服务                  
 9. 3　通用业务对象层                  
 9. 4　核心业务处理层                  
 9. 5　有用的参考资料                  
 9. 5. 1　有关SanFrancisco的书籍                  
 9. 5. 2  有关SanFrancisco的文章                  
 9. 5. 3  有关SanFrancisco的IBM Redbooks                  
 9. 6　本章小结                  
 第10章  企业级Java Beans及其性能                  
 10. 1  J2EE体系结构和技术                  
 10. 2  企业级Java Beans                  
 10. 2. 1　选择一个实现                  
 10. 2. 2　EJB的实现及其性能                  
 10. 3  EJB体系结构及其性能                  
 10. 3. 1  Session Bean                  
 10. 3. 2  Entity Bean                  
 10. 3. 3  Entity Bean的特点                  
 10. 3. 4  EJB的粒度                  
 10. 3. 5  Session Bean和Entity Bean的比较                  
 10. 4  EJS中的特性研究                  
 10. 5　本章小结                  
 第11章  CORBA及Java                  
 11. 1  CORBA概述                  
 11. 2  Java IDL                  
 11. 3  RMI-IIOP                  
 11. 4  RMI over IIOP的性能影响                  
 11. 5　本章小结                  
 第12章　Jini及其性能                  
 12. 1  Jini概述                  
 12. 1. 1　查找                  
 12. 1. 2　发现                  
 12. 1. 3　租借                  
 12. 1. 4　远程事件                  
 12. 1. 5　事务                  
 12. 2　Jini中的性能考虑                  
 12. 3　本章小结                  
 第五部分　应用程序模型                  
 第13章　Java的使用                  
 13. 1　网外                  
 13. 2　网内                  
 13. 3　应用程序连接                  
 13. 4　数据库上                  
 13. 5　应用程序包装                  
 13. 6　对象下                  
 13. 7　组合方法                  
 13. 8　本章小结                  
 第14章　性能含义                  
 14. 1　网外                  
 14. 2　网内                  
 14. 3　应用程序连接                  
 14. 3. 1　字符编码及尾数                  
 14. 3. 2　远程对象的累积                  
 14. 4　应用程序包装                  
 14. 4. 1　过多的客户交互                  
 14. 4. 2　容量限制                  
 14. 4. 3　减少客户一服务器交互                  
 14. 5　数据库上                  
 14 6　对象下                  
 14. 6. 1  过多的客户交互                  
 14. 6. 2　过多的远程对象交互                  
 14. 6. 3　过多的中件交互                  
 14. 6. 4　内存泄漏和对象驻留                  
 14. 6. 5　过多的垃圾回收                  
 14. 7　本章小结                  
 第六部分　扩大应用程序规模                  
 第15章　系统调整                  
 15. 1　调整内存和系统                  
 15. 1. 1  SanFrancisco解决方案                  
 15. 1. 2  EJB解决方案                  
 15. 1. 3　调整数据库                  
 15. 1. 4　操作系统内存分配                  
 15. 1. 5　平衡内存要求                  
 15. 2　磁盘配置                  
 15. 3　网络配置                  
 15. 4　性能调整的过程                  
 15. 5　本章小结                  
 第16章　大规模的影响                  
 16. 1　应用程序及其环境                  
 16. 1. 1  内存                  
 16. 1. 2　处理器                  
 16. 1. 3　输入／输出                  
 16. 1. 4　软件                  
 16. 2　大规模的影响                  
 16. 3　SMP和堆影响                  
 16. 3. 1　在SMP上的堆分配和垃圾回收                  
 16. 3. 2　为什么需要多重服务器                  
 16. 3. 3　对象的布局. 访问和复制                  
 16. 4　本章小结                  
 附录A　使用的机器