Java 线程池

Posted 千里之外

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java 线程池相关的知识,希望对你有一定的参考价值。

 

 

线程

Java多线程,皆始于Thread。Thread是多线程的根,每一个线程的开启都始于Thread的start()方法。

Runnable

看一个例子:

Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("thread begin...");
        try {
            Thread.sleep(1000 * 30);
        } catch (Exception e) {

        }
        System.out.println("thread end");
    }
});


thread.start();

try {
    thread.join();
} catch (Exception e) {

}

System.out.println("main done");

new 一个 Thread,然后调用其 start() 方法,会启动一个线程并使线程进入了就绪状态,当分配到时间片后就可以开始运行了。 start() 会执行线程的相应准备工作,然后自动执行 run() 方法的内容。 如果直接执行Thread的 run() 方法,会把 run 方法当成一个 main 线程下的普通方法去执行,并不会在某个线程中执行它。

调用 start 方法方可启动线程并使线程进入就绪状态,而 run 方法只是 thread 的一个普通方法调用,还是在主线程里执行,此外:

  • start方法用synchronized修饰,为同步方法;
  • 虽然为同步方法,但不能避免多次调用问题,用threadStatus来记录线程状态,如果线程被多次start会抛出异常;threadStatus的状态由JVM控制。
  • 使用Runnable时,主线程无法捕获子线程中的异常状态。线程的异常,应在线程内部解决。
 

Callable

如果想捕获线程的返回值或异常,可以实现Callable接口
FutureTask<String> futureTask = new FutureTask<>(new Callable<String>() {
    @Override
    public String call() throws Exception {
        return "hello world!";
    }
});

Thread thread = new Thread(futureTask);

thread.start();

try {
    String result = futureTask.get();
    System.out.println(result);
} catch (Exception e) {

}

System.out.println("main done");

 

中止线程

如果用Thread.stop()方法中止一个正在运行的线程:

public class MyThread {

    public static void main(String[] args) throws InterruptedException {
        StopThread thread = new StopThread();
        thread.start();

        // 休眠1秒,确保线程进入运行
        Thread.sleep(1000);

        // 暂停线程
        thread.stop();
        //thread.interrupt();

        // 确保线程已经销毁
        while (thread.isAlive()) { }

        thread.print();
    }

    private static class StopThread extends Thread {

        private int x = 0;
        private int y = 0;

        @Override
        public void run() {
            // 这是一个同步原子操作
            synchronized (this) {
                ++x;
                try {
                    // 休眠3秒,模拟耗时操作
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ++y;
            }
        }

        public void print() {
            System.out.println("x=" + x + " y=" + y);
        }
    }
}

运行结果:

x=1 y=0

 

线程没有抛出异常,如果把stop改成interrupt,那么运行结果变为

x=1 y=1
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at com.meitu.helloworld.MyThread$StopThread.run(MyThread.java:34)

 

stop() 方法事实上已被废弃,它对线程的强制中断是不可预期的。

interrupt() 方法是一个比较温柔的做法,它更类似一个标志位。它不能中断线程,而是「通知线程应该中断了」,具体到底中断还是继续运行,应该由被通知的线程自己处理:

具体来说,当对一个线程,调用 interrupt() 时,

  1. 如果线程处于被阻塞状态(例如处于sleep, wait, join 等状态),那么线程将立即退出被阻塞状态,并抛出一个InterruptedException异常,仅此而已。
  2. 如果线程处于正常活动状态,那么会将该线程的中断标志设置为 true,仅此而已。被设置中断标志的线程将继续正常运行,不受影响。
可见,interrupt() 并不能真正的中断线程,需要被调用的线程自己进行配合才行。也就是说,一个线程如果有被中断的需求,那么就可以这样做。
  • 在正常运行任务时,经常检查本线程的中断标志位,如果被设置了中断标志就自行停止线程;
  • 在调用阻塞方法时正确处理InterruptedException异常;



 

最后,总结下创建Thread的三种方法:
  1. 继承Thread类,重写run方法;
  2. 实现Runnable的run方法;
  3. 实现Callable的call方法;

 

 

线程池

 

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler);

 

