I’m Duansg(XiaoDuan)

• 🔭 I’m currently working on Zcy
• 🌱 I’m currently learning Interesting knowledge
• 👯 Currently working in HangZhou, China
• 🤔 I love Reading, Drinking
• 💬 Ask me about Java and my projects
• 📫 How to reach me: siguoduan@gmail.com
• 😄 You may like Blog
• ⚡ Fun fact: Movie,Interesting

About My Github

||

😐 Good sense asserted itself….

十大人物

James Gosling : Java 之父
文/陶文

作为 Java 之父，James Gosling 的名字可谓是耳熟能详。当人们评论一种编程语言时，总喜欢捎带着把下蛋的母鸡一起带上。Java 做为中国的编程语言学习者餐桌上有限的那么几样餐点中的流行款式，自然是让 James Gosling 风光不已。虽然 James Gosling 现在已经不是领导 Java 发展潮流的领军人物了，做为 Sun 的开发者产品组的 CTO，怎么算来也是身居高位了，俗事缠身吧，但是这并不妨碍其对于 Java 一如既往的爱护，表达着各式各样鲜明的观点，引发一场又一场的争论。
James Gosling 是很爱 Java 的——是啊，哪有当父母的不爱自己的孩子的呢。James Gosling 也是很爱 Sun 的——是啊，哪有当领导的不爱自己的公司的呢。于是我们在批评.NET 的安全性的队伍前头，在褒扬 Java 性能的队伍前头，在抨击 SWT 开倒车的队伍前头，在给 NetBeans 大唱赞歌的队伍前头，我们都看到了 James Gosling 的身影。无论对错、偏见或者固执，至少说明了 Gosling 的鲜明个性丝毫没有受到年龄的影响。也许也只有这种天才而偏执的人物才能创造出 Java 这般伟大的语言来吧。

Bill Joy : 软件业的爱迪生
文/徐昊

Joy 生于 1954 年，1982 年与 Vinod Khosla, Scott McNealy 和 Andy Bechtolsheim 一起创建了 Sun Microsystems，并从那时起担任首席科学家，直到 2003 年离开。他是一位令人崇敬的软件天才，他在软件和硬件的历史上留下了无数令人仰止的传奇。
在上个世纪 80 年代早期，DARPA 与 BBN 达成协议，准备将 Vinton Cerf 和 Bob Kahn 设计的 TCP/IP 协议添加到 Berkeley UNIX 中。Bill Joy 被委派来完成这项任务，然而他却拒绝将 BBN 的 TCP/IP 协议栈添加到 BSD 中，因为在他的眼中 BBN 的 TCP/IP 实现还远不够好，于是他就写了一个高性能的 TCP/IP 协议栈。John Gage 回忆道，“BBN 和 DARPA 签署了巨额合同来实现 TCP/IP 协议，然而他们的员工所编写的代码远没有一个研究生所做的好。于是他们邀请 Bill Joy 参加他们的一个会议，这位研究生穿着一件 T-Shirt 就出现了，他们询问他，‘你是如何做到的呢？’Bill 回答说，‘这是非常简单的一件事，你读一下协议然后就可以编码了’”。除了 TCP/IP 协议，基于分页的虚拟内存系统最早也是由 Bill Joy 添加到 Berkeley UNIX 内核当中的。同时他还是 vi、csh、早期 Pascal 编译器的作者。
关于 Bill Joy 惊人的软件才能流传最广的一个传奇是，据说他在上研究生的时候，想看看自己能不能写一个操作系统出来，于是就在三天里写了一个非常简陋，但是可以使用的 Unix 系统, 传说就是 BSD 的前身。虽然如此夸张的才情令人难以置信，但是考虑到主角是 Bill Joy，还是有一定的可信度的。Bill Joy 硕士毕业之后，决定到工业界发展，于是就到了当时只有一间办公室的 Sun, 他作为主要设计者参与了 SPARC 微处理器的设计，负责设计最为关键的一部分电路。这样兼精软硬件的天才实在是让人不得不佩服啊。1995 年，Sun 发布了轰动世界的 Java 语言。当然，Bill Joy 对 Java 也作出了不少的贡献，首先是 JINI——一种针对分布式服务的基础连接技术。任何可以内嵌 JVM 的电子设备都可以通过 JINI 相互连接； JXTA 是基于 Java 的 P2P 协议，允许互联网上的软件进行点对点交流和协作。
这个其貌不扬的瘦高个，有着凌乱的亚麻色头发，被《财富》杂志誉为“网络时代的爱迪生”的技术狂人，在短短的二十年间，创造了无数令人心动的软件。在 MIT 的 BBS 上曾有一个帖子，说微软电话面试有一道题，问“Who do you think is the best coder, and why?”虽然回复的帖子中大家都声明列举的 best coder 排名不分先后，然而大多数人仍把 Bill Joy 列在第一位，或许可以从一个侧面验证 Bill Joy 在广大 Programmer 心目中的地位吧。

