jdk中的简单并发，需要掌握

前言

　　开心一刻

　　　　小时候有一次爸爸带我去偷村头别人家的梨子，我上树摘，爸爸在下面放风，正摘着主人来了，爸爸指着我破口大骂：臭小子，赶紧给我滚下来，敢偷吃别人家梨子，看我不打死你。主人家赶紧说：没事没事，小孩子淘气嘛，多摘点回家吃。我……这坑儿子的爹...

纯正的海豹突击队

　　路漫漫其修远兮，吾将上下而求索！

　　github：

　　码云(gitee)：

runnable

　　如果是简单的实现一个线程，我们会通过实现runnable接口或继承thread类来完成。jdk1.0中就已经存在runnable和thread，thread实现了runnable接口。runnable使用方式一般如下

public class runnabletest {

    public static void main(string[] args) {
        // java 8之前：
        new thread(new runnable() {
            @override
            public void run() {
                system.out.println("before java8, 我是子线程1");
            }
        }).start();

        //java 8方式：
        new thread( () -> {
            system.out.println("in java8");
            system.out.println("我是子线程2");
        } ).start();

    }
}

view code

　　一般我们的线程不是以匿名内部类的方式存在的，而是以如下方式存在

public class runnabletest {

    public static void main(string[] args) throws interruptedexception {
        runnable myrunnable = new myrunnable();
        new thread(myrunnable).start();
        thread.sleep(1000);
        system.out.println("我是主线程");
    }
}
class myrunnable implements runnable {

    @override
    public void run() {
        system.out.println("我是子线程1");
    }
}

view code

　　当然线程的实现方式还有thread类，thread实现了runnable接口，本质还是一样；无论是runnable，还是thread，实现的线程有一个很明显的缺点，就是没有返回值，执行完任务之后无法获取执行结果。

callable

　　callable接口是jdk1.5中引入的，和runnable类似，都是用来实现多线程，不同的是，callable能返回结果和抛出checked exception。源代码如下

@functionalinterface
public interface callable<v> {
    /**
     * computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws exception if unable to compute a result
     */
    v call() throws exception;
}

　　可以看到，callable是一个泛型接口，call()函数返回的类型就是传递进来的泛型类型，也是返回的结果类型。那么怎么使用callable呢？一般情况下是配合executorservice来使用的，而executorservice的创建又是用executors来完成的。

线程池

　　executors

　　　　也是jdk1.5新增内容，是创建executorservice、scheduledexecutorservice、threadfactory和callable的工厂，并提供了一些有效的工具方法。有很多创建executorservice的方法

　　　　主要分为6类方法，每一类都两两重载，一个有threadfactory threadfactory参数，一个没有threadfactory threadfactory参数，也就是我们可以自定义threadfactory来定制thread；若没有threadfactory参数，则使用默认的defaultthreadfactory来构建thread。6类方法如下

　　　　　　newcachedthreadpool(...)

　　　　　　　　创建一个可缓存的线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程；返回类型是：threadpoolexecutor。

　　　　　　newfixedthreadpool(...)

　　　　　　　　创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待；返回类型是：threadpoolexecutor。

　　　　　　newscheduledthreadpool(...)

　　　　　　　　创建一个定长线程池，支持定时及周期性任务执行；返回类型是：scheduledthreadpoolexecutor。多数情况下可用来替代timer类。

　　　　　　newsinglethreadexecutor(...)

　　　　　　　　创建一个单线程化的线程池，只有唯一的一个工作线程来执行任务，保证所有任务按照指定顺序执行；返回类型是：threadpoolexecutor的代理，我们可以认为就是threadpoolexecutor。

　　　　　　newsinglethreadscheduledexcutor(...)

　　　　　　　　创建一个单线程化的线程池，与newsinglethreadexecutor类似，但支持定时及周期性任务执行；返回类型是：scheduledthreadpoolexecutor。

　　　　　　newworkstealingpool(...)

　　　　　　　　创建持有足够线程的线程池来支持给定的并行级别，并通过使用多个队列，减少竞争；它需要穿一个并行级别的参数，如果不传，则被设定为默认的cpu数量。jdk1.8中新增，返回类型是：forkjoinpool。forkjoinfool通常配合forkjointask的子类recursiveaction或recursivetask使用。

