图灵学院：java高并发之Executor

最新推荐文章于 2022-11-26 15:38:00 发布

Java这点事

最新推荐文章于 2022-11-26 15:38:00 发布

阅读量1.1k

点赞数 1

concurrent Executor

一：线程池的用途

平时的业务中，如果要使用多线程，那么我们会在业务开始前创建线程，业务结束后，销毁线程。但是对于业务来说，线程的创建和销毁是与业务本身无关的，只关心线程所执行的任务。因此希望把尽可能多的cpu用在执行任务上面，而不是用在与业务无关的线程创建和销毁上面。而线程池则解决了这个问题，线程池的作用就是将线程进行复用。

二：java并发包提供的线程池

1：线程池的类(Executors类)

类图

newFixedThreadPool 固定数量的线程池，线程池中的线程数量是固定的，不会改变。

newSingleThreadExecutor 单一线程池，线程池中只有一个线程。执行完成一个再执行另外一个，其实有点把多线程变成了单线程

newCachedThreadPool 缓存线程池，线程池中的线程数量不固定，会根据需求的大小进行改变。它的线程回自动释放默认时间是60s

newScheduledThreadPool 计划任务调度的线程池，用于执行计划任务，比如每隔5分钟怎么样，

newWorkStealingPool 创建一个 work-stealing 线程池，使用目前机器上可用的处理器作为它的并行级别。 jdk1.8新增的

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue());
}
public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue()));
}
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue());
}
 public static ExecutorService newWorkStealingPool() {
        return new ForkJoinPool
            (Runtime.getRuntime().availableProcessors(),
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

ThreadPoolExecutor 构造函数中参数的含义。

corePoolSize 线程池中核心线程数的数目

maximumPoolSize 线程池中最多能容纳多少个线程

keepAliveTime 当现在线程数目大于corePoolSize时，超过keepAliveTime时间后，多出corePoolSize的那些线程将被终结。

unit keepAliveTime的单位

workQueue 当任务数量很大，线程池中线程无法满足时，提交的任务会被放到阻塞队列中，线程空闲下来则会不断从阻塞队列中取数据。

FixedThreadPool，它的线程的核心数目和最大容纳数目都是一样的，以至于在工作期间，并不会创建和销毁线程。当任务数量很大，线程池中的线程无法满足时，任务将被保存到LinkedBlockingQueue中，而LinkedBlockingQueue的大小是Integer.MAX_VALUE。这就意味着，任务不断地添加，会使内存消耗越来越大。

CachedThreadPool,它的核心线程数量是0，最大容纳数目是Integer.MAX_VALUE，它的阻塞队列是SynchronousQueue，这是一个特别的队列，它的大小是0。由于核心线程数量是0，所以必然要将任务添加到SynchronousQueue中，这个队列只有一个线程在从中添加数据，同时另一个线程在从中获取数据时，才能成功。独自往这个队列中添加数据会返回失败。当返回失败时，则线程池开始扩展线程，这就是为什么CachedThreadPool的线程数目是不固定的。当60s该线程仍未被使用时，线程则被销毁。

相关演示代码

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecutorsDome {
    public static void main(String[] args) {
        //ExecutorService executorService = Executors.newCachedThreadPool();//默认是60s 的线程时间
       ExecutorService executorService = Executors.newFixedThreadPool(10);//固定数量的线程池，线程池中的线程数量是固定的，不会改变。
       // ExecutorService executorService = Executors.newSingleThreadExecutor();//线程池中只有一个线程，执行完成一个在执行另外一个，其实有点把多线程变成了单线程
        //ExecutorService executorService =Executors.newScheduledThreadPool(6);
      // ExecutorService executorService=Executors.newWorkStealingPool();
        executorService.execute(new ThreadPools(1));
        executorService.execute(new ThreadPools(2));
        executorService.execute(new ThreadPools(3));
        executorService.execute(new ThreadPools(4));
        executorService.execute(new ThreadPools(5));
        executorService.submit(new ThreadPools(6));
    }
}
class ThreadPools implements Runnable {
    private int i=0;
    
    public ThreadPools(int i){
        this.i=i;
    }
    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            
            e.printStackTrace();
        }
        System.out.println("ThreadPools:"+i);
    }
}

==============================

定时的demo

public class ScheduledExecutorServiceDemo {
    
    public static void main(String[] args) throws Exception, ExecutionException {
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);  
        ScheduledFuture scheduledFuture = executorService.schedule(new Callable() {  
            public String call() throws Exception {  
                return "call";  
            }  
        }, 10, TimeUnit.SECONDS);  
        System.out.println(scheduledFuture.get());  
        executorService.shutdown(); 
    }
}

结果是10s后返回"call"的结果

2：拒绝(饱和)策略

ThreadPoolExecutor的构造函数里面有一个参数是RejectedExecutionHandler，它是一个接口实现类有：AbortPolicy，CallerRunsPolicy，DiscardOldestPolicy，DiscardPolicy，这这个分别代表了4种策略

AbortPolicy：如果不能接受任务了，则抛出异常。默认拒绝策略是它

CallerRunsPolicy：如果不能接受任务了，则让调用的线程去完成。

DiscardOldestPolicy：如果不能接受任务了，则丢弃最老的一个任务，由一个队列来维护。

DiscardPolicy：如果不能接受任务了，则丢弃任务。

当然我们也可以自己实现RejectedExecutionHandler接口来自己定义拒绝策略。

3:ForkJoin

fork/join（jdk1.7新增）框架是ExecutorService接口的一种具体实现，目的是为了帮助你更好地利用多处理器带来的好处。它是为那些能够被递归地拆解成子任务的工作类型量身设计的。其目的在于能够使用所有可用的运算能力来提升你的应用的性能。类似于ExecutorService接口的其他实现，fork/join框架会将任务分发给线程池中的工作线程。fork/join框架的独特之处在与它使用工作窃取(work-stealing)算法。完成自己的工作而处于空闲的工作线程能够从其他仍然处于忙碌(busy)状态的工作线程处窃取等待执行的任务。fork/join框架的核心是ForkJoinPool类，它是对AbstractExecutorService类的扩展。ForkJoinPool实现了工作偷取算法，并可以执行ForkJoinTask任务。

他的思想可以用一张图来了解

演示代码

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;
//1*1+2*2+3*3....100*100
public class ForkJoinPoolDemo {
    public static void main(String[] args) {
        MyTask mt = new MyTask(1);
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        Future result = forkJoinPool.submit(mt);
        try {
            System.out.println(result.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        forkJoinPool.shutdown();
        
        A.a();
    }
}
//ForkJoin算法
class MyTask extends RecursiveTask {
    int i;
    public MyTask(int i){
        this.i = i;
    }
    @Override
    protected Integer compute() {
        if (i >= 100) {
            return i * i;
        }
        MyTask newTask2 = new MyTask(i + 1);
        newTask2.fork();
        return i * i + newTask2.join();
    }
}
//普通算法
class A { 
    public static void a() {
        int j=0;
        for (int i = 1; i <= 100; i++) {  
            j=j+(i*i);
            
        }
        System.out.println(j);
    }
}

以上两种算法的结果是一样的都是 338350。更深入的了解请网上超资料。