java并发编程-java线程池

最新推荐文章于 2024-11-03 11:01:20 发布

谢俊华

最新推荐文章于 2024-11-03 11:01:20 发布

阅读量275

点赞数

分类专栏： java 文章标签： java 线程池

本文链接：https://blog.csdn.net/m0_37895333/article/details/77923358

版权

java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本为重点探讨java中的线程池如果使用，以及各自的使用场景，对于其原理，因个人能力有限，只能做一些粗浅的介绍。
java 中的七种线程池分别是:

newCacheThreadPool 创建一个可缓存的线程池,如果线程池长度超过处理需要，可灵活回收空闲线程。
newFixedThreadPool 创建一个定长线程池
newSingleThreadExecutor 创建一个单线程化的线程池
newSingleThreadScheduledExecutor 创建一个单线程化的线程池，支持定时及周期性任务
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务
newWorkStealingPool 创建持有足够线程数的线程池来支持给定的并行级别，并通过使用多个队列，减少竞争,java 8新增
ForkJoinPool 支持大任务分解成小任务的线程池

newCacheThreadPool

class LiftOff implements Runnable {
    protected int countDown = 10;
    private static int taskCount = 0;
    private final int id = taskCount++; //用来区分多个任务的实例
    public LiftOff() {

    }
    public LiftOff(int countDown) {
        this.countDown = countDown;
    }
    public String status() {
        return "#" + id + "(" + (countDown > 0 ? countDown : "Liftoff!") + ").";
    }
    public void run() {
        //run中通常会有某种形式的循环，使得任务一直运行下去直到不再需要。
        while (countDown-- >0) {
            System.out.println("Thread-Name: " + Thread.currentThread().getName() + "  " + status());
            Thread.yield();
        }
    }
}

public class ThreadPoolSample{
    public static void main(String[] args) {
        //Executor用来管理Thread对象，简化并发编程。是并发编程中启动任务的首选方法
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 100; i++) {
          // 提交任务
            executorService.execute(new LiftOff());
        }
        // 任务全部提交之后，记得关闭线程池
        executorService.shutdown();
    }
}

newCacheThreadPool 会尽可能的回收复用已有的线程，在没有可以使用的线程的时候，会去新建一个线程，加入到线程池中，线程数是没有上限。持续1分钟没有被使用的线程就会被从线程池中删掉。newCacheThreadPool在执行大量耗时较短的任务时，性能比较高。

newFixedThreadPool

public class ThreadPoolSample{
    public static void main(String[] args) {
        //Executor用来管理Thread对象，简化并发编程。是并发编程中启动任务的首选方法
        // 固定只有两个线程
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        for (int i = 0; i < 100; i++) {
          // 提交任务
            executorService.execute(new LiftOff());
        }
        // 任务全部提交之后，记得关闭线程池
        executorService.shutdown();
    }
}

newFixedThreadPool 会创造固定的线程数来处理任务，当新的任务出现的时候，会被加到一个无限长度的queue里，如果有空闲的线程可用，就执行任务，如果没有空闲的线程可用，任务会一直被保存在队列中，直到前面的任务被执行完，释放出线程资源。线程执行任务的过程中发生异常，会新建一个新的线程取代发生异常的线程，保证线程池中线程数在一个固定数量。

newSingleThreadExecutor

等价于newFixedThreadPool(1)。执行任务的过程中，发生异常会产生一个新的线程，替代老的线程，始终保证线程池有一个可用的线程，可以执行queue中的任务。

newScheduledThreadPool

newScheduledThreadPool 支持任务调度，持续执行，或者延迟一段时间后执行。

public class ThreadPoolSample{
    public static void main(String[] args) {
        //Executor用来管理Thread对象，简化并发编程。是并发编程中启动任务的首选方法
        // 固定只有两个线程
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(2);
        //每隔一秒钟执行一次任务，不关心上一个任务是否完成
        ScheduledFuture future = executorService.scheduleAtFixedRate(() -> {
            Date date = new Date();
            System.out.println("线程: " + Thread.currentThread().getName() + " 报时：" + date);
        }, 1, 1, TimeUnit.SECONDS);

        // 上一个任务完成之后，间隔一秒，执行下一个任务
        ScheduledFuture future2 = executorService.scheduleWithFixedRate(() -> {
            Date date = new Date();
            System.out.println("线程: " + Thread.currentThread().getName() + " 报时：" + date);
        }, 1, 1, TimeUnit.SECONDS);

        // 任务在延迟一分钟后执行
        ScheduledFuture future3 = executorService.schedule(() -> {
          Date date = new Date();
            System.out.println("线程: " + Thread.currentThread().getName() + " 报时：" + date);
        }, 1, TimeUnit.MINUTES)

        future3.getDelay();//获取剩余延迟时间


    }
}