Joshua Bloch : Java 2 元勋
文/莫映

早在 1996 年，适逢 Java 刚刚崭露头角，年内好事连连。先是 1 月份发布 JDK 1.0，然后是 5 月底在旧金山召开首届 JavaOne 大会，年末又是 JDK 1.1 紧跟其后。正是在 Java 技术如火如荼、大展拳脚的背景之下，Joshua Bloch 来到了 Sun，开始了他带领 Java 社区步入“迦南美地”的漫长历程。
很快，他被从安全组调入核心平台组，从事底层 API 设计。至此以后，每逢 JDK 的重大版本发布，总能在其中见到 Joshua 的“妙笔”。JDK 1.1 中的 java.math、1.4 中的 assertions，还有大家所熟识的 Collections Framework 皆是 Joshua 一手打造。其中的 Collections Framework 还获得了当年的 Jolt 大奖。到了 J2SE 5.0 研发阶段，身为平台组构架师的 Joshua 接掌了 Tiger 大旗，其核心地位已然无人可以替代。作为 Tiger 的代言人和领路人，没有谁比 Joshua 更清楚 Tiger。相信大家一定还记得 Joshua 当年仿效英国诗人 William Blake 所做的咏 Tiger 诗八首，优雅的笔调，透出大师深厚底蕴的同时，也道出了 Tiger 的几大重要特性，这些特性是自 JDK 1.1 引入 Inner Class 以来，Java 最大的语法改进。
Java 风雨十年，从 JDK 1.1 到 J2SE 5.0，Joshua 实在功不可没。难怪有人戏言，假如将 James Gosling 比作 Java 之父，那么 Joshua 就是一手将 Java “哺育”成人的 Java 之母。Joshua 对 Java 的贡献还不止于 JDK，提起他的大作《Effective Java》（Addison Wesley, 2001），相信 Java 粉丝们一定耳熟能详。该书荣膺 2002 年度 Jolt 大奖，且备受 James Gosling 推崇。书中 57 条颇具实用价值的经验规则，来自 Joshua 多年来在 JDK 开发工作中，尤其是 Collections Framework 设计中的实践心得，各个有理有据，剖析深入，也足见其深厚功力。该书对 Java 社群的影响，犹如 C++社群中的《Effective C++》。Joshua 对 JCP 的贡献也不小。他是 JSR201 和 JSR175 的领导者，前者包含了 Tiger 四大语言特性，后者则为 Java 提供了元数据支持。此外，他还是 JSR166 的发起人之一（该 JSR 由 Doug Lea 领导），并且是许多其他 JSR 的参与者。Joshua 目前是 JCP 为数不多的几个执行委员会成员之一。
Joshua Bloch 给人的印象是谦逊平和，行事低调而不喜抛头露面，一个典型的技术人员和实干家。不过即便如此，也丝毫不会减弱他对 Java 技术的卓越贡献和对 Java 社区的绝对影响力。有人说，如果他能更彰显一些，就很有可能成为 Java 开发者中的领军人物，就有如 Don Box 之于微软社群。
2004 年 7 月初，就在 Tiger 发布在即之时，就在 Jusha Bloch 刚刚荣获 Sun“杰出工程师（Distinguished Engineer）”的称号之时，他突然离开 Sun 而去了正值发展态势迅猛的 Google。当他离开 Sun 的消息在 TSS 发布之后，众多拥趸表达了怀念与不舍之情。一年过去了，我们还没有获知 Joshua 的任何近闻，似乎又是他行事低调的一贯作风所致，不知他在 Google 状况如何。希望 Joshua 依然能继续“摩西未尽的事业”，以他的影响力推动 Java 社群继续前行。据称，《Effective Java》的下一版会加入 Java 5.0 的部分，让我们翘首以待吧。

Bruce Eckel : 功勋卓著的机会主义分子
文/孟岩