　　　　常用的主要是以下3类：newcachedthreadpool,newfixedthreadpool,newscheduledthreadpool。至于newworkstealingpool，我还没用过，不太好评论。

　　executorservice

　　　　executorservice是一个interface，继承了executor，是java中对线程池定义的一个接口，类图如下：

　　　　executorservice接口中常用方法如下

void execute(runnable command);    // 从executor继承而来，用来执行runnale，没有返回值
<t> future<t> submit(callable<t> task);    // 执行callable类型的task，并返回future
<t> future<t> submit(runnable task, t result);    // 这种方式很少使用
future<?> submit(runnable task);    // 执行runnable类型的task，并返回future

　　　　当然还有invokeall、invokeany，感兴趣的可以去看下。关于future，下面会讲到。

　　　　当我们使用完成executorservice之后应该关闭它，否则它里面的线程会一直处于运行状态，导致应用无法停止。关闭executorservice的方式有两种，其一是executorservice.shutdown()方法，在调用shutdown()方法之后，executorservice不会立即关闭，但是它不再接收新的任务，直到当前所有线程执行完成才会关闭，所有在shutdown()执行之前提交的任务都会被执行；其二是调用executorservice.shutdownnow()方法，它将跳过所有正在执行的任务和被提交还没有执行的任务，但是它并不对正在执行的任务做任何保证，有可能它们都会停止，也有可能执行完成。一般推荐的关闭方式是executorservice.shutdown()。

　　future

　　　　对具体的runnable或者callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。相关类图如下

public interface future<v> {

    /**
     * 取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false
     * @param mayinterruptifrunning 是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。
     *         如果任务已经完成，则无论mayinterruptifrunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false。
     *         如果任务正在执行，若mayinterruptifrunning设置为true，则返回true，若mayinterruptifrunning设置为false，则返回false。
     *         如果任务还没有执行，则无论mayinterruptifrunning为true还是false，肯定返回true。
     * @return
     */
    boolean cancel(boolean mayinterruptifrunning);

    /**
     * 任务是否被取消成功，如果在任务正常完成前被取消成功，则返回true。
     * @return
     */
    boolean iscancelled();

    /**
     * 任务是否已经完成，若完成则返回true。
     * @return
     */
    boolean isdone();

    /**
     * 获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回。
     * @return
     * @throws interruptedexception
     * @throws executionexception
     */
    v get() throws interruptedexception, executionexception;

    /**
     * 获取执行结果，如果在指定时间内没获取到结果，就直接返回null
     * @param timeout
     * @param unit
     * @return
     * @throws interruptedexception
     * @throws executionexception
     * @throws timeoutexception
     */
    v get(long timeout, timeunit unit)
            throws interruptedexception, executionexception, timeoutexception;
}

view code

　　　　从如上代码可以看出future提供了三种功能：

　　　　　　1、判断任务是否完成；2、中断任务；3、获取任务执行结果。

线程池使用示例

　　runnable使用示例

　　　　示例一，定时周期的执行某个任务

import java.util.concurrent.executors;
import java.util.concurrent.scheduledexecutorservice;
import java.util.concurrent.timeunit;

public class runnabletest {

    public static void main(string[] args) {
        scheduledexecutorservice executorservice = executors.newscheduledthreadpool(5);
        myrunnable myrunnable = new myrunnable();
        // 应用启动3秒开始执行myrunnable，之后每隔5秒执行一次; scheduleatfixedrate是有返回值的，配合runnable的话，我们不关注返回值
        executorservice.scheduleatfixedrate(myrunnable, 3, 5, timeunit.seconds);
        system.out.println("我是主线程...");
    }
}
class myrunnable implements runnable {

    @override
    public void run() {
        try {
            thread.sleep(1000);
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
        system.out.println("我是子线程1");
    }
}

view code

　　　　示例二，单线程化的线程池执行某个任务，并显示的关闭线程池

public class runnabletest {

