《Java并发编程：核心方法与框架》

编辑推荐

资深Java专家10年经验总结，全程案例式讲解，全面介绍Java并发包相关的技术。以浅白的措辞，结合大量实例模拟实际应用场景，全面解析Java并发包中的核心类、API与并发框架的使用。

Java并发编程无处不在，服务器、数据库、应用，Java并发是永远不可跳过的沟坎，优秀的程序员一定要在Java并发领域进行炼狱式的学习，吸收消化并最终转化成软件产品成果。另外，单纯从Java程序员成长计划这方面进行考虑，Java多线程/并发也依然是想深入学习Java必须要掌握的技术，比如在软件公司中接触的“缓存”，“分布式一致性”，“高并发框架”，“海量数据处理”，“高效订单处理”等都与Java多线程、Java并发紧密相关。进行大数据、分布式、高并发类的专题攻克时，并发编程的学习必不可少，但并发编程学习曲线陡峭，多弯路和“坑”。《Java并发编程：核心方法与框架》基本完全覆盖了Java并发包中核心类、API与并发框架，大程度介绍了每个常用类的使用，以案例的方式进行讲解，以使读者快速学习，迅速掌握。
　　
　　《Java并发编程：核心方法与框架》有以下特点
　　不留遗漏——全面覆盖Java并发知识点；
　　直击要害——实战化案例，精准定位技术细节；
　　学以致用——精要式演示，确保开发/学习不脱节；
　　潜移默化——研磨式知识讲解，参透技术要点；
　　提升效率——垂直式技术精解，不绕弯路；
　　循序提升——渐进式知识点统排，确保连贯。

内容简介

技术畅销书《Java多线程编程核心技术》作者撰写，全程案例式讲解，全面介绍Java并发包相关的技术。以浅白的措辞，结合大量实例模拟实际应用场景，全面解析Java并发包中的核心类、API与并发框架的使用。
　　《Java并发编程：核心方法与框架》共10章。第1章讲解了线程间的同步性，以及线程间的传输数据控制，即Semaphore和Exchanger类的使用。第2章介绍了在同步处理上更加灵活的工具类CountDownLatch和CyclicBarrier，详细到每个类的API的具体使用与应用场景。第3章是第2章的升级，由于CountDownLatch和CyclicBarrier类都有相应的弊端，所以在JDK1.7中新增加了Phaser类来解决这些缺点，该类是熟练掌握JDK并发包的必要知识点。第4章是读者应重点掌握的Executor接口与ThreadPoolExecutor线程池，能有效地提高程序运行效率，更好地统筹线程执行的相关任务。第5章讲解Future和Callable的使用，解决线程需要返回值的情况。第6章介绍Java并发包中的CompletionService的使用，因为可以以异步的方式获得任务执行的结果，所以该接口可以增强程序运行效率。第7章介绍接口ExecutorService，该接口提供了若干工具方法来方便执行并发业务。第8章主要介绍ScheduledExecutorService的使用，以掌握如何将计划任务与线程池结合使用。第9章主要介绍Fork-Join分治编程，以提升多核CPU的优势，加快程序运行效率。第10章主要介绍并发集合框架，利用好并发框架，事半功倍。

作者简介

高洪岩
某世界500强企业高级项目经理，10余年项目管理与开发经验，10年Java相关开发经验，深谙Java技术开发难点与要点，拥有良好的技术素养和丰富的实践经验。精通J2EE核心技术、基于EJB的分布式系统开发、Android移动开发、智能报表、多线程及高并发等相关的技术内容，近期继续关注并发相关的前沿技术。著有技术畅销书《Java多线程编程核心技术》，喜欢将技术与教育相结合的方式共享知识，得以共同提高。生活中喜欢摄影，对轮滑，旅游，航模亦兴趣浓厚。

目录