Bruce Eckel 原本是一位普通的汇编程序员。不知道是什么因缘际会，他转行去写计算机技术图书，却在此大红大紫。他成功的秘诀不外乎两点：超人的表达能力和捕捉机会的能力。他最早的一本书是 1990 年代初期的《C++ Inside & Out》，随后，在 1995 年他写出了改变自己命运的《Thinking in C++》。如果说这本书充分表现了他作为优秀技术作家的一面，那么随后他写作《Thinking in Java》并因此步入顶级技术作家行列，则体现了他作为优秀的机会主义分子善于捕捉机会的另一面。写作中擅长举浅显直接的小例子来说明问题，语言生动，娓娓道来，特别适合于缺乏实践经验的初学者。因此《Thinking in Java》俨然成为天字第一号的 Java 教科书，对 Java 的普及与发展发挥着不可忽略的作用。不过公允地说，Bruce Eckel 的书欠深刻。比如在“Thinking in…”系列中对设计模式的解说就有失大师水准。这一方面是因为书的定位非常清晰，另一方面也是因为 Bruce 太过分心赶潮流，未能深入之故。TIJ 之后，他预言 Python 将火，就匆匆跑去写了半本《Thinking in Python》。后来 Python 并未如期而旺，于是他也就把书稿撂在那里不过问了，机会主义的一面暴露无遗。我们也可以善意的猜测一下，他的下一个投机对象会是什么呢？Ruby？.NET？MDA？总之，是什么我都不奇怪。

Rickard Oberg :J2EE 奇才
文/熊节

Oberg 的作品很多，流行的代码生成工具 XDoclet 和 MVC 框架 WebWork 都出自他的手笔。这两个框架有一个共同的特点，即它们的功能虽然简单，但设计都非常优雅灵活，能够很方便地扩展新功能甚至移植到新环境下使用。优雅的设计源自 Oberg 的过人才华，简单的功能则折射出他玩世不恭的人生态度。正是这两种特质的融合，才造就了这个不世出的奇才。
1999 年，JDK 1.3 发布，其中带来了一个重要的新特性：动态代理（Dynamic Proxy）。当所有人都还在对这项新技术的用途感到迷惑时，Oberg 发现用它便可以轻松攻克 EJB 容器实现中的一些难关。这一发现的产物就是一本《Mastering RMI》，以及大名鼎鼎的 JBoss 应用服务器。但 Oberg 很快又让世人见识了他的玩世不恭。由于和总经理 Marc Fleury 在经营理念上不合，Oberg 抱怨“法国的天空总让我感到压抑”，甩手离开了自己一手打造的 JBoss。此后的几年里，他和老友 Hani Suleiman 不断地对 JBoss 的“专业开源”模式和 Marc Fleury 的商人味道冷嘲热讽，让众人为他的孩子气扼腕叹息。
2002 年 10 月，微软推出 Petstore 示例应用的.NET 版本，并宣称其性能比 Java Petstore 高出数倍。正是 Oberg 深入分析这个示例应用的源代码，在第一时间指出它大量运用了 SQL Server 专有的特性，性能对比根本不具参考价值。后来 Oberg 又先后关注了 AOP 和 IoC 容器，两者都成为了 J2EE 架构的新宠。

Doug Lea : 世界上对 Java 影响力最大的个人
文/KIT

如果 IT 的历史，是以人为主体串接起来的话，那么肯定少不了 Doug Lea。这个鼻梁挂着眼镜，留着德王威廉二世的胡子，脸上永远挂着谦逊腼腆笑容，服务于纽约州立大学 Oswego 分校计算器科学系的老大爷。
说他是这个世界上对 Java 影响力最大的个人，一点也不为过。因为两次 Java 历史上的大变革，他都间接或直接的扮演了举足轻重的脚色。一次是由 JDK 1.1 到 JDK 1.2，JDK1.2 很重要的一项新创举就是 Collections，其 Collection 的概念可以说承袭自 Doug Lea 于 1995 年发布的第一个被广泛应用的 collections；一次是 2004 年所推出的 Tiger。Tiger 广纳了 15 项 JSRs(Java Specification Requests)的语法及标准，其中一项便是 JSR-166。JSR-166 是来自于 Doug 编写的 util.concurrent 包。
值得一提的是: Doug Lea 也是 JCP (Java 小区项目)中的一员。
Doug 是一个无私的人，他深知分享知识和分享苹果是不一样的，苹果会越分越少，而自己的知识并不会因为给了别人就减少了，知识的分享更能激荡出不一样的火花。《Effective JAVA》这本 Java 经典之作的作者 Joshua Blosh 便在书中特别感谢 Doug 是此书中许多构想的共鸣板，感谢 Doug 大方分享丰富而又宝贵的知识。这位并发编程的大师级人物的下一步，将会带给 Java 怎样的冲击，不禁令人屏息以待。