参数:

  • corePoolSize : 核心线程数,一旦创建将不会再释放;
  • maximumPoolSize : 最大线程数,如果最大线程数等于核心线程数,则无法创建非核心线程;如果非核心线程处于空闲时,超过设置的空闲时间,则将被回收,释放占用的资源。
  • keepAliveTime : 也就是当线程空闲时,所允许保存的最大时间,超过这个时间,线程将被释放销毁,但只针对于非核心线程。
  • unit : 时间单位,TimeUnit.SECONDS等。
  • workQueue : 任务队列,用于保存等待执行的任务的阻塞队列,可以选择以下几个阻塞队列。
  1. ArrayBlockingQueue:是一个基于数组结构的有界阻塞队列,必须设置容量。此队列按 FIFO(先进先出)原则对元素进行排序。
  2. LinkedBlockingQueue:一个基于链表结构的阻塞队列,可以设置容量,此队列按FIFO (先进先出) 排序元素,吞吐量通常要高于ArrayBlockingQueue。
  3. SynchronousQueue:一个不存储元素的阻塞队列。每个插入offer操作必须等到另一个线程调用移除poll操作,否则插入操作一直处于阻塞状态,吞吐量通常要高于LinkedBlockingQueue。
  4. PriorityBlockingQueue:一个具有优先级的无限阻塞队列。
  • threadFactory :  线程工厂,用于创建线程。
  • handler : 拒绝策略,当线程边界和队列容量已经达到最大时,用于处理阻塞时的程序:
  1. AbortPolicy:默认策略,抛出异常RejectedExecutionException拒绝提交任务;
  2. CallerRunsPolicy:由调用execute方法提交任务的线程来执行这个任务;
  3. DiscardPolicy:直接抛弃任务,不做任何处理;
  4. DiscardOldestPolicy:去除任务队列中的第一个任务,重新提交;

 

 

处理任务

提交任务有2个方法:
  • execute(Runnable),无返回值;
  • submit(Callable<T>),有返回值;
看一个例子:
public class ThreadTest {

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