调度一个任务之后，会产生一个专门的future类型ScheduleFuture，除了提供所有的Future的方法之外还提供了getDelay()方法来获取剩余的延迟时间。scheduleAtFixedRate()方法，以一个固定的频率来执行一个任务。上面的例子中是以一秒钟一次的的频率来执行。还接收一个初始化延迟的参数。scheduleAtFixedRate()并不考虑任务的实际执行时间，任务会被加载进一个队列中，然后按照固定的频率从队列中取出任务来执行。scheduleWithFixedDelay()方法与上面的scheduleAtFixedRate()类似，scheduleWithFixedDelay()是在上次任务结束到下次任务开始，设置一个固定的时间。

newSingleThreadScheduledExecutor

等价于newScheduledThreadPool(1)

newWorkStealingPool

根据源码，可以看出newWorkStealingPool()的实质是new ForkJoinPool()

/**
     * Creates a thread pool that maintains enough threads to support
     * the given parallelism level, and may use multiple queues to
     * reduce contention. The parallelism level corresponds to the
     * maximum number of threads actively engaged in, or available to
     * engage in, task processing. The actual number of threads may
     * grow and shrink dynamically. A work-stealing pool makes no
     * guarantees about the order in which submitted tasks are
     * executed.
     *
     * @param parallelism the targeted parallelism level
     * @return the newly created thread pool
     * @throws IllegalArgumentException if {@code parallelism <= 0}
     * @since 1.8
     */
    public static ExecutorService newWorkStealingPool(int parallelism) {
        return new ForkJoinPool
            (parallelism,
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

接受一个参数，或者可以不传，不传参数，parallelism值默认为cpu核数

public class ThreadPoolSample{
    public static void main(String[] args) {
        List<Callable<String>> list = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            int finalI = i;
            list.add(() -> {
                TimeUnit.MILLISECONDS.sleep(500);
                return  "task: " + Thread.currentThread().getName() + " i: " + finalI;
            });
        }
        ExecutorService executorService1 = Executors.newWorkStealingPool(5);
        ExecutorService executorService2 = Executors.newFixedThreadPool(5);

        try {
            long start = System.currentTimeMillis();
            List<Future<String>> list1 = executorService3.invokeAll(list);
            list1.stream().map(future -> {
                try {
                    return future.get();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
                return null;
            }).forEach(System.out::println);
            long end = System.currentTimeMillis();
            System.out.println("total time: " + (end - start));

            List<Future<String>> list2 = executorService2.invokeAll(list);
            list2.stream().map(future -> {
                try {
                    return future.get();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
                return null;
            }).forEach(System.out::println);
            System.out.println("cache pool time:" + (System.currentTimeMillis() - end));
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            executorService2.shutdown();
            executorService3.shutdown();
        }
    }
}

从实现上，newWorkStealingPool()和newFixedThreadPool()虽然有明显不同，但如果我们提交的任务不是ForkJoinTask，那么这两种线程池在效率上区别不大。但如果想提交ForkJoinTask,返回类型必须强转成ForkJoinPool，如果是这样的话，为什么api在设计的时候不直接将返回值设计成ForkJoinPool？所以，我觉得这个线程池存在的意义并不是希望被强转成ForkJoinPool去执行ForkJoinTask,而是提供一种新的线程池实现方式，来执行一般的task

ForkJoinPool

ForkJoinPool使用场景是将一个大任务分解成多个小任务，任务必须是ForkJoinTask的子类，包括RecursiveTask[使用场景:递归执行，有返回值],RecursiveAction[递归执行，没有返回值],CountedCompleter;这里只做一些用法上的简单讨论，具体实现思路以及源码，不做深入探讨。

import java.util.concurrent.RecursiveTask;

/**
 * Created by xiejunhua on 2017/9/6.
 */
public class MyForkAndJoinTask extends RecursiveTask<Integer>{

    private static final int MAX = 70;
    private int[] arr;
    private int start;
    private int end;


    public MyForkAndJoinTask(int[] arr, int start, int end) {
        this.arr = arr;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        int sum = 0;
        if ((end - start) < MAX) {
            for (int i = start; i < end; i++) {
                sum += arr[i];
            }
            return sum;
        } else {
            System.out.println("任务分解======");
            int middle = (start + end) / 2;
            MyForkAndJoinTask left = new MyForkAndJoinTask(arr, start, middle);
            MyForkAndJoinTask right = new MyForkAndJoinTask(arr, middle, end);
            left.fork();
            right.fork();
            return left.join() + right.join();

        }
    }
}


import java.util.Random;
import java.util.concurrent.*;

/**
 * Created by xiejunhua on 2017/9/6.
 */
public class App {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        int[] arr = new int[1000];
        ForkJoinPool service = new ForkJoinPool();

        int total = 0;
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            int temp = random.nextInt(100);
            arr[i] = temp;
            total += temp;
        }
        System.out.println(total);
        Future<Integer> future = service.submit(new MyForkAndJoinTask(arr, 0, arr.length));

        System.out.println(future.get());

        service.shutdown();
    }
}