Scott McNealy :SUN 十年来的掌舵者
文/KIT

McNealy，Sun 的 CEO、总裁兼董事长。他曾经狂傲的说:“摧毁微软是我们每个人的任务。”这位英勇的硅谷英雄，似乎带头起义，试图组织一个反微软阵线联盟，以对抗微软这股庞大的托拉斯恶势力。他时常口出惊人之语，在公开场合大肆的批评微软，并曾经说微软的.NET 是.NOT。
Scott McNealy 先后毕业于哈佛大学及史丹佛大学，分别持有经济学学士学位及企管硕士。1982 年 MBA 毕业的他和三个同学共同合伙创建了 Sun，并于 1984 年成为 Sun 的执行官。“要么吞了别人，不然就被别人吞了”是 Scott McNealy 的名言录之一。他擅长以信念带动员工，鼓舞士气。极富自信的他，对于认定的事，总是坚持自己的想法，因此有人形容他是一个刚愎自用的决策者。
身为 Sun 这艘船的掌舵者，Scott McNealy 能够看多远，Sun 就能走多远。Scott McNealy 认为将来软件界是一个只有服务，没有产品的世代。他希望打造出 Sun 不是一个纯靠硬件赚钱的公司。从 Open Source 到 Open Solaris，Sun 希望可以成为提供整合性解决方案的服务厂商。Solaris 10 + UltraSPARC 是否可以像 Scott McNealy 希望的是下一匹世纪黑马呢？Sun 是否能以股价来证明华尔街分析师及普罗大众的诽短流长？Scott McNealy 是否能带领着 Sun 成为继微软之后的下一个巨人，一场场 IT 界的争霸战值得我们拭目以待。

Rod Johnson : 用一本书改变了 Java 世界的人
文/ 刘铁锋

Rod 在悉尼大学不仅获得了计算机学位，同时还获得了音乐学位。更令人吃惊的是在回到软件开发领域之前，他还获得了音乐学的博士学位。有着相当丰富的 C/C++技术背景的 Rod 早在 1996 年就开始了对 Java 服务器端技术的研究。他是一个在保险、电子商务和金融行业有着丰富经验的技术顾问，同时也是 JSR-154（Servlet 2.4）和 JDO 2.0 的规范专家、JCP 的积极成员。
真正引起了人们的注意的，是在 2002 年 Rod Johnson 根据多年经验撰写的《Expert One-on-One J2EE Design and Development》。其中对正统 J2EE 架构的臃肿、低效的质疑，引发了人们对正统 J2EE 的反思。这本书也体现了 Rod Johnson 对技术的态度，技术的选择应该基于实证或是自身的经验，而不是任何形式的偶像崇拜或者门户之见。正是这本书真正地改变了 Java 世界。基于这本书的代码，Rod Johnson 创建了轻量级的容器 Spring。Spring 的出现，使得正统 J2EE 架构一统天下的局面被打破。基于 Struts+Hibernate +Spring 的 J2EE 架构也逐渐得到人们的认可，甚至在大型的项目架构中也逐渐开始应用。
Rod Johnson 的新作《Expert One-on-one J2EE Development without JEB》则更让人吃惊，单单“Without EJB”一词就会让大多数 J2EE 架构师大跌眼镜了。不过 Rod Johnson 可能仅仅是想通过“Without EJB”一词表明应该放开门户之见。这也是 Rod Johnson 一贯的作风，。也许正是这种思想，促使得 Rod Johnson 创建了 Spring，真正改变了 Java 世界。

Alan Kay :Java 的精神先锋
文/徐昊