        final AtomicInteger mThreadNum = new AtomicInteger(1);

        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4,
                10, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(2),
                new ThreadFactory() {
                    @Override
                    public Thread newThread(@NotNull Runnable r) {
                        Thread t = new Thread(r, "my-thread-" + mThreadNum.getAndIncrement());
                        System.out.println(t.getName() + " has been created");
                        return t;
                    }
                },
                new RejectedExecutionHandler() {
                    @Override
                    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
                        System.err.println(r.toString() + " rejected");
                    }
                });

        executor.prestartAllCoreThreads(); // 预启动所有核心线程

        for (int i = 1; i <= 10; i++) {
            MyTask task = new MyTask(String.valueOf(i));
            executor.execute(task);
        }

        executor.shutdown();
    }

    static class MyTask implements Runnable {
        private String name;

        public MyTask(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            try {
                System.out.println(this.toString() + " is running!");
                Thread.sleep(3000); //让任务执行慢点
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        @Override
        public String toString() {
            return "MyTask [name=" + name + "]";
        }
    }
}

运行结果:

my-thread-1 has been created
my-thread-2 has been created
my-thread-3 has been created
MyTask [name=1] is running!
my-thread-4 has been created
MyTask [name=3] is running!
MyTask [name=2] is running!
MyTask [name=5] is running!
MyTask [name=7] rejected
MyTask [name=8] rejected
MyTask [name=9] rejected
MyTask [name=10] rejected
MyTask [name=4] is running!
MyTask [name=6] is running!

其中线程线程1-4先占满了核心线程和最大线程数量,然后4、5线程进入等待队列,7-10线程被直接忽略拒绝执行,等1-4线程中有线程执行完后通知4、5线程继续执行。

 

当在execute(Runnable)方法中提交新任务并且少于corePoolSize线程正在运行时,即使其他工作线程处于空闲状态,也会创建一个新线程来处理该请求。 如果有多于corePoolSize但小于maximumPoolSize线程正在运行,则仅当队列已满时才会创建新线程。 通过设置corePoolSize和maximumPoolSize相同,您可以创建一个固定大小的线程池。 通过将maximumPoolSize设置为基本上无界的值,例如Integer.MAX_VALUE,您可以允许池容纳任意数量的并发任务。

 

  1. 如果运行的线程少于 corePoolSize,则 Executor 始终首选添加新的线程,而不进行排队。(即如果当前运行的线程小于corePoolSize,则任务根本不会添加到workQueue中)
  2. 如果运行的线程等于或多于 corePoolSize,则 Executor 始终首选将请求加入工作队列,而不添加新的线程
  3. 如果无法将请求加入workQueue(但是队列已满),则创建新的线程,除非创建此线程超出 maximumPoolSize,如果超过,在这种情况下,新的任务将被拒绝。

 

 

预定义线程池

FixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

corePoolSize与maximumPoolSize相等,即其线程全为核心线程,是一个固定大小的线程池。

 

 

SingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

看起来很像 newFixedThreadPool(1),但多了一层 FinalizableDelegatedExecutorService 包装,看下它的作用:

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(1);
((ThreadPoolExecutor) fixedThreadPool).setMaximumPoolSize(3);
System.out.println(((ThreadPoolExecutor) fixedThreadPool).getMaximumPoolSize());    // 3

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
((ThreadPoolExecutor) singleThreadExecutor).setMaximumPoolSize(3);  // 运行时异常 java.lang.ClassCastException
//System.out.println(((ThreadPoolExecutor) singleThreadExecutor).getMaximumPoolSize()); 

可见,SingleThreadExecutor被包装后,无法成功向下转型。因此,SingleThreadExecutor被定以后,无法修改,做到了真正的Single。

 

 

newCachedThreadPool

 public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

corePoolSize = 0,maximumPoolSize = Integer.MAX_VALUE,即其线程全为非核心线程,空闲超时会被释放。

 

 

ScheduledThreadPool

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
newScheduledThreadPool调用的是ScheduledThreadPoolExecutor的构造方法,
而ScheduledThreadPoolExecutor继承了ThreadPoolExecutor,构造是还是调用了其父类的构造方法。
public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

 

 

 

关闭线程池

线程池自动关闭的两个条件:1、线程池的引用不可达;2、线程池中没有线程;

如果核心线程不为0,由于没有超时策略,所以并不会自动关闭。

 

当shutdown一个线程池后,继续提交任务,会执行拒绝策略;

public static void main(String[] args) {
    ThreadPoolExecutor executor = new ThreadPoolExecutor(4, 4, 10, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
    executor.execute(() -> System.out.println("before shutdown"));
    executor.shutdown();
    executor.execute(() -> System.out.println("after shutdown"));
}

 

shutdown一个线程池后,等待队列的任务仍会被继续执行,但如果用shutdownNow()方法,则不执行队列中的任务;

shutdown和shutdownNow对正在执行的任务的影响是怎样的呢?

public class InteruptTest {

    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 10, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
        executor.execute(new Task("0"));
        Thread.sleep(1);
        executor.shutdownNow();
        System.out.println("executor has been shutdown");
    }

    static class Task implements Runnable {
        String name;

        public Task(String name) {
            this.name = name;
        }

        @Override
        public void run() {

            for (int i = 1; i <= 100 && !Thread.interrupted(); i++) {
                Thread.yield();
                System.out.println("task " + name + " is running, round " + i);
            }

        }
    }
}

运行结果:

task 0 is running, round 1
task 0 is running, round 2
task 0 is running, round 3
task 0 is running, round 4
task 0 is running, round 5
task 0 is running, round 6
task 0 is running, round 7
task 0 is running, round 8
task 0 is running, round 9
task 0 is running, round 10
task 0 is running, round 11
task 0 is running, round 12
task 0 is running, round 13
task 0 is running, round 14
task 0 is running, round 15
task 0 is running, round 16
task 0 is running, round 17
task 0 is running, round 18
task 0 is running, round 19
executor has been shutdown
task 0 is running, round 20

shutdownNow 会将正在执行任务的Thread.interrupted 置为true,如果线程检测了该状态,可以决定要不要停止运行。

总结一下:

shutdown

停止接收外部submit的任务

l 内部正在跑的任务和队列里等待的任务,会执行完

l 等到第二步完成后,才真正停止

 

shutdownNow

l 停止接收外部submit的任务

l 队列里等待的任务走拒绝策略;

l interrupt正在执行的任务;

| 等到第三步完成后,才真正停止

 

 

调整线程池大小

对于CPU密集型任务,线程池大小可以设置为CPU核数,这可以通过下面的方式获取

Runtime.getRuntime().availableProcessors();

 

对于IO密集型任务,线程池大小可以参考公式:

  NThreads = NCPU * UCPU * (1 + W/C)

其中:

  • NCPU,CPU核个数;
  • UCPU,期望的CPU利用率(0-1之间);
  • W/C,等待时间/计算时间 比率;

 

 

ForkJoinPool

ForkJoinPool是ExecutorSerice的一个补充,而不是替代品,特别适合用于“分而治之”,递归计算的算法。

JAVA8 中CompeleteFuture、并发流等都是基于ForkJoinPool实现;

ForkJoinPool的线程池默认大小为CPU核数:

    /**
     * Creates a {@code ForkJoinPool} with parallelism equal to {@link
     * java.lang.Runtime#availableProcessors}, using the {@linkplain
     * #defaultForkJoinWorkerThreadFactory default thread factory},
     * no UncaughtExceptionHandler, and non-async LIFO processing mode.
     *
     * @throws SecurityException if a security manager exists and
     *         the caller is not permitted to modify threads
     *         because it does not hold {@link
     *         java.lang.RuntimePermission}{@code ("modifyThread")}
     */
    public ForkJoinPool() {
        this(Math.min(MAX_CAP, Runtime.getRuntime().availableProcessors()),
             defaultForkJoinWorkerThreadFactory, null, false);
    }

 

 

例子:使用RecursiveTask实现一个累加的功能,使用分而治之的思想,实现分段求和后汇总

import java.util.concurrent.RecursiveTask;

public class SumTask extends RecursiveTask<Integer> {

    private Integer start = 0;
    private Integer end = 0;

    public SumTask(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {

        if (end - start < 100) {
            int sumResult = 0;
            for (int i = start; i <= end; i++) {
                sumResult += i;
            }
            return sumResult;

        } else {
            int middle = (end + start) / 2;
            SumTask leftSum = new SumTask(this.start, middle);
            SumTask rightSum = new SumTask(middle + 1, this.end);
            leftSum.fork();
            rightSum.fork();
            return leftSum.join() + rightSum.join();
        }
    }

    public static void main(String[] args) {
        SumTask sumTask = new SumTask(1, 999999);
        sumTask.fork();
        System.out.println("result:" + sumTask.join());
    }
}

看下fork()方法做了什么:

    public final ForkJoinTask<V> fork() {
        Thread t;
        if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread)
            ((ForkJoinWorkerThread)t).workQueue.push(this);
        else
            ForkJoinPool.common.externalPush(this);
        return this;
    }
当前线程不是个ForkJoinWorkerThread的时候,则加入到ForkJoinPool线程池(基于ExecutorService实现);
当前线程已经是ForkJoinWorkerThread了,则把这个任务加入到当前线程的workQueue。
这是和普通线程池不同的地方,task并不是交给线程池中的queue,而是放到线程本地的workQueue。
 
ForkJoinPool中的工作线程是由ForkJoinWorkerThread类实现的,其通过维护一个双端队列(ForkJoinPool.WorkQueue)来存放Task的,这里的Task一般是ForkJoinTask的子类。每一个工作线程简单的通过以下两条原则进行活动:
  • 若队列非空,则代表自己线程的Task还没执行完毕,取出Task并执行。
  • 若队列为空,则随机选取一个其他的工作线程的Task并执行(work-stealing)。


那么为了减少在对Task双端队列进行操作时的Race Condition,这里的双端队列通过维护一个top变量和一个base变量来解决这个问题。top变量类似于栈帧,当ForkJoinTask fork出新的Task或者Client从外部提交一个新的Task的ForkJoinPool时,工作线程将Task以LIFO的方式push到双端队列的队头,top维护队头的位置,可以简单理解为双端队列push的部分为一个栈。而base维护队列的队尾,当别的线程需要从本工作线程密取任务时,是从双端队列的队尾出取出任务。工作队列基于以下几个保证对队列进行操作:

  • push和pop操作只会被owner线程调用。
  • 只有非owner线程会调用take操作。
  • pop和take操作只有在队列将要变成空(当前只有一个元素)时才会需要处理同步问题。

也就是说这个实现的双端队列将整体的同步问题转换为了一个two-party的同步问题,对于take而言我们只要提供一个简单的entry lock来保证所以其他线程的take的一致性,而对于自己owner线程的pop和push几乎不需要同步。

由于ForkJoinPool的这些特性,因此它除了适合用来实现分而治之的计算框架以外,还非常适合用来作为基于event的异步消息处理执行框架,而Akka正是将ForkJoinPool作为默认的底层ExcutorService。事实证明,ForkJoinPool在Akka这种基于消息传递的异步执行环境下能够展现出非常高的性能优势,前提是尽量减少在处理过程中的线程阻塞(如IO等待等等)。

 

以上是关于Java 线程池的主要内容,如果未能解决你的问题,请参考以下文章

Java线程池详解

Java 线程池详解

newCacheThreadPool()newFixedThreadPool()newScheduledThreadPool()newSingleThreadExecutor()自定义线程池(代码片段

Java线程池详解

IDEA对新建java线程池的建议

java中的进程,线程,线程池总结