前言
第1章　Semaphore和Exchanger的使用1
1.1　Semaphore的使用2
1.1.1　类Semaphore的同步性2
1.1.2　类Semaphore构造方法permits参数作用4
1.1.3　方法acquire(intpermits)参数作用及动态添加permits许可数量5
1.1.4　方法acquireUninterruptibly()的使用8
1.1.5　方法availablePermits()和drainPermits()10
1.1.6　方法getQueueLength()和hasQueuedThreads()12
1.1.7　公平与非公平信号量的测试13
1.1.8　方法tryAcquire()的使用15
1.1.9　方法tryAcquire(intpermits)的使用17
1.1.10　方法tryAcquire(longtimeout,TimeUnitunit)的使用17
1.1.11　方法tryAcquire(intpermits,longtimeout,TimeUnitunit)的使用19
1.1.12　多进路-多处理-多出路实验20
1.1.13　多进路-单处理-多出路实验21
1.1.14　使用Semaphore创建字符串池23
1.1.15　使用Semaphore实现多生产者/多消费者模式25
1.2　Exchanger的使用31
1.2.1　方法exchange()阻塞的特性31
1.2.2　方法exchange()传递数据32
1.2.3　方法exchange(Vx,longtimeout,TimeUnitunit)与超时34
1.3　本章总结35
第2章　CountDownLatch和CyclicBarrier的使用36
2.1　CountDownLatch的使用36
2.1.1　初步使用37
2.1.2　裁判在等全部的运动员到来38
2.1.3　各就各位准备比赛39
2.1.4　完整的比赛流程41
2.1.5　方法await(longtimeout,TimeUnitunit)44
2.1.6　方法getCount()的使用46
2.2　CyclicBarrier的使用46
2.2.1　初步使用48
2.2.2　验证屏障重置性及getNumberWaiting()方法的使用51
2.2.3　用CyclicBarrier类实现阶段跑步比赛52
2.2.4　方法isBroken()的使用55
2.2.5　方法await(longtimeout,TimeUnitunit)超时出现异常的测试57
2.2.6　方法getNumberWaiting()和getParties()60
2.2.7　方法reset()62
2.3　本章总结64
第3章　Phaser的使用65
3.1　Phaser的使用66
3.2　类Phaser的arriveAndAwaitAdvance()方法测试166
3.3　类Phaser的arriveAndAwaitAdvance()方法测试268
3.4　类Phaser的arriveAndDeregister()方法测试69
3.5　类Phaser的getPhase()和onAdvance()方法测试70
3.6　类Phaser的getRegisteredParties()方法和register()测试74
3.7　类Phaser的bulkRegister()方法测试75
3.8　类Phaser的getArrivedParties()和getUnarrivedParties()方法测试75
3.9　类Phaser的arrive()方法测试177
3.10　类Phaser的arrive()方法测试278
3.11　类Phaser的awaitAdvance(intphase)方法测试81
3.12　类Phaser的awaitAdvanceInterruptibly(int)方法测试183
3.13　类Phaser的awaitAdvanceInterruptibly(int)方法测试284
3.14　类Phaser的awaitAdvanceInterruptibly(int)方法测试386
3.15　类Phaser的awaitAdvanceInterruptibly(int,long,TimeUnit)方法测试487
3.16　类Phaser的forceTermination()和isTerminated()方法测试89
3.17　控制Phaser类的运行时机92
3.18　本章总结93
第4章　Executor与ThreadPoolExecutor的使用94
4.1　Executor接口介绍94
4.2　使用Executors工厂类创建线程池97
4.2.1　使用newCachedThreadPool()方法创建无界线程池98
4.2.2　验证newCachedThreadPool()创建为Thread池100
4.2.3　使用newCachedThreadPool(ThreadFactory)定制线程工厂102
4.2.4　使用newFixedThreadPool(int)方法创建有界线程池103
4.2.5　使用newFixedThreadPool(int,ThreadFactory)定制线程工厂105
4.2.6　使用newSingleThreadExecutor()方法创建单一线程池106
4.2.7　使用newSingleThreadExecutor(ThreadFactory)定制线程工厂107
4.3　ThreadPoolExecutor的使用107
4.3.1　构造方法的测试107
4.3.2　方法shutdown()和shutdownNow()与返回值119
4.3.3　方法isShutdown()129
4.3.4　方法isTerminating()和isTerminated()129
4.3.5　方法awaitTermination(longtimeout,TimeUnitunit)131
4.3.6　工厂ThreadFactory+execute()+UncaughtExceptionHandler处理异常134
4.3.7　方法set/getRejectedExecutionHandler()138
4.3.8　方法allowsCoreThreadTimeOut()/(boolean)140
4.3.9　方法prestartCoreThread()和prestartAllCoreThreads()142
4.3.10　方法getCompletedTaskCount()144
4.3.11　常见3种队列结合max值的因果效果145
4.3.12　线程池ThreadPoolExecutor的拒绝策略151
4.3.13　方法afterExecute()和beforeExecute()157
4.3.14　方法remove(Runnable)的使用159
4.3.15　多个get方法的测试162
4.3.16　线程池ThreadPoolExecutor与Runnable执行为乱序特性166
4.4　本章总结167
第5章　Future和Callable的使用168
5.1　Future和Callable的介绍168
5.2　方法get()结合ExecutorService中的submit(Callable)的使用168
5.3　方法get()结合ExecutorService中的submit(Runnable)和isDone()的使用170
5.4　使用ExecutorService接口中的方法submit(Runnable,Tresult)170
5.5　方法cancel(booleanmayInterruptIfRunning)和isCancelled()的使用173
5.6　方法get(longtimeout,TimeUnitunit)的使用178
5.7　异常的处理179
5.8　自定义拒绝策略RejectedExecutionHandler接口的使用181
5.9　方法execute()与submit()的区别182
5.10　验证Future的缺点186
5.11　本章总结188
第6章　CompletionService的使用189
6.1　CompletionService介绍189
6.2　使用CompletionService解决Future的缺点190
6.3　使用take()方法193
6.4　使用poll()方法194
6.5　使用poll(longtimeout,TimeUnitunit)方法195
6.6　类CompletionService与异常199
6.7　方法Futuresubmit(Runnabletask,Vresult)的测试205
6.8　本章总结207
第7章　接口ExecutorService的方法使用208
7.1　在ThreadPoolExecutor中使用ExecutorService中的方法208
7.2　方法invokeAny(Collectiontasks)的使用与interrupt209
7.3　方法invokeAny()与执行慢的任务异常212
7.4　方法invokeAny()与执行快的任务异常216
7.5　方法invokeAny()与全部异常220
7.6　方法invokeAny(CollectionTasks,timeout,timeUnit)超时的测试222
7.7　方法invokeAll(Collectiontasks)全正确226
7.8　方法invokeAll(Collectiontasks)快的正确慢的异常227
7.9　方法invokeAll(Collectiontasks)快的异常慢的正确230
7.10　方法invokeAll(Collectiontasks,longtimeout,TimeUnitunit)先慢后快232
7.11　方法invokeAll(Collectiontasks,longtimeout,TimeUnitunit)先快后慢234
7.12　方法invokeAll(Collectiontasks,longtimeout,TimeUnitunit)全慢236
7.13　本章总结238
第8章　计划任务ScheduledExecutorService的使用239
8.1　ScheduledExecutorService的使用240
8.2　ScheduledThreadPoolExecutor使用Callable延迟运行241
8.3　ScheduledThreadPoolExecutor使用Runnable延迟运行244
8.4　延迟运行并取得返回值245
8.5　使用scheduleAtFixedRate()方法实现周期性执行246
8.6　使用scheduleWithFixedDelay()方法实现周期性执行248
8.7　使用getQueue()与remove()方法250
8.8　方法setExecuteExistingDelayedTasksAfterShutdownPolicy()的使用253
8.9　方法setContinueExistingPeriodicTasksAfterShutdownPolicy()255
8.10　使用cancel(boolean)与setRemoveOnCancelPolicy()方法257
8.11　本章总结261
第9章　Fork-Join分治编程262
9.1　Fork-Join分治编程与类结构262
9.2　使用RecursiveAction让任务跑起来264
9.3　使用RecursiveAction分解任务265
9.4　使用RecursiveTask取得返回值与join()和get()方法的区别266
9.5　使用RecursiveTask执行多个任务并打印返回值270
9.6　使用RecursiveTask实现字符串累加272
9.7　使用Fork-Join实现求和：实验1273
9.8　使用Fork-Join实现求和：实验2275
9.9　类ForkJoinPool核心方法的实验276
9.9.1　方法publicvoidexecute(ForkJoinTasktask)的使用276
9.9.2　方法publicvoidexecute(Runnabletask)的使用278
9.9.3　方法publicvoidexecute(ForkJoinTasktask)如何处理返回值278
9.9.4　方法publicForkJoinTasksubmit(ForkJoinTasktask)的使用279
9.9.5　方法publicForkJoinTasksubmit(Runnabletask)的使用280
9.9.6　方法publicForkJoinTasksubmit(Callabletask)的使用281
9.9.7　方法publicForkJoinTasksubmit(Runnabletask,Tresult)的使用282
9.9.8　方法publicList>invokeAll(Collection>tasks)的使用285
9.9.9　方法publicvoidshutdown()的使用286
9.9.10　方法publicListshutdownNow()的使用289
9.9.11　方法isTerminating()和isTerminated()的使用292
9.9.12　方法publicbooleanisShutdown()的使用295
9.9.13　方法publicbooleanawaitTermination(longtimeout,TimeUnitunit)的使用297
9.9.14　方法publicTinvoke(ForkJoinTasktask)的使用299
9.9.15　监视pool池的状态301
9.10　类ForkJoinTask对异常的处理308
9.11　本章总结309
第10章　并发集合框架310
10.1　集合框架结构简要310
10.1.1　接口Iterable310
10.1.2　接口Collection311
10.1.3　接口List311
10.1.4　接口Set312
10.1.5　接口Queue312
10.1.6　接口Deque312
10.2　非阻塞队列313
10.2.1　类ConcurrentHashMap的使用313
10.2.2　类ConcurrentSkipListMap的使用322
10.2.3　类ConcurrentSkipListSet的使用325
10.2.4　类ConcurrentLinkedQueue的使用328
10.2.5　类ConcurrentLinkedDeque的使用330
10.2.6　类CopyOnWriteArrayList的使用332
10.2.7　类CopyOnWriteArraySet的使用335
10.3　阻塞队列337
10.3.1　类ArrayBlockingQueue的使用337
10.3.2　类PriorityBlockingQueue的使用338
10.3.3　类LinkedBlockingQueue的使用340
10.3.4　类LinkedBlockingDeque的使用341
10.3.5　类SynchronousQueue的使用341
10.3.6　类DelayQueue的使用344
10.3.7　类LinkedTransferQueue的使用345
10.4　本章总结354