Sun 的官方 Java 教材中有一句话，说 Java 是“C++的语法与 Smalltalk 语义的结合”。而 Smalltalk 的创造者就是 Alan Kay。
Alan Kay 于 1970 年加入 Xerox 公司的 Palo Alto 研究中心。早在 70 年代初期，Alan Kay 等人开发了世界上第二个面向对象语言 Smalltalk，因此，Alan Kay 被誉为 Smalltalk 之父。2003 年，Alan Key 因为在面向对象程序设计上的杰出贡献，获得了有计算机界的诺贝尔奖之称的 ACM Turing Award。
Alan Kay 成名于 Smapltalk 和 OOP，而 Java 虽然在语言上类似于 C，但是在语义上非常接近 Smalltalk，很多 Java 中的设计思想在 Alan Kay 的文献中找到根源，也有些人将 Alan Kay 尊为 Java 思想的先驱。不过遗憾的是似乎 Alan Kay 老先生对 Java 并不买账，反倒攻击说 Java 是存在致命缺陷的编程语言，Java 的成功不是由于 Java 本身的内在价值，而是其商业化的成功。 Alan Kay 欣赏的是 Lisp，他认为 Lisp 是软件的麦克斯韦方程，其中的许多想法是软件工程和计算机科学的一部分。看来拥有 Alan Kay 这样一位重量级的 Java 先驱仍是我们 Java 一厢情愿的单恋吧。

Kent Beck : 领导的敏捷潮
文：刘铁锋

Beck 全家似乎都弥漫着技术的味道。生长在硅谷, 有着一个对无线电痴迷的祖父，以及一个电器工程师父亲。从小就引导 Kent Beck 成为了业余无线电爱好者。
在俄勒冈州大学读本科期间，Kent Beck 就开始研究起模式。然而在他最终拿到计算机学位之前，他却是在计算机和音乐中交替学习。似乎 Java 大师都能够有这样的能耐，另一 Java 大牛 Rod Johnson 同样也拥有音乐学的博士学位。
Kent Beck 一直倡导软件开发的模式定义。早在 1993 年，他就和 Grady Booch（UML 之父）发起了一个团队进行这个方面的研究。虽然著有了《Smalltalk Best Practice Patterns》一书，但这可能并不是 Kent Beck 最大的贡献。他于 1996 年在 DaimlerChrysler 启动的关于软件开发的项目，才真正地影响后来的软件开发。这次的杰作就是 XP（极限编程）的方法学。
和软件开发大师 Martin Fowler 合著的《Planning Extreme Programming》可谓是关于 XP 的奠基之作。从此，一系列的作品如《Test Driven Development: By Example》，《Extreme Programming Explained: Embrace Change》让更多的人领略到了极限编程的精髓，也逐步导致了极限编程的流行。
Kent Beck 的贡献远不仅如此。对于众多的 Java 程序员来说，他和 Erich Gamma 共同打造的 JUnit，意义更加重大。也许正式这个简单而又强大的工具，让众多的程序员更加认可和信赖极限编程，从而引起了 Java 敏捷开发的狂潮吧。

前言

你是不是曾遇到过这样一个问题，公司仓库往往为了满足公司 git 规范，往往需要全局配置用户名和邮箱，但是我们平时也活跃在男性交友论坛(github)上，这个时候我们个人仓库的用户名和邮箱配置是有区别的，为了能够很好地区分工程上传到不同的远程仓库，我们需要分别处理，保证在不同的工程使用不同的配置信息。 more >>

前言

这个异常并不陌生，很多情况下，我们总能见到 Permission denied 异常，可能是文件没有权限等等。

前言

谈起 juc(java.util.concurrent)，那就不得不提起一位大神，他就是 Doug Lea，他是 java 并发包的作者，显而易见，他对 java 的影响力也是举足轻重的，在 java 历史上的迭代的过程中，你都可以找到他的身影，其中最重要的便是 JSR-166(Java Specification Requests)的语法标准，而这项标准就来自于 Doug Lea 老爷子所编写的 java.util.concurrent 包。大家可以去http://ifeve.com/doug-lea/ 查看相关译文。

CountDownLatch 概述

从官方 api doc(译文翻译的不好，谨慎阅读)，可以大致概括一下，CountDownLatch 就是使一个线程在等待(调用 await)另外一个/多个线程完成各自工作之后(调用 countDown)，再继续执行。为了方便理解，我们可以把这个流程理解为”百米赛跑”，我们可以将 CountDownLatch 理解为裁判，裁判在发号施令以后进行等待，而每个运动员在跑到终点以后代表完成任务，当所有的运动员完成以后，裁判统计结果通知所有的运动员成绩。

CountDownLatch 的用法

Methods

• await()/await(long timeout,TimeUnit unit)：使当前线程等待锁计数在为 0 之前等待，除非线程被中断或超出了指定的等待时间，如果锁计数为 0，则立即返回。如果锁计数大于 0，则当前线程还是处于等待。
• countDown()：递减锁计数，如果锁计数到达零，则唤醒等待的线程。如果当前的锁计数大于零，则将计数递减。

总结

