书籍详情

Java线程编程

Java线程编程

作者:(美)Paul Hyde著;周良忠译

出版社:人民邮电出版社

出版时间:2003-01-01

ISBN:9787115117915

定价:¥52.00

购买这本书可以去
内容简介
  本书以丰富的实例、由浅至深的方式全面讲解如何用Java进行多线程编程。全书分三部分。第一部分(第1章~第10章)介绍基础概念,包括线程、线程组、Swing、线程同步、线程优先级、启动和终止线程、线程间通信等。第二部分(第11章~第18章)介绍一些重要的多线程编程技术,包括自运行对象、异常回调、线程池、完全超时、摆脱阻塞的I/O状态、先进先出(FIFO)队列以及运用类SureStop和BooleanLock等。第三部分为附录,提供了Thread API和ThreadGroup API的相关材料。 本书可以帮助具有Java基本编程知识的程序员学习多线程编程。
作者简介
  译者:周良忠畅销图书《C++实践之路》的译者周良忠,1970年生。本科毕业于武汉化工学院计算机应用专业。1995毕业于中国科学院武汉岩土力学研究所,获硕士学位,1997年获得博士学位。1998年创办云巅工作室(http://www.cloudcrown.com),为个人、中小企业提供专业软件定做服务。近几年开发了多款广受欢迎的共享软件。精通C++、C#、Java、Perl等开发语言。2001年开始从事计算机科技图书的创作和翻译工作,最新翻译力作有《C#PrimerPlus中文版》、《C++实践之路》等。SymbianOS软件开发开发:应用C++开发智能手机应用程序入门>>更多作品
目录
第一部分  线    程                  
 第1章  线程简介 3                  
 1.1  什么是线程 4                  
 1.2  为什么使用多线程 4                  
 1.2.1  与用户的更佳交互 4                  
 1.2.2  同步动作的模拟 5                  
 1.2.3  利用多处理器 5                  
 1.2.4  等待缓慢I/O操作时完成其他任务 5                  
 1.2.5  简化对象模型 6                  
 1.3  不宜采用多线程的场合 7                  
 1.4  Java的内置线程支持 7                  
 1.5  易于起步, 难以掌握 7                  
 第2章  一个简单的双线程实例 9                  
 2.1  扩展java.lang.Thread类 10                  
 2.2  覆盖run()方法 11                  
 2.3  创建新线程 12                  
 2.4  综合运用 13                  
 2.5  小结 14                  
 第3章  创建和启动线程 15                  
 3.1  使用Thread.currentThread() 16                  
 3.2  线程命名:getName()和setName() 18                  
 3.2.1  使用getName() 18                  
 3.2.2  使用setName() 21                  
 3.3  线程构造函数 22                  
 3.4  激活线程:start()和isAlive() 24                  
 3.5  使用Thread.sleep() 26                  
 3.6  小结 28                  
 第4章  实现Runnable接口与扩展Thread类 30                  
 4.1  可视定时器图形组件 31                  
 4.2  能扩展Thread和JComponent吗 37                  
 4.3  接口java.lang.Runnable 38                  
 4.4  把Runnable对象传递给Thread的构造函数 38                  
 4.5  修改SecondCounter来使用Runnable 39                  
 4.6  检查SecondCounter的准确性 45                  
 4.7  提高SecondCounter的准确性 49                  
 4.8  小结 54                  
 第5章  完美终止线程 55                  
 5.1  中断线程:interrupt() 56                  
 5.1.1  中断休眠线程 58                  
 5.1.2  待决中断 56                  
 5.1.3  使用isInterrupted() 59                  
 5.1.4  使用Thread.interrupted() 60                  
 5.1.5  使用InterruptedException 61                  
 5.2  挂起和恢复线程执行 63                  
 5.2.1  使用淘汰的方法suspend()和resume() 63                  
 5.2.2  在不恰当的时候挂起 67                  
 5.2.3  不使用淘汰方法实现挂起和恢复 70                  
 5.3  终止线程 74                  
 5.3.1  使用淘汰的方法stop() 74                  
 5.3.2  取代stop() 76                  
 5.4  stop(). suspend()和resume()的最佳替代 78                  
 5.5  守护线程 84                  
 5.6  小结 86                  
 第6章  线程优先化 87                  
 6.1  系统线程优先级 88                  
 6.2  线程优先级常量 89                  
 6.2.1  Thread.MAX_PRIORITY 89                  
 6.2.2  Thread.MIN_PRIORITY 89                  
 6.2.3  Thread.NORM_PRIORITY 89                  
 6.3  判断当前优先级:getPriority() 89                  
 6.4  更改线程的优先级:setPriority() 91                  
 6.5  线程状态 94                  
 6.6  优先级和规划 96                  
 6.7  自愿放弃处理器:Thread.yield() 96                  
 6.8  线程规划情形 102                  
 6.8.1  情形一:一个高优先级线程独占处理器 102                  
 6.8.2  情形二:所有高优先级线程独占处理器 102                  
 6.8.3  情形三:所有线程均获得一定的处理器时间 102                  
 6.9  小结 103                  
 第7章  并发访问对象和变量 104                  
 7.1  易变成员变量修饰符 105                  
 7.2  同步方法修饰符 110                  
 7.2.1  两个线程同时位于一个对象的同一个方法中 110                  
 7.2.2  同一时刻一个线程 112                  
 7.2.3  两个线程, 两个对象 115                  
 7.2.4  避免对象的意外崩溃 117                  
 7.2.5  对象处于不一致状态时, 推迟对它的访问 121                  
 7.3  同步语句块 126                  
 7.3.1  减少持有锁的时间 126                  
 7.3.2  锁定任意对象, 而非仅仅锁定当前对象 127                  
 7.3.3  把向量内容安全地复制到数组 128                  
 7.4  静态同步方法 130                  
 7.5  在同步语句中使用类级别锁 134                  
 7.6  同步化和集合API 136                  
 7.6.1  封装集合, 使之同步化 136                  
 7.6.2  安全地把列表中的内容复制到数组 137                  
 7.6.3  安全遍历集合元素 139                  
 7.7  死锁 141                  
 7.8  加速并发访问 145                  
 7.9  小结 145                  
 第8章  线程间通信 147                  
 8.1  线程间通信的必要性 148                  
 8.2  等待/通知机制 148                  
 8.2.1  最小规模的等待/通知 148                  
 8.2.2  典型等待/通知 150                  
 8.2.3  运用同步方法的等待/通知 151                  
 8.3  用于等待/通知的对象API 153                  
 8.3.1  notify() 153                  
 8.3.2  notifyAll() 153                  
 8.3.3  wait() 153                  
 8.3.4  wait(long) 154                  
 8.3.5  wait(long, int) 154                  
 8.4  何时使用notifyAll()代替notify() 154                  
 8.5  遗漏通知 155                  
 8.5.1  MissedNotify 155                  
 8.5.2  MissedNotifyFix 159                  
 8.6  早期通知 163                  
 8.6.1  EarlyNotify 164                  
 8.6.2  EarlyNotifyFix 167                  
 8.7  示例CubbyHole 171                  
 8.8  使用join()等待线程的消亡 177                  
 8.8.1  join() 177                  
 8.8.2  join(long) 177                  
 8.8.3  join(long, int) 177                  
 8.8.4  JoinDemo 178                  
 8.9  使用管道在线程间流动数据 181                  
 8.9.1  PipedBytes 182                  
 8.9.2  PipedCharacters 185                  
 8.10  使用ThreadLocal和InheritableThreadLocal 188                  
 8.10.1  ThreadLocal API 189                  
 8.10.2  ThreadID 189                  
 8.10.3  InheritableThreadLocal API 192                  
 8.10.4  InheritableThreadID 192                  
 8.11  小结 198                  
 第9章  线程和Swing 199                  
 9.1  为什么Swing工具包不是多线程安全 200                  
 9.2  使用SwingUtilities.invokeAndWait() 201                  
 9.3  使用SwingUtilities.invokeLater() 204                  
 9.4  使用SwingUtilities.isEventDispatchThread() 207                  
 9.5  何时不需要invokeAndWait()和invokeLater() 207                  
 9.6  在GUI设置中使用工作线程的必需性 208                  
 9.7  使用工作线程减轻事件线程的负担 213                  
 9.8  在自定义组件中滚动文本 220                  
 9.9  动画显示一系列图像 225                  
 9.10  在JLabel上显示流逝的时间 229                  
 9.11  在容器内浮动组件 233                  
 9.12  小结 238                  
 第10章  线程组 239                  
 10.1  什么是线程组 240                  
 10.2  使用getParent() 241                  
 10.3  查找线程组的子组 241                  
 10.4  使用Thread的getThreadGroup()方法 242                  
 10.5  查找线程组中的所有线程 242                  
 10.6  理解线程组的安全性 242                  
 10.7  使用setMaxPriority()和getMaxPriority() 243                  
 10.8  使用interrupt() 243                  
 10.9  淘汰的方法:stop(). suspend()和resume() 243                  
 10.10  类ThreadViewer 243                  
 10.11  小结 252                  
 第二部分  技    术                  
 第11章  自运行对象 255                  
 11.1  简单自运行类 256                  
 11.2  使用内部类来隐藏run() 259                  
 11.3  要考虑的额外功能 261                  
 11.4  小结 267                  
 第12章  异常回调 268                  
 12.1  ExceptionListener接口 269                  
 12.2  支持ExceptionListener的辅助方法 269                  
 12.3  小结 276                  
 第13章  线程池 277                  
 13.1  线程池的好处 278                  
 13.2  线程池的考虑与开销 278                  
 13.3  泛型线程池:ThreadPool 279                  
 13.4  专门工作线程池:HttpServer 288                  
 13.4.1  类HttpServer 289                  
 13.4.2  类HttpWorker 296                  
 13.4.3  服务文件示例 305                  
 13.4.4  用3个工作线程运行HttpServer 307                  
 13.4.5  用10个工作线程来运行HttpServer 309                  
 13.5  小结 310                  
 第14章  等待完全超时 311                  
 14.1  意外提前返回 312                  
 14.2  判断是否应当再次调用wait() 315                  
 14.3  通用等待-直到模式 319                  
 14.4  小结 325                  
 第15章  摆脱阻塞I/O状态的束缚 326                  
 15.1  read()方法忽略中断和终止请求 327                  
 15.2  关闭流来摆脱阻塞状态 329                  
 15.2.1  类CalcServer与摆脱阻塞的accept() 330                  
 15.2.2  类CalcWorker与摆脱阻塞的read() 333                  
 15.2.3  类CalcClient 336                  
 15.2.4  运行CalcClient的输出 337                  
 15.3  被中断时抛出InterruptedIOException 338                  
 15.3.1  类ThreadedInputStream 338                  
 15.3.2  类BufferedThreadedInputStream 347                  
 15.4  针对可中断I/O使用BufferedThreadedInputStream 349                  
 15.5  小结 354                  
 第16章  SureStop的运用 356                  
 16.1  使用SureStop的原则 357                  
 16.2  SureStop类 357                  
 16.3  使用SureStopVerbose的分析 363                  
 16.4  用SureStopDemo演示SureStop的工作方式 369                  
 16.5  小结 374                  
 第17章  类BooleanLock的运用 375                  
 17.1  背景 376                  
 17.2  类BooleanLock 376                  
 17.3  使用BooleanLock在线程间发送信号 380                  
 17.4  避免阻塞于同步 382                  
 17.4.1  SyncBlock 382                  
 17.4.2  InterruptibleSyncBlock 385                  
 17.5  使用TransitionDetector检测Value的短暂变化 388                  
 17.6  小结 394                  
 第18章  先进先出(FIFO)队列 395                  
 18.1  FIFO队列如何工作 396                  
 18.2  用数组实现FIFO 397                  
 18.3  用Java的简单实现:SimpleObjectFIFO 399                  
 18.4  对象引用的一个扩展FIFO队列:ObjectFIFO 405                  
 18.5  字节的FIFO队列:ByteFIFO 419                  
 18.6  小结 432                  
 第三部分  附    录                  
 附录A  Thread API 435                  
 成员变量 436                  
 Thread.MAX_PRIORITY 436                  
 Thread.MIN_PRIORITY 436                  
 Thread.NORM_PRIORITY 436                  
 构造函数 437                  
 Thread(ThreadGroup, Runnable, String) 437                  
 Thread(ThreadGroup, Runnable) 437                  
 Thread(ThreadGroup, String) 437                  
 Thread(Runnable, String) 437                  
 Thread(Runnable) 438                  
 Thread(String) 438                  
 Thread() 438                  
 静态方法 438                  
 Thread.activeCount() 438                  
 Thread.currentThread() 438                  
 Thread.dumpStack() 438                  
 Thread.enumerate() 439                  
 Thread.interrupted() 439                  
 Thread.sleep(long) 439                  
 Thread.sleep(long, int) 439                  
 Thread.yield() 439                  
 实例方法 440                  
 checkAccess() 440                  
 destroy() 440                  
 getContextClassLoader() 440                  
 getName() 440                  
 getPriority() 440                  
 getThreadGroup() 440                  
 interrupt() 441                  
 isAlive() 441                  
 isDaemon() 441                  
 isInterrupted() 441                  
 join() 441                  
 join(long) 441                  
 join(long, int) 442                  
 run() 442                  
 setContextClassLoader(ClassLoader) 442                  
 setDaemon(boolean) 442                  
 setName(String) 442                  
 setPriority(int) 443                  
 start() 443                  
 toString() 443                  
 被淘汰的方法 443                  
 countStackFrames() 443                  
 resume() 443                  
 stop() 444                  
 stop(Throwable) 444                  
 suspend() 444                  
 附录B  ThreadGroup API 445                  
 构造函数 446                  
 ThreadGroup(ThreadGroup, String) 446                  
 ThreadGroup(String) 446                  
 实例方法 447                  
 activeCount() 447                  
 activeGroupCount() 447                  
 checkAccess() 447                  
 destroy() 447                  
 enumerate(Thread[], boolean) 447                  
 enumerate(Thread[]) 448                  
 enumerate(ThreadGroup[], boolean) 448                  
 enumerate(ThreadGroup[]) 448                  
 getMaxPriority() 448                  
 getName() 448                  
 getParent() 448                  
 interrupt() 449                  
 isDaemon() 449                  
 isDestroyed() 449                  
 list() 449                  
 parentOf(ThreadGroup) 449                  
 setDaemon(boolean) 449                  
 setMaxPriority(int) 449                  
 toString() 450                  
 uncaughtException(Thread, Throwable) 450                  
 被淘汰的方法 450                  
 allowThreadSuspension(boolean) 450                  
 resume() 450                  
 stop() 450                  
 suspend() 451                  
 索引 452                  

猜您喜欢

读书导航