Java多线程任务超时结束的5种实现方法_java多线程超时自动关闭_won-king的博客

方法一：使用Thread.join(long million)

（先讲一下本人对join方法的理解，已理解此方法的可以略过）join方法可以这样理解，在理解它之前，先解释另一个常识，即当前线程（后面称为目标线程，因为它是我们想使其超时结束的目标任务）的创建及start的调用，一定是在另一个线程中进行的（最起码是main线程，也可以是不同于main线程的其他线程），这里我们假设为main线程，并且称之为依赖线程，因为目标线程的创建是在他里面执行的。介绍完这些常识就可以进一步解释了，join的字面意思是，使目标线程加入到依赖线程中去，也可以理解为在依赖线程中等待目标线程一直执行直至结束（如果没有设置超时参数的话）。设置了超时参数（假设为5秒）就会这样执行，在依赖线程中调用了join之后，相当于告诉依赖线程，现在我要插入到你的线程中来，即两个线程合二为一，相当于一个线程（如果不执行插入的话，那目标线程和依赖线程就是并行执行），而且目标线程是插在主线程前面，所以目标线程先执行，但你主线程只需要等我5秒，5秒之后，不管我有没有执行完毕，我们两都分开，这时又会变成两个并行执行的线程，而不是目标线程直接结束执行，这点很重要。
其实这个方法比较牵强，因为它主要作用是用来多个线程之间进行同步的。但因为它提供了这个带参数的方法（所以这也给了我们一个更广泛的思路，就是一般带有超时参数的方法我们都可以尝试着用它来实现超时结束任务），所以我们可以用它来实现。注意这里的参数的单位是固定的毫秒，不同于接下来的带单位的函数。具体用法请看示例：
public class JoinTest {
    public static void main(String[] args) {
        Task task1 = new Task("one", 4);
        Task task2 = new Task("two", 2);
        Thread t1 = new Thread(task1);
        Thread t2 = new Thread(task2);
        t1.start();
        try {
            t1.join(2000); // 在主线程中等待t1执行2秒
        } catch (InterruptedException e) {
            System.out.println("t1 interrupted when waiting join");
            e.printStackTrace();
        t1.interrupt(); // 这里很重要，一定要打断t1,因为它已经执行了2秒。
        t2.start();
        try {
            t2.join(1000);
        } catch (InterruptedException e) {
            System.out.println("t2 interrupted when waiting join");
            e.printStackTrace();
class Task implements Runnable {
    public String name;
    private int time;
    public Task(String s, int t) {
        name = s;
        time = t;
    public void run() {
        for (int i = 0; i < time; ++i) {
            System.out.println("task " + name + " " + (i + 1) + " round");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println(name
                        + "is interrupted when calculating, will stop...");
                return; // 注意这里如果不return的话，线程还会继续执行，所以任务超时后在这里处理结果然后返回
在主线程中等待t1执行2秒之后，要interrupt（而不是直接调用stop，这个方法已经被弃用）掉它，然后在t1里面会产出一个中断异常，在异常里面处理完该处理的事，就要return，一定要return，如果不return的话，t1还会继续执行，只不过是与主线程并行执行。 
方法二：Future.get(long million, TimeUnit unit) 配合Future.cancle(true) 
Future系列（它的子类）的都可以实现，这里采用最简单的Future接口实现。 
public class FutureTest {
    static class Task implements Callable<Boolean> {
        public String name;
        private int time;
        public Task(String s, int t) {
            name = s;
            time = t;
        @Override
        public Boolean call() throws Exception {
            for (int i = 0; i < time; ++i) {
                System.out.println("task " + name + " round " + (i + 1));
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println(name
                            + " is interrupted when calculating, will stop...");
                    return false; // 注意这里如果不return的话，线程还会继续执行，所以任务超时后在这里处理结果然后返回
            return true;
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task1 = new Task("one", 5);
        Future<Boolean> f1 = executor.submit(task1);
        try {
            if (f1.get(2, TimeUnit.SECONDS)) { // future将在2秒之后取结果
                System.out.println("one complete successfully");
        } catch (InterruptedException e) {
            System.out.println("future在睡着时被打断");
            executor.shutdownNow();
        } catch (ExecutionException e) {
            System.out.println("future在尝试取得任务结果时出错");
            executor.shutdownNow();
        } catch (TimeoutException e) {
            System.out.println("future时间超时");
            f1.cancel(true);
            // executor.shutdownNow();
            // executor.shutdown();
        } finally {
            executor.shutdownNow();
运行结果如下，task在2秒之后停止： 
  
 如果把Task中捕获InterruptedException的catch块中的return注释掉，就是这样的结果： 
  
 task继续执行，直至结束 
方法三：ExecutorService.awaitTermination(long million, TimeUnit unit) 
这个方法会一直等待所有的任务都结束，或者超时时间到立即返回，若所有任务都完成则返回true，否则返回false 
public class AwaitTermination {
    static class Task implements Runnable {
        public String name;
        private int time;
        public Task(String s, int t) {
            name = s;
            time = t;
        public void run() {
            for (int i = 0; i < time; ++i) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println(name
                            + " is interrupted when calculating, will stop...");
                    return; // 注意这里如果不return的话，线程还会继续执行，所以任务超时后在这里处理结果然后返回
                System.out.println("task " + name + " " + (i + 1) + " round");
            System.out.println("task " + name + " finished successfully");
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task("one", 5);
        Task task2 = new Task("two", 2);
        Future<?> future = executor.submit(task);
        Future<?> future2 = executor.submit(task2);
        List<Future<?>> futures = new ArrayList<Future<?>>();
        futures.add(future);
        futures.add(future2);
        try {
            if (executor.awaitTermination(3, TimeUnit.SECONDS)) {
                System.out.println("task finished");
            } else {
                System.out.println("task time out,will terminate");
                for (Future<?> f : futures) {
                    if (!f.isDone()) {
                        f.cancel(true);
        } catch (InterruptedException e) {
            System.out.println("executor is interrupted");
        } finally {
            executor.shutdown();
运行结果如下： 
  
方法四：设置一个守护线程，守护线程先sleep一段定时时间，睡醒后打断它所监视的线程 
public class DemonThread {
    static class Task implements Runnable {
        private String name;
        private int time;
        public Task(String s, int t) {
            name = s;
            time = t;
        public int getTime() {
            return time;
        public void run() {
            for (int i = 0; i < time; ++i) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println(name
                            + " is interrupted when calculating, will stop...");
                    return; // 注意这里如果不return的话，线程还会继续执行，所以任务超时后在这里处理结果然后返回
                System.out.println("task " + name + " " + (i + 1) + " round");
            System.out.println("task " + name + " finished successfully");
    static class Daemon implements Runnable {
        List<Runnable> tasks = new ArrayList<Runnable>();
        private Thread thread;
        private int time;
        public Daemon(Thread r, int t) {
            thread = r;
            time = t;
        public void addTask(Runnable r) {
            tasks.add(r);
        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(time * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                thread.interrupt();
    public static void main(String[] args) {
        Task task1 = new Task("one", 5);
        Thread t1 = new Thread(task1);
        Daemon daemon = new Daemon(t1, 3);
        Thread daemoThread = new Thread(daemon);
        daemoThread.setDaemon(true);
        t1.start();
        daemoThread.start();
一开始准备在守护任务里面用一个集合来实现监视多个任务，接着发现要实现这个功能还得在这个守护任务里面为每一个监视的任务开启一个监视任务，一时又想不到更好的方法来解决，索性只监视一个算了，留待以后改进吧。 
 运行结果如下： 
  
方法五：使用Timer / TimerTask，或其他schedule定时相关的类 
总结：需要注意的是，无论以上哪一种方法，其实现原理都是在超时后通过interrupt打断目标线程的运行，所以都要在捕捉到InterruptedException的catch代码块中return,否则线程仍然会继续执行。另外，最后两种方法本质上是一样的，都是通过持有目标线程的引用，在定时结束后打断目标线程，这两种方法的控制精度最低，因为它是采用另一个线程来监视目标线程的运行时间，因为线程调度的不确定性，另一个线程在定时结束后不一定会马上得到执行而打断目标线程。
                    在用Java编写并发程序时，往往会碰到某个线程因计算量大或因阻塞而一直处于无响应的情况，我们可能会等的不耐烦（也可能是不想让它占用太多资源）想及时终止掉它，那就需要用到任务超时结束的技巧了。在刚接触到多线程时，我本以为API会提供这样一个多线程类：Thread(Runnable r, long timeout) ,第二个参数用来设置超时时间，可事实并非如此。因为这样的类不具有通用性，面向对象设计语言
				问题：比如多线程进行io操作的时候，io的读取在等待的时候（比如telnet某端口时，会长时间等待），线程是不会关闭的，这样导致线程不释放，早晚凉凉。
线程池关闭线程的方式有很多，我使用以下两种，简单介绍下，希望能帮助到你。
1、编写守护线程，来关闭你的当前线程
思路：创建守护线程执行业务操作，编写用户线程超时退出，当用户线程退出后，守护线程将强制退出。代码如下：
package BK2020.M08.D27;
 * @description:
 * @Author: huangsan
				jwx是开源的java公众号开发MVC框架，基于spring配置文件和微信消息或事件注解，通过微信上下文处理一个或多个微信公众号服务请求。目的主要有两个，其一生封装微信请求xml消息为java实体对象，将返回对象转换为xml响应消息；其二是封装微信接口为java服务。微信公众号采用web服务作为消息与第三方平台发生交互，数据格式主要是xml和json，普通的web请求响应机制采用xml数据格式交互，微信接口服务采用json数据格式。jwx主要对这两个方面做了封装处理，另外借鉴springmvc的请求处理方式，以WeixinDispatcherServlet类作为消息分发控制器，通过消息组装工厂生成请求消息或事件实体，根据消息或事件类型，在消息策略处理工厂查找处理策略，获取相应的微信处理方法，Servlet获取到处理方法后，请求线程池获取线程调用微信方法，根据微信方法的返回值，生成请求的xml响应。本说明文档将分章节说明jwx框架的特征、快速入门、配置、扩展等各个方面。
消息重排自动处理，提供消息重排缓存接口
明文/加密模式无感知切换
常用的微信接口服务封装
提供线程池执行微信方法，方法调用线程池大小可配置
长任务消息推送
通过微信上下文配置支持多个微信公众号处理
提供统一的异常处理机制
提供access_token自动更新机制
请求消息组装
灵活的响应消息类型
二、快速入门
本章教材提供一个最简单的例子，用户在微信公众号发一条foo的文本请求消息，公众号响应一条bar的文本响应消息。
1、maven配置文件
通过maven生成一个webapp项目，例如项目名为weixin，在maven配置文件pom.xml中添加jwx依赖，jwx的1.1.1jar包已经提交到maven中心仓库，通过中心仓库搜索jwx关键字可以获取jar包依赖配置。
    com.github.jweixin
    1.1.1
2、web.xml文件配置
web.xml是web应用的配置文件，jwx从spring配置文件中获取配置信息，所以必须配置spring上下文环境；另外，需要配置微信消息处理分发Servlet(WeixinDispatcherServlet)，用于处理微信送过来的请求消息或事件。jwx对springmvc没有依赖关系，web mvc框架可以根据实际需要配置。
 org.springframework.web.context.ContextLoaderListener
 weixin
 com.github.jweixin.jwx.servlet.WeixinDispatcherServlet
 weixin
 /wx/*
load-on-startup表示Servlet在web应用启动阶段加载，数字代表了启动次序，如果项目使用了springmvc框架，可以调整该数字为2，放到springmvc框架后面启动加载，但实际上Servlet的启动次序并没有太大的关系。
spring配置是jwx必须的，如果没有配置spring上下文，jwx在启动阶段会报错。
url-pattern模式匹配微信公众号平台服务器配置的URL配置，如果需要处理多个微信公众号，可以配置多个servlet-mapping或者使用路径通配符匹配多个url链接。
3、spring配置文件
spring配置文件applicationContext.xml里面需要配置WeixinConfigurer，这是jwx唯一必须配置项，如果没有配置，启动阶段会报错。
component-scan配置了微信接口服务类，里面包含常用的微信公众号接口服务，例如菜单管理、消息服务、二维码服务、用户管理、微信网页授权、素材管理等服务内容，在web应用控制器类和微信控制器类里面可以通过@Autowired注解来注入服务。本配置并不是必须项。
WeixinConfigurer是唯一需要配置的部分，packages属性必须配置，里面是微信控制器包路径列表，WeixinDispatcherServlet在启动阶段会扫描包路径及其下面的子包路径，如果类拥有@Weixin注解，则该类会被当作微信控制器类加载到微信上下文。
除了packages属性是必须配置的，其他配置都有缺省值，包括消息缓存、微信方法线程池的大小、微信方法调用超时阀值等，这部分内容放在配置部分说明了。
4、编写微信控制器类
当配置完上面的3个部分，所有的配置文件部分就结束了，是不是很简单呢。下面我们只需要写微信控制器类就能让我们的微信公众号活起来了。微信控制器类是用@Weixin注解的普通类，与sprngmvc里面的controller很类似，方法的执行也很类似。我们在com.telecomjs.yc.controller包下建一个java类WeixinController，如下：
package com.telecomjs.yc.controller;
import com.github.jweixin.jwx.context.Weixin;
import com.github.jweixin.jwx.message.annotation.TextMsg;
@Weixin(value="/wx/coreServlet",
   appID="xxx",
   appSecret="xxx",
   encodingAESKey="xxx",
   token="xxx")
public class WeixinController {
 @TextMsg("foo")
 public String foo(){
  return "bar";
@Weixin需要配置value值，这个实际就是微信服务器配置里面URL最后的部分，当然不包含域名和web应用的上下文，切记，不能包含web应用上下文，其他4个部分配置内容也是公众号配置内容，我们只需要登录到公众号看下填进去就行了。如果没有配置encodingAESKey，那么是不能处理加密消息的，如果有log4j的配置文件，启动阶段会给出告警信息的。
同一个公众号可以配置多个@Weixin注解控制器类，其中只需要一个有其他4项配置就可以了，如果多个控制器类配置了其他4个配置项，如果相对应的配置项值不相同，启动阶段会报错。
不同微信公众号是通过@Weixin的value值区分的，该值同时是微信上下文的查找关键字。
foo方法上面有@TextMsg注解，是定义的微信方法，在Servlet启动时通过包扫描加载到微信上下文对象中。jwx针对微信消息或事件类型设计了一组微信注解，基本涵盖了微信公众号定义的消息和事件类型。
@TextMsg是文本消息注解，代表请求类型的是文本消息，value值是发送的文本消息内容。处理文本适配模式，@TextMsg还支持正则表达式适配模式，这部分内容在使用参考部分说明。
本例中微信方法并没有设置参数，实际可以灵活设置参数，例如我们可以在方法中设置HttpServletRequest request，HttpServletResponse response，InMessage in, WeixinContext context等参数，这部分内容也放在使用参考部分说明。
本例中方法的返回类型是String，代表响应的消息内容是文本消息，jwx提供了丰富的返回值类型，这部分内容会在使用参考部分详细说明。
5、启动web应用
上面就是这个最简单例子的全部内容，让我们启动web应用，进入到我们的公众号，输入foo文本提交，看看返回的是不是bar这个内容了，如果是，恭喜你，你已经初步掌握了jwx的使用方法。下面更多的内容等着你呢！
三、配置说明
spring配置文件中唯一需要配置的bean是WeixinConfigurer类，是可选配置，但里面封装了微信接口服务类，建议一定要配置进spring配置文件中。
1、微信接口服务
微信接口服务类位于com.github.jweixin.jwx.weixin.service包中，在spring配置文件中通过扫描包载入服务，在web mvc框架和微信控制器类中都可以通过@Autowired注解注入，与其他spring普通的服务类主键使用方式一致，服务类每个方法都有accessToken参数，这个参数指的是微信access_token，在微信控制器类方法中，可以通过设置方法的WeixinContext context参数获取，在web mvc框架中，可以通过WeixinContextHelper类的静态方法getAccessToken(String url)获取。
CustomMsgService 客服消息服务
MassMsgService 群发消息服务
MaterialService 永久素材管理
MediaService 临时素材管理
MenuService 菜单服务
QrcodeService 二维码服务
TagService 标签服务
TemplateService 模板管理及消息发送
WebAuthService 微信网页授权服务
UserService 微信用户服务
SystemService 获取地址列表及长链接转短链接等其他类型服务
2、WeixinConfigurer配置
WeixinConfigurer是微信上下文全局配置类，里面包含了处理微信类扫描、微信消息重排处理、微信方法执行线程池大小、微信方法调用超时阀值等方面的配置，packages包扫描配置是唯一必须的配置部分，这个配置在快速入门部分已经描述，其他部分配置都有缺省配置，不是必须配置部分。
a、微信消息重排处理messageKeyCache配置
微信在处理消息推送时，如果没有获得响应，会隔5秒重试，最多重试3次。jwx在接到消息推送时，需要判断该消息是否已经接受过，如果接受过，则需要放弃处理。jwx设计了MessageKeyCache接口用于处理消息重排，里面需要实现唯一的方法public boolean hasMessageKey(String key);如果系统已经缓存了消息key值，返回true。jwx实现了一个默认的消息key值缓存ConcurrentHashMapMessageKeyCache。如果我们要设置缓存清理间隔，可以采用如下配置：
另外我们可以实现自己的消息key缓存类，只需要实现MessageKeyCache接口就可以了，比如我们可以采用redis作为消息key值缓存数据库。
b、微信方法线程池大小threadPoolSize设置
微信方法是由Servlet在获取请求消息或事件的策略后取得，Servlet取得微信方法后，在线程池中获取线程执行微信方法。缺省线程池的大小是10个，如果微信公众并发比较频繁，我们可以调整线程池的大小，以提高处理效率。 如果我们调整线程池大小为100，可以采用如下配置：
1、主要概念
微信上下文：微信上下文（WexinContext）是jwx最重要的部分，jwx可以同时处理多个微信公众号，每个公众号在jwx框架中对应一个微信上下文，微信上下文持有一个微信公众号所有的配置信息及处理策略。url是微信公众号配置的服务器地址的最后部分（不包括域名和web应用上下文），是识别微信公众号的唯一标识，透过url我们可以通过微信上下文帮助类（WeixinContextHelper）的静态方法获取到微信上下文及访问token，另外，在微信方法中我们也可以通过注入WeixinContext参数来获得微信上下文。微信上下文还包含了微信的access_token、appID、appSecret、encodingAESKey这些微信公众号的配置内容。微信上下文还保存微信方法与消息注解的策略对应关系，是微信消息能够得到处理的最重要的部分。微信上下文通过@Weixin注解来配置。
微信消息注解：jwx定义了14个消息或事件注解，涵盖了目前所有的微信消息和事件类型，这些注解定义在包com.github.jweixin.jwx.message.annotation中，微信注解代表了消息或事件类型，可以通过微信注解配置识别请求消息类型，获取相应的微信处理方法。
微信方法：被微信消息注解包围的方法，通过微信方法，我们可以处理微信公众号请求消息，返回公众号的响应消息。
2、@Weixin注解
@Weixin是用来配置微信上下文的，该注解使用在微信控制器类上。每个被@Weixin注解包围的类会在web应用启动时被扫描，配置项会加载到微信上下文中，@Weixin注解的参数说明：
value：代表微信上下文关键字，不能为空，在微信公众号基本配置中，处于URL配置的最后部分。例如微信公众号的URL(服务器地址)配置是：http://nalan_weixin.tunnel.qydev.com/weixin/wx/coreServlet，其中http://nalan_weixin.tunnel.qydev.com是主机栏，/weixin是web应用的上下文栏，那么value值应该是/wx/coreServlet，一个公众号可以有多个类拥有@Weixin注解，如果多个注解的value相同，则会认为是同一个微信上下文，在jwx中，区分上下文的唯一标识就是@Weixin注解的value值配置。@Weixin注解还有其他4个配置项，都有缺省值，在一个微信控制器类中配置了其他4个值，那么相同value值得控制器类只需要配置value项就可以了，如果value配置项相同，而其他4个配置项的同项配置不同，jwx在初始启动扫描阶段会给出报错提示。
token：代表微信公众号基本配置中的Token(令牌)项的值。
encodingAESKey：代表微信公众号基本配置中的EncodingAESKey(消息加解密密钥)，该项如果没有配置，那么jwx不能处理加密的请求消息，在jwx初始启动阶段会给出告警提示。如果我们配置了消息加解密方式为安全模式，没有配置encodingAESKey项，则运行阶段会报错。另外如果在加密请求消息到达时报如下错误：java.security.InvalidKeyException:illegal Key Size，则说明当前运行的JDK没有用JCE无限制权限策略文件替换相应的安全jar包，**解决方案：在官方网站下载JCE无限制权限策略文件（请到官网下载对应的版本， 例如JDK7的下载地址：http://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html下载后解压，可以看到local_policy.jar和US_export_policy.jar以及readme.txt，如果安装了JRE，将两个jar文件放到%JRE_HOME%\lib\security目录下覆盖原来的文件；如果安装了JDK，将两个jar文件放到%JDK_HOME%\jre\lib\security目录下覆盖原来文件**。
appID：代表微信公众号基本配置中的AppID(应用ID)。
appSecret：代表微信公众号基本配置中的AppSecret(应用密钥)。
3、微信方法
在微信控制器类中，被微信消息（事件）注解包围的方法，被称为微信方法，微信方法是MVC框架里面的C部分，它控制着对请求消息的处理逻辑，并且返回响应消息。微信注解主要用于适配请求消息（事件）的类型及关键字内容，当适配成功后，由对应的微信方法执行处理逻辑，并且通过方法的返回值返回响应消息。微信方法的参数在请求消息到达时由Servlet注入，目前微信方法参数可以是HttpServletRequest request，HttpServletResponse response，InMessage in, WeixinContext context里面的任意次序和数量的组合，参数中InMessage可以是与注解对应的子类，对于@ExceptionHandler注解，可以添加Throwable及其子类作为方法参数，需要注意的是如果参数类型与实际消息类型或异常类型不能匹配，则该参数会被置为空。
4、微信注解
jwx定义了14个消息或事件注解，涵盖了目前所有的微信消息和事件类型，下面逐个讲解没有注解的使用。
@TextMsg
@ClickEvent
5、响应类型
│      高并发编程第一阶段01讲、课程大纲及主要内容介绍.wmv
│      高并发编程第一阶段02讲、简单介绍什么是线程.wmv
│      高并发编程第一阶段03讲、创建并启动线程.mp4
│      高并发编程第一阶段04讲、线程生命周期以及start方法源码剖析.mp4
│      高并发编程第一阶段05讲、采用多线程方式模拟银行排队叫号.mp4
│      高并发编程第一阶段06讲、用Runnable接口将线程的逻辑执行单元从控制中抽取出来.mp4
│      高并发编程第一阶段07讲、策略模式在Thread和Runnable中的应用分析.mp4
│      高并发编程第一阶段08讲、构造Thread对象你也许不知道的几件事.mp4
│      高并发编程第一阶段09讲、多线程与JVM内存结构的关系，虚拟机栈实验.mp4
│      高并发编程第一阶段10讲、Thread构造函数StackSize详细讲解.mp4
│      高并发编程第一阶段11讲、Thread构造函数StackSize详细讲解-续.mp4
│      高并发编程第一阶段12讲、Daemon线程的创建以及使用场景分析.mp4
│      高并发编程第一阶段13讲、线程ID，优先级讲解.mp4
│      高并发编程第一阶段14讲、Thread的join方法详细介绍，结合一个典型案例.mp4
│      高并发编程第一阶段15讲、Thread中断Interrupt方法详细讲解.mp4
│      高并发编程第一阶段16讲、采用优雅的方式结束线程生命周期.mp4
│      高并发编程第一阶段17讲、Thread API综合实战，编写ThreadService实现暴力结束线程的综合实战.mp4
│      高并发编程第一阶段18讲、数据同步的引入与Synchronized的简单介绍.mp4
│      高并发编程第一阶段19讲、结合jconsole,jstack以及汇编指令认识synchronized关键字.mp4
│      高并发编程第一阶段20讲、同步代码块以及同步方法之间的区别和关系.mp4
│      高并发编程第一阶段21讲、通过实验分析This锁的存在.mp4
│      高并发编程第一阶段22讲、通过实验分析Class锁的存在.mp4
│      高并发编程第一阶段23讲、多线程死锁分析，案例介绍.mp4
│      高并发编程第一阶段24讲、线程间通信快速入门，使用wait和notify进行线程间的数据通信.mp4
│      高并发编程第一阶段25讲、多Produce多Consume之间的通讯导致出现程序假死的原因分析.mp4
│      高并发编程第一阶段26讲、多线程下的生产者消费者模型，以及详细介绍notifyAll方法.mp4
│      高并发编程第一阶段27讲、wait和sleep的本质区别是什么，深入分析（面试常见问题）.mp4
│      高并发编程第一阶段28讲、线程生产者消费者的综合实战结合Java8语法.mp4
│      高并发编程第一阶段29讲、如何实现一个自己的显式锁Lock精讲上.mp4
│      高并发编程第一阶段30讲、如何实现一个自己的显式锁Lock精讲下（让锁具备超时功能）.mp4
│      高并发编程第一阶段31讲、如何给你的应用程序注入钩子程序，Linux下演示.mp4
│      高并发编程第一阶段32讲、如何捕获线程运行期间的异常.mp4
│      高并发编程第一阶段33讲、ThreadGroup API介绍之一.mp4
│      高并发编程第一阶段34讲、ThreadGroup API介绍之二.mp4
│      高并发编程第一阶段35讲、线程池原理与自定义线程池.mp4
│      高并发编程第一阶段36讲、自定义个简单的线程池并且测试.mp4
│      高并发编程第一阶段37讲、给线程池增加拒绝策略以及停止方法.mp4
│      高并发编程第一阶段38讲、给线程池增加自动扩充线程数量，以及闲时自动回收的功能.mp4
│      高并发编程第一阶段39讲、课程结束，内容回顾，下季内容预告.mp4
├─第二阶段
│       Java并发编程.png
│       ppt+源码.rar
│       高并发编程第二阶段01讲、课程大纲及主要内容介绍.wmv
│       高并发编程第二阶段02讲、介绍四种Singleton方式的优缺点在多线程情况下.wmv
│       高并发编程第二阶段03讲、介绍三种高效优雅的Singleton实现方式.wmv
│       高并发编程第二阶段04讲、多线程的休息室WaitSet详细介绍与知识点总结.mp4
│       高并发编程第二阶段05讲、一个解释volatile关键字作用最好的例子.mp4
│       高并发编程第二阶段06讲、Java内存模型以及CPU缓存不一致问题的引入.mp4
│       高并发编程第二阶段07讲、CPU以及CPU缓存的结构，解决高速缓存一致性问题的两种方案介绍.mp4
│       高并发编程第二阶段08讲、并发编程的三个重要概念，原子性，可见性，有序性.mp4
│       高并发编程第二阶段09讲、指令重排序，happens-before规则精讲.mp4
│       高并发编程第二阶段10讲、volatile关键字深入详解.mp4
│       高并发编程第二阶段11讲、volatile关键字总结.mp4
│       高并发编程第二阶段12讲、观察者设计模式介绍.mp4
│       高并发编程第二阶段13讲、使用观察者设计模式观察线程的生命周期.mp4
│       高并发编程第二阶段14讲、单线程执行设计模式，有一个门，始终只能一个人通过-上.mp4
│       高并发编程第二阶段15讲、单线程执行设计模式，有一个门，始终只能一个人通过-下.mp4
│       高并发编程第二阶段16讲、多线程读写锁分离设计模式讲解-上.mp4
│       高并发编程第二阶段17讲、多线程读写锁分离设计模式讲解-中.mp4
│       高并发编程第二阶段18讲、多线程读写锁分离设计模式讲解-下.mp4
│       高并发编程第二阶段19讲、多线程不可变对象设计模式Immutable-上.mp4
│       高并发编程第二阶段20讲、多线程不可变对象设计模式Immutable-下.mp4
│       高并发编程第二阶段21讲、多线程Future设计模式详细介绍-上.mp4
│       高并发编程第二阶段22讲、多线程Future设计模式详细介绍-下.mp4
│       高并发编程第二阶段23讲、第二阶段课程答疑学员问题.mp4
│       高并发编程第二阶段24讲、Guarded Suspension设计模式-上.mp4
│       高并发编程第二阶段25讲、Guarded Suspension设计模式-下.mp4
│       高并发编程第二阶段26讲、ThreadLocal使用详解，深入原理介绍.mp4
│       高并发编程第二阶段27讲、多线程运行上下文设计模式介绍.mp4
│       高并发编程第二阶段28讲、使用ThreadLocal重新实现一个上下文设计模式.mp4
│       高并发编程第二阶段29讲、多线程Balking设计模式-上.mp4
│       高并发编程第二阶段30讲、多线程Balking设计模式-下.mp4
│       高并发编程第二阶段31讲、多线程Producer and Consumer设计模式.mp4
│       高并发编程第二阶段32讲、多线程Count Down设计模式.mp4
│       高并发编程第二阶段33讲、多线程Thread-Per-Message设计模式.mp4
│       高并发编程第二阶段34讲、多线程Two Phase Termination设计模式-上.mp4
│       高并发编程第二阶段35讲、多线程Two Phase Termination设计模式-下.mp4
│       高并发编程第二阶段36讲、多线程Worker-Thread设计模式-上.mp4
│       高并发编程第二阶段37讲、多线程Worker-Thread设计模式-上.mp4
│       高并发编程第二阶段38讲、多线程Active Objects设计模式(接受异步消息的主动对象)-上.mp4
│       高并发编程第二阶段39讲、多线程Active Objects设计模式(接受异步消息的主动对象)-中.mp4
│       高并发编程第二阶段40讲、多线程Active Objects设计模式(接受异步消息的主动对象)-下.mp4
│       高并发编程第二阶段41讲、多线程设计模式内容回顾与总结.mp4
│       高并发编程第二阶段42讲、ClassLoader课程大纲介绍.mp4
│       高并发编程第二阶段43讲、类加载的过程以及类主动使用的六种情况详细介绍.mp4
│       高并发编程第二阶段44讲、被动引用和类加载过程的练习巩固训练题.mp4
│       高并发编程第二阶段45讲、ClassLoader加载阶段发生的故事.mp4
│       高并发编程第二阶段46讲、ClassLoader链接阶段（验证，准备，解析）过程详细介绍.mp4
│       高并发编程第二阶段47讲、ClassLoader初始化阶段详细介绍clinit.mp4
│       高并发编程第二阶段48讲、JVM内置三大类加载器的详细介绍.mp4
│       高并发编程第二阶段49讲、自定义类加载器ClassLoader顺便问候了一下世界.mp4
│       高并发编程第二阶段50讲、ClassLoader父委托机制详细介绍.mp4
│       高并发编程第二阶段51讲、加密解密类加载实战演示.mp4
│       高并发编程第二阶段52讲、加密解密类加载实战演示-续.mp4
│       高并发编程第二阶段53讲、ClassLoader打破双父亲委托机制,重写loadClass实战练习.mp4
│       高并发编程第二阶段54讲、ClassLoader命名空间，运行时包，类卸载详细介绍.mp4
│       高并发编程第二阶段55讲、线程上下文类加载器以及数据库驱动案例分析.mp4
└─第三阶段
       Java并发编程.png
       Java高并发第三阶段(JUC).png
       高并发编程第三阶段01讲 AtomicInteger多线程下测试讲解.mkv
       高并发编程第三阶段02讲 AtomicInteger API详解，以及CAS算法详细介绍.mkv
       高并发编程第三阶段03讲 利用CAS构造一个TryLock自定义显式锁.mp4
       高并发编程第三阶段04讲 利用CAS构造一个TryLock自定义显式锁-增强并发情况下.mp4
       高并发编程第三阶段05讲 AtomicBoolean源码分析.mp4
       高并发编程第三阶段06讲 AtomicLong源码分析.mp4
       高并发编程第三阶段07讲 AtomicReference详解，CAS算法带来的ABA问题详解.mp4
       高并发编程第三阶段08讲 AtomicStampReference详解，解决CAS带来的ABA问题.mp4
       高并发编程第三阶段09讲 AtomicIntegerArray,AtomicLongArray,AtomicReferenceArray讲解.mp4
       高并发编程第三阶段10讲 AtomicIntegerFieldUpdater,AtomicLongFieldUpdater,AtomicReferenceFieldUpdater讲解.mp4
       高并发编程第三阶段11讲 AtomicXXXFieldUpdater源码分析及使用场景分析.mp4
       高并发编程第三阶段12讲 sun.misc.Unsafe介绍以及几种Counter方案性能对比.mp4
       高并发编程第三阶段13讲 一个JNI程序的编写，通过Java去调用C，C++程序.mp4
       高并发编程第三阶段14讲 Unsafe中的方法使用，一半是天使，一半是魔鬼的Unsafe.mp4
       高并发编程第三阶段15讲 Unsafe背后的汇编指令，牛逼男人背后的女人_.mp4
       高并发编程第三阶段16讲 CountDownLatch经典案例讲解-上_.mp4
       高并发编程第三阶段17讲 CountDownLatch经典案例讲解及API精讲-中_.mp4
       高并发编程第三阶段18讲 CountDownLatch经典案例讲解如何给离散平行任务增加逻辑层次关系-下_.mp4
       高并发编程第三阶段19讲 CyclicBarrier工具的使用场景介绍_.mp4
       高并发编程第三阶段20讲 CyclicBarrier vs CountDownLatch_.mp4
       高并发编程第三阶段21讲 Exchanger工具的使用以及常见问题分析-上_.mp4
       高并发编程第三阶段22讲 Exchanger工具的使用以及常见问题分析-下_.mp4
       高并发编程第三阶段23讲 Semaphore工具的介绍以及借助于Semaphore构造一个Lock_.mp4
       高并发编程第三阶段24讲 Semaphore工具API详细介绍-上_.mp4
       高并发编程第三阶段25讲 Semaphore工具API详细介绍-下_.mp4
       高并发编程第三阶段26讲 Lock&ReentrantLock详细讲解_.mp4
       高并发编程第三阶段27讲 ReadWriteLock&ReentrantReadWriteLock详细讲解_.mp4
       高并发编程第三阶段28讲 Condition初步使用，提出几个疑问_.mp4
       高并发编程第三阶段29讲 关于Condition疑问的几个小实验，对比Wait&Notify_.mp4
       高并发编程第三阶段30讲 使用Condition实现一个多线程下的Producer-Consumer_.mp4
       高并发编程第三阶段31讲 JDK8-StampedLock详细介绍-上_.mp4
       高并发编程第三阶段32讲 JDK8-StampedLock详细介绍-下.mp4
       高并发编程第三阶段33讲 ForkJoin框架之RecursiveTask_.mp4
       高并发编程第三阶段34讲 ForkJoin框架之RecursiveAction_.mp4
       高并发编程第三阶段35讲 Phaser工具的实战案例使用第一部分_.mp4
       高并发编程第三阶段36讲 Phaser工具的实战案例使用第二部分_.mp4
       高并发编程第三阶段37讲 Phaser工具的实战案例使用第三部分_.mp4
       高并发编程第三阶段38讲 Executor&ExecutorService讲解_.mp4
       高并发编程第三阶段39讲 ThreadPoolExecutor七大构造参数详细讲解_.mp4
       高并发编程第三阶段40讲 ThreadPoolExecutor关闭(很重要)精讲_.mp4
       高并发编程第三阶段41讲 newCache&newFixed&single ExecutorService详解_.mp4
       高并发编程第三阶段42讲 newWorkStealingPool ExecutorService详解_.mp4
       高并发编程第三阶段43讲 Scheduler的前奏Timer&Linux Crontab & quartz比较_.mp4
       高并发编程第三阶段44讲 ExecutorService API详细讲解-上_.mp4
       高并发编程第三阶段45讲 ExecutorService 四大内置拒绝策略深入探究_.mp4
       高并发编程第三阶段46讲 ExecutorService API详细讲解-中_.mp4
       高并发编程第三阶段47讲 ExecutorService API详细讲解-下_.mp4
       高并发编程第三阶段48讲 Future&Callable详细讲解-上_.mp4
       高并发编程第三阶段49讲 Future&Callable详细讲解-下_.mp4
       高并发编程第三阶段50讲 CompletionService详细介绍_.mp4
       高并发编程第三阶段51讲 ScheduledExecutorService详细讲解-上_.mp4
       高并发编程第三阶段52讲 ScheduledExecutorService详细讲解-下_.mp4
       高并发编程第三阶段53讲 知识回顾与串联_.mp4
       高并发编程第三阶段54讲 课程问题答疑，ExecutorService中的陷阱_.mp4
       高并发编程第三阶段55讲 CompletableFuture的使用精讲（体验）-1_.mp4
       高并发编程第三阶段56讲 CompletableFuture的使用精讲（构建）-2_.mp4
       高并发编程第三阶段57讲 CompletableFuture的使用精讲（熟练）-3_.mp4
       高并发编程第三阶段58讲 CompletableFuture的使用精讲（深入）-4_.mp4
       高并发编程第三阶段59讲 CompletableFuture的使用精讲（掌握）-5_.mp4
       高并发编程第三阶段60讲 LinkedList和有序LinkedList的实现_.mp4
       高并发编程第三阶段61讲 跳表数据结构的Java实现-1_.mp4
       高并发编程第三阶段62讲 跳表数据结构的Java实现-2_.mp4
       高并发编程第三阶段63讲 跳表数据结构的Java实现（解决Bug）-3_.mp4
       高并发编程第三阶段64讲 ArrayBlockingList详细讲解_.mp4
       高并发编程第三阶段65讲 PriorityBlockingQueue详细讲解_.mp4
       高并发编程第三阶段66讲 LinkedBlockingQueue详细讲解_.mp4
       高并发编程第三阶段67讲 SynchronousQueue详细讲解_.mp4
       高并发编程第三阶段68讲 DelayQueue详细讲解_.mp4
       高并发编程第三阶段69讲 LinkedBlockingDeque详细讲解_.mp4
       高并发编程第三阶段70讲 LinkedTransferQueue详细讲解_.mp4
       高并发编程第三阶段71讲 七大BlockingQueue的特点总结，可以不用详细看_.mp4
       高并发编程第三阶段72讲 ConcurrentHashMap性能测试以及JDK1.7原理讲解_.mp4
       高并发编程第三阶段73讲 ConcurrentHashMap性能测试以及JDK1.8原理讲解_.mp4
       高并发编程第三阶段74讲 ConcurrentSkipListMap详细讲解_.mp4
       高并发编程第三阶段75讲 ConcurrentSkipListMap vs ConcurrentHashMap_.mp4
       高并发编程第三阶段76讲 ConcurrentLinkedQueue&ConcurrentLinkedDeque_.mp4
       高并发编程第三阶段77讲 CopyOnWriteArrayList&CopyOnWriteArraySet源码分析_.mp4
       高并发编程第三阶段78讲 ConcurrentLinkedList vs CopyOnWriteArrayList vs SynchronizedList性能对比_.mp4
       高并发编程第三阶段79讲 实现一个高并发的无锁队列（Lock-Free）.mp4
       高并发编程第三阶段80讲 总结与回顾，闲聊与感谢.mp4
				ThreadPoolExecutor
Java线程池可以设置核心线程也随超时时间关闭，节省资源
java.util.concurrent.ThreadPoolExecutor
     * If false (default), core threads stay alive even when idle.
     * If true, core threads use keepAliveTime to time out waiting
     * for work.