1. 调用 countDown 递减锁计数，如果计数递减为 0，则唤醒调用 await 的等待线程。
2. 如果调用 await 的当前线程，在调用时已经设置了该线程的中断状态，或者在等待时被中断，则抛出 InterruptedException，并且清除当前线程的中断状态。
3. 如果超出了指定的 await 等待时间，则立即返回。如果等待时间小于等于 0，则调用 await 的当前线程不会休眠。
4. 重点：从文档可以看出 countDown 方法并没有限制一个线程只能调用一次，await 方法同样也没有限制。它们会有如下两种场景。
   1. 当同一个线程调用多次 countDown()方法时，每次都会使计数器递减。
   2. 如果多个线程同时执行 await()方法，那么这几个线程都将处于等待状态，并且以共享模式享有同一个锁。

CountDownLatch 的使用场景

它的使用场景有很多，这里举一个图片识别的例子，我们知道在常见的电商系统中很多商品都有上传图片的功能，通常都是主图跟一些副图批量上传，而当有些监管比较严格的平台，比如政府采购电商平台会将用户上传的所有图片进行一些 OCR 识别，对图片中涉恐涉黄等敏感信息进行监管，但是识别时间会受图片大小、字数、网络环境等等影响浮动，所以为了解决串行识别比较慢的情况下，采用并行识别，然后在通知用户是否图片不合格以提升用户体验。

CountDownLatch 的原理

CountDownLatch 是基于(AQS)AbstractQueuedSynchronizer 实现的，在 AQS 中维护了一个 volatile 类型的整数 state，volatile 可以保证多线程环境下该变量的修改对每个线程都可见，并且由于该属性为整型，因而对该变量的修改也是原子的。创建一个 CountDownLatch 对象时，所传入的整数 n 就会赋值给 state 属性，当 countDown()方法调用时，该线程就会尝试对 state 减一，而调用 await()方法时，当前线程就会判断 state 属性是否为 0，如果为 0，则继续往下执行，如果不为 0，则使当前线程进入等待状态，直到某个线程将 state 属性置为 0，其就会唤醒在 await()方法中等待的线程。

CountDownLatch 使用示例

1、主线程等待子线程执行完成在执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 主线程等待子线程执行完成再执行
 */
public class CountdownLatchTest1 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(3);
        final CountDownLatch latch = new CountDownLatch(3);
        for (int i = 0; i < 3; i++) {
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("子线程" + Thread.currentThread().getName() + "开始执行");
                        Thread.sleep((long) (Math.random() * 10000));
                        System.out.println("子线程"+Thread.currentThread().getName()+"执行完成");
                        latch.countDown();//当前线程调用此方法，则计数减一
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            service.execute(runnable);
        }

        try {
            System.out.println("主线程"+Thread.currentThread().getName()+"等待子线程执行完成...");
            latch.await();//阻塞当前线程，直到计数器的值为0
            System.out.println("主线程"+Thread.currentThread().getName()+"开始执行...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

2、百米赛跑，4 名运动员选手到达场地等待裁判口令，裁判一声口令，选手听到后同时起跑，当所有选手到达终点，裁判进行汇总排名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountdownLatchTest2 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        final CountDownLatch cdOrder = new CountDownLatch(1);
        final CountDownLatch cdAnswer = new CountDownLatch(4);
        for (int i = 0; i < 4; i++) {
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("选手" + Thread.currentThread().getName() + "正在等待裁判发布口令");
                        cdOrder.await();
                        System.out.println("选手" + Thread.currentThread().getName() + "已接受裁判口令");
                        Thread.sleep((long) (Math.random() * 10000));
                        System.out.println("选手" + Thread.currentThread().getName() + "到达终点");
                        cdAnswer.countDown();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            service.execute(runnable);
        }
        try {
            Thread.sleep((long) (Math.random() * 10000));
            System.out.println("裁判"+Thread.currentThread().getName()+"即将发布口令");
            cdOrder.countDown();
            System.out.println("裁判"+Thread.currentThread().getName()+"已发送口令，正在等待所有选手到达终点");
            cdAnswer.await();
            System.out.println("所有选手都到达终点");
            System.out.println("裁判"+Thread.currentThread().getName()+"汇总成绩排名");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.shutdown();
    }
}

演示 2 个等待线程通过 CountDownLatch 去等待 3 个工作线程完成操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {
        // 让2个线程去等待3个三个工作线程执行完成
        CountDownLatch c = new CountDownLatch(3);

        // 2 个等待线程
        WaitThread waitThread1 = new WaitThread("wait-thread-1", c);
        WaitThread waitThread2 = new WaitThread("wait-thread-2", c);

        // 3个工作线程
        Worker worker1 = new Worker("worker-thread-1", c);
        Worker worker2 = new Worker("worker-thread-2", c);
        Worker worker3 = new Worker("worker-thread-3", c);

        // 启动所有线程
        waitThread1.start();
        waitThread2.start();
        Thread.sleep(1000);
        worker1.start();
        worker2.start();
        worker3.start();
    }
}