    public static void main(string[] args) throws interruptedexception, executionexception, timeoutexception {
        executorservice executorservice = executors.newsinglethreadexecutor();
        myrunnable myrunnable = new myrunnable();

        // 为了可取消性而使用future但又不提供可用的结果，则可以声明 future<?> 形式类型、并返回null作为底层任务的结果
        future<?> submit = executorservice.submit(myrunnable);

        // 如果不shutdown，那它里面的线程会一直处于运行状态，应用不会停止
        executorservice.shutdown();

        // 输出任务执行结果，由于runnable没有返回值，所以get的是null
        system.out.println(submit.get(4, timeunit.seconds));
        system.out.println("我是主线程...");
    }
}
class myrunnable implements runnable {

    @override
    public void run() {
        try {
            thread.sleep(1000);
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
        system.out.println("我是子线程1");
    }
}

view code

　　callable使用示例

　　　　示例一，callable + future获取结果；采用缓存线程池执行任务

import java.util.concurrent.*;
import java.util.concurrent.future;

public class callabletest {

    public static void main(string[] args) throws interruptedexception, executionexception {
        executorservice executorservice = executors.newcachedthreadpool();
        task task = new task();
        future<string> result = executorservice.submit(task);
        executorservice.shutdown();

        thread.sleep(1000);
        system.out.println("我是主线程, 执行另外的业务...");

        system.out.println("task执行结果：" + result.get());

        system.out.println("任务全部执行完毕...");
    }
}
class task implements callable<string> {

    @override
    public string call() throws exception {
        system.out.println("子线程, 业务处理中...");
        thread.sleep(2000);
        return "业务执行成功";
    }
}

view code

　　　　示例二，callable + futuretask获取结果；采用定长线程池执行定时任务

import java.util.concurrent.*;

public class callabletest {

    public static void main(string[] args) throws interruptedexception, executionexception, timeoutexception {
        executorservice executorservice = executors.newcachedthreadpool();
        task task = new task();
        futuretask<string> futuretask = new futuretask<>(task);
        executorservice.submit(futuretask);
        executorservice.shutdown();

        thread.sleep(1000);
        system.out.println("我是主线程, 执行另外的业务...");

        system.out.println("task执行结果：" + futuretask.get(5, timeunit.seconds));

        system.out.println("任务全部执行完毕...");
    }
}
class task implements callable<string> {

    @override
    public string call() throws exception {
        system.out.println("子线程, 业务处理中...");
        thread.sleep(2000);
        return "业务执行成功";
    }
}

view code

shiro中session验证定时任务

　　中讲到了session验证定时任务，我们abstractvalidatingsessionmanager中createsession方法开始

　　可以看到，调用executors.newsinglethreadscheduledexcutor(threadfactory threadfactory)方法创建了一个支持定时及周期性执行的单线程化线程池，支持定时及周期性地执行task，并且线程池中只有一个线程。executorservicesessionvalidationscheduler本身就是一个runnable，那么会定时、周期性的执行其run()。说的简单点就是：应用启动60分钟后，单线程化的线程池中的单个线程开始执行executorservicesessionvalidationscheduler的run()方法，之后每隔60分钟执行一次，60分钟是默认设置；executorservicesessionvalidationscheduler的run()中，会调用sessionmanager的validatesessions()方法完成session的验证。

总结

　　1、无需返回结果，简单的线程实现可以用runnable（或thread）；需要返回结果的、稍复杂的线程实现可以用callable；如果线程操作频繁、需要连接池管理的可以考虑用executorservice来实现线程池；更复杂的任务调度，则可以用三方工具，比如：quartz，更多三方调度工具可查阅，具体选择哪个，需要结合我们的具体业务来考虑，没有绝对的选择谁而不选择谁，就看谁更契合；

　　2、一般情况下，callable(或runnale)、executors、executorservice、future会配合来使用，很多时候我们不需要返回值，则可以不关注future；推荐使用线程池的方式，有与数据库连接池类似的优点；

　　3、很多三方的框架、工具都沿用了jdk的线程池实现，而没有引用第三方调度工具，例如shiro中，session的验证定时任务就是沿用的jdk中的executors.newsinglethreadscheduledexcutor(threadfactory threadfactory)来创建的线程池；

　　4、jdk中的线程还有很多内容，本文只是涉及到了冰山一角，更深入的学习有待大家自行去进行。

参考

　　java 8 教程汇总

　　java并发编程：callable、future和futuretask

　　深入理解 java 线程池：threadpoolexecutor