前言/序言

　　为什么要写这《Java并发编程：核心方法与框架》早在几年前笔者就曾想过整理一份与Java并发包有关的稿件。因为市面上所有的Java书籍都是以1章或2章的篇幅介绍Java并发包技术，这就导致对Java并发包的讲解并不是非常详尽，包含的知识量远远不够，并没有完整覆盖Java并发包技术的知识点。但可惜，苦于当时的时间及精力有限，一直没有如愿。
　　也许是注定的安排，笔者现所在单位是集技术与教育为一体的软件类企业，学员在学习完JavaSE/JavaEE之后想探索更深入的技术，比如大数据、分布式、高并发类的专题，就会立即遇到与Java并发包中API相关的问题。为了带领学员在技术层面上有更高的追求，所以我将Java并发包的技术点以教案的方式进行整理，在课堂上与同学们一起进行学习、交流，同学们反响非常强烈。至此，若干年前的心愿终于了却，同学们也很期待这样一《Java并发编程：核心方法与框架》能出版发行，那样他们就有真正的纸质参考资料了。若这份资料也被其他爱好Java并发的朋友们看到，并通过它学到相关知识，那就是我最大的荣幸了。
　　《Java并发编程：核心方法与框架》将给读者一个完整的视角，秉承“大道至简”的主导思想，只介绍Java并发包开发中最值得关注的内容，希望能抛砖引玉，以个人的一些想法和见解，为读者拓展出更深入、全面的思路。
　　《Java并发编程：核心方法与框架》特色《Java并发编程：核心方法与框架》尽量减少“啰嗦”式的文字语言，全部用Demo式案例来讲解技术点的实现，使读者看到代码及运行结果后就可以知道此项目要解决的是什么问题。类似于网络中Blog的风格，可让读者用最短的时间学会此知识点，明白此知识点如何应用，以及在使用时要避免什么。这就像“瑞士军刀”，虽短小，却锋利。《Java并发编程：核心方法与框架》的目的就是帮读者快速学习并解决问题。
　　读者对象Java初级、中级程序员Java多线程开发者Java并发开发者系统架构师大数据开发者其他对多线程技术感兴趣的人员如何阅读《Java并发编程：核心方法与框架》在整理《Java并发编程：核心方法与框架》时，笔者本着实用、易懂的学习原则整理了10个章节来介绍Java并发包相关的技术。
　　第1章讲解了Semaphore和Exchanger类的使用，学完本章后，能更好地控制线程间的同步性，以及线程间如何更好、更方便地传输数据。
　　第2章是第1章的延伸，主要讲解了CountDownLatch、CyclicBarrier类的使用及在Java并发包中对并发访问的控制。本章主要包括Semaphore、CountDownLatch和CyclicBarrier的使用，它们在使用上非常灵活，所以对于API的介绍比较详细，为读者学习控制同步打好坚实的基础。
　　第3章是第2章的升级，由于CountDownLatch和CyclicBarrier类都有相应的弊端，所以在JDK1.7中新增加了Phaser类来解决这些缺点。
　　第4章中讲解了Executor接口与ThreadPoolExecutor线程池的使用，可以说本章中的知识也是Java并发包中主要的应用技术点，线程池技术也在众多的高并发业务环境中使用。掌握线程池能更有效地提高程序运行效率，更好地统筹线程执行的相关任务。
　　第5章中讲解Future和Callable的使用，接口Runnable并不支持返回值，但在有些情况下真的需要返回值，所以Future就是用来解决这样的问题的。
　　第6章介绍Java并发包中的CompletionService的使用，该接口可以增强程序运行效率，因为可以以异步的方式获得任务执行的结果。
　　第7章主要介绍的是ExecutorService接口，该接口提供了若干方法来方便地执行业务，是比较常见的工具接口对象。
　　第8章主要介绍计划任务ScheduledExecutorService的使用，学完本章可以掌握如何将计划任务与线程池结合使用。
　　第9章主要介绍Fork-Join分治编程。分治编程在多核计算机中应用很广，它可以将大的任务拆分成小的任务再执行，最后再把执行的结果聚合到一起，完全利用多核CPU的优势，加快程序运行效率。
　　第10章主要介绍并发集合框架。Java中的集合在开发项目时占有举足轻重的地位，在Java并发包中也提供了在高并发环境中使用的Java集合工具类，读者需要着重掌握Queue接口的使用。
　　勘误和支持由于笔者的水平有限，加之编写时间仓促，书中难免会出现一些错误或者不准确的地方，恳请读者批评指正。期待能够得到你们的真挚反馈，在技术之路上互勉共进。
　　《Java并发编程：核心方法与框架》的源代码可以在华章网站下载。
　　致谢感谢所在单位领导的支持与厚爱，使我在技术道路上更有信心。
　　感谢机械工业出版社华章公司的编辑们始终支持我的写作，是你们的鼓励和帮助引导我顺利完成全部书稿。
　　高洪岩