/**
 * 等待线程
 */
class WaitThread extends Thread {

    private String name;
    private CountDownLatch c;

    public WaitThread(String name, CountDownLatch c) {
        this.name = name;
        this.c = c;
    }

    @Override
    public void run() {
        try {
            // 等待
            System.out.println(this.name + " wait...");
            c.await();
            System.out.println(this.name + " continue running...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/**
 * 工作线程
 */
class Worker extends Thread {

    private String name;
    private CountDownLatch c;

    public Worker(String name, CountDownLatch c) {
        this.name = name;
        this.c = c;
    }

    @Override
    public void run() {
        System.out.println(this.name + " is running...");
        try {
            Thread.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.name + " is end.");
        c.countDown();
    }
}

CountDownLatch 的不足

CountDownLatch 是一次性的，计算器的值只能在构造方法中初始化一次，之后没有任何机制再次对其设置值，当 CountDownLatch 使用完毕后，它不能再次被使用。

前言

如果说 juc（java.util.concurrent）是 java 的灵魂，那么 AQS（AbstractQueuedSynchronizer）则是 juc 的灵魂抽象类，这个灵魂伴侣常常伴随你的身边，那么你是否真正的了解”她”呢？

简介

AQS：全称是 AbstractQueuedSynchronizer，一个并发同步管理框架类，是 JUC 的灵魂抽象类。如果要自己去实现一个同步管理框架呢？

个人学习寒食君大佬的解析后觉得可以分为三点：

通用性，下层实现透明的同步机制，同时给上层提供业务代码编写的功能
利用 CAS 操作，原子的修改共享标志位（由这个标志位来判断共享资源是否空闲）
等待队列（埋伏笔：情况 ①：当共享资源被占用时，直接返回结果、情况 ②：当共享资源被占用时，让后续的线程进入到等待队列中等待）
与 AQS 的结构有着异曲同工之妙，下面就记录下 AQS 的要素吧（本文只写了独占式的过程，共享式也大差不差）。

AQS 的成员变量属性

这里的 state（注意使用了 volatitle 关键字修饰）为什么不是布尔类型而是整数类型呢？因为这就牵扯到了 AQS 的两种模式 –> 共享模式、独占模式

独占模式：当共享资源被一个线程占用时，其他线程无法占用
共享模式：当共享资源被一个线程占用时，其他共享模式下的线程能占用
state 为了表示占有资源的线程数量，所以采用的是整数类型。

队列里的节点有两种模式，就是独有和共享：


再来看一下节点 Node 的成员变量：

waitStaus 用来判断线程是否需要挂起（后文有写）。

AQS 的重点就是如何利用标志位 state 和这个 FIFO 等待队列来管理多线程的同步状态，AQS 也把这些操作封装成了一些方法 tryAcquire、acquire（对应着前文的伏笔，tryAcquire：尝试获取锁，直接返回结果，acquire：获取锁，进入等待队列，直至获取成功）。

AQS 的核心方法
tryAcquire

该方法被 protected 修改，传入的参数是一个整数，返回一个布尔类型，但方法中只抛出了一个异常。这样做的目的是：让继承的子类必须去重写这个方法，否则就抛出不支持该操作的异常，这种设计就是给了上层调用者开发的空间。

在上层调用了 tryAcquire 方法获取到锁后，就去做自己的业务，做完后释放资源；如果获取失败，开发者的这个功能必须要操作这个共享资源呢，那就去调用 acquire 方法进入到等待队列。

acquire

该方法由 public final 修饰，表明所有的继承类都可以直接调用这个方法，而且不允许子类去把这个方法重写（很显然，这就是告诉你，调用这个方法是一定能得到锁的）

在 if 判断语句里，你 tryAcquire 获取锁失败再去判断&&之后的条件，如果是获取到了锁那就直接结束。接下来看第二个判断条件：acquireQueued(addWaiter())，方法嵌套。

addWaiter

这个方法的作用就是将当前线程封装成一个 node，然后加入等待队列中。源码步骤：

创建一个线程节点
将该节点放到队尾，如果当前尾节点为空或第一次尝试 CAS 操作失败，则进入完整的入队方法 enq
enq 方法中采用 CAS + 自旋的操作保证插入成功
疑问：为什么不直接在 addWaiter 方法中完整入队呢？其实注释中就已经告诉了，先尝试快速入队，不行再完整的入队。

acquireQueued

该方法是对线程进行挂起和响应，以此来实现队列的先进先出。

这两个方法就是当线程使用完共享资源后释放锁的方法。

所以流程总结就是：

如果当前节点是头节点的下一个，那么将会自旋是不断尝试拿锁，直到拿锁成功；否则进行判断是否需要挂起（判断条件：该节点前除了 head 节点，还有其它节点的，并且 waitStaus 为 SIGANL，那么该节点就需要挂起），这样就能保证 head 之后只有一个节点在通过 CAS 来获取锁，就能最大限度的避免无用的自旋来消耗 CPU 资源。

在该节点使用完共享资源后（节点使用完锁后会采用 setHead()方法，变成新的头节点，起一个占位作用），需要释放锁，将自己的 waitStaus 置为默认值 0，然后程序将会从队列的尾节点向前进行搜索（为什么不从头向后找？因为在 setHead()方法中，已经和队列切断联系了），找到 head 节点后的最近且 waitStaus <= 0 的一个节点并唤醒它去争抢这个锁（因为在前面它是被挂起了的）。这样回到了最开始的地方，形成了一个良好的闭环。

前言

前言

在写代码时，经常需要对异常进行处理，最常用的就是 try catch。

在用 CompletableFuture 编写多线程时，如果需要处理异常，可以用 exceptionally，它的作用相当于 catch。

exceptionally 的特点：

当出现异常时，会触发回调方法 exceptionally
exceptionally 中可指定默认返回结果，如果出现异常，则返回默认的返回结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public class Thread01_Exceptionally {

	public static void main(String[] args) throws InterruptedException, ExecutionException {

		CompletableFuture<Double> future = CompletableFuture.supplyAsync(() -> {

			if (Math.random() < 0.5) {
				throw new RuntimeException("抛出异常");
			}

			System.out.println("正常结束");
			return 1.1;
		}).thenApply(result -> {

			System.out.println("thenApply接收到的参数 = " + result);
			return result;
		}).exceptionally(new Function<Throwable, Double>() {

			@Override
			public Double apply(Throwable throwable) {
				System.out.println("异常：" + throwable.getMessage());
				return 0.0;
			}
		});

		System.out.println("最终返回的结果 = " + future.get());

	}
}

// final Stream<CompletableFuture> stream = Stream.of(
// CompletableFuture.supplyAsync(() -> {
// throw new RuntimeException(“抛出异常”);
// }),
// CompletableFuture.supplyAsync(() -> {
// return “future2”;
// })
// );
//
// final List strings = CompletableFuture.allOf(stream.toArray(CompletableFuture[]::new)).thenApply(t -> {
//
// return stream.map(future -> {
// try {
// return future.get();
// } catch (Exception e) {
// e.printStackTrace();
// return null;
// }
// }).collect(Collectors.toList());
// }).get();
//
//
// System.out.println(strings);

Java 8 强大的函数式异步编程辅助类

前言

CompletableFuture join()和 get()方法的区别

CompletableFuture 组合处理 allOf 和 anyOf 太赞了！

CompletableFuture 串行回调函数 thenApply thenAccept thenRun

当子线程完成后，需要调用一些回调方法，如果是 Java8 以前，我们写的会稍微复杂。
Java8 的 CompletableFuture 已经为我们实现了几个回调函数，使用非常方便。

CompletableFuture runAsync 与 supplyAsync，何时选择一个？

runAsync将 Runnable 作为输入参数并返回 CompletableFuture，这意味着它不返回任何结果。
CompletableFuture run = CompletableFuture.runAsync(()-> System.out.println(“hello”));
但是suppyAsync将 Supplier 作为参数并返回 CompletableFuturewith 结果值，这意味着它不接受任何输入参数，而是将 result 作为输出返回。
CompletableFuture supply = CompletableFuture.supplyAsync(() -> { System.out.println(“Hello”); return “result”; }); System.out.println(supply.get()); //result
结论：因此，如果您希望返回结果，则选择，supplyAsync 或者如果您只想运行异步操作，则选择 runAsync。