Java线程池Executor&ThreadPool

  java自1.5版本之后,提供线程池,供开发人员快捷方便的创建自己的多线程任务。下面简单的线程池的方法及说明。

  1、Executor 

    线程池的顶级接口。定义了方法execute(Runnable),该方法接收一个Runnable实例,用来执行一个任务,该任务即是一个实现Runnable接口的类。

    此服务方法无返回值,原因是因为实现Runnable接口的类的run方法是无返回(void)的。

    常用方法 : void execute(execute)

    作用 : 启动并执行线程任务

  2、ExecutorService

    继承自Executor接口,提供了更多的方法调用,例如优雅关闭方法shutdown,有返回值的submit。

    2.1、ExecutorService生命周期

      运行 - Running 、关闭 - shuttingdown、终止 - terminated

      Running : 线程池正在执行中,活动状态。创建后即进入此状态

      shuttingdown : 优雅关闭,线程池正在关闭中。不再接收新的线程任务,已有的任务(正在处理的 + 队列中阻塞的),处理完毕后,关闭线程池。

              调用shutdown()方法,即进入此状态

      terminated : 线程池已关闭。

    2.2、submit方法

      有返回值,Future类型。重载了方法,submit(Runnable)不需要提供返回值。submit(Callable)、submit(Runnable,T)可以提供线程执行后的结果返回值。

    2.3、Future

      线程执行完毕结果。获取线程执行结果是通过get()方法获取。get()无参,阻塞等待线程执行结束。

      get(long timeout, TimeUnit unit)有参,阻塞等待固定时长,超时未获取,则抛出异常。

    2.4、Callable

      类似Runnable的一个线程接口。其中的对应run的方法是call方法。此接口提供了线程执行完毕返回值。

package com.cn.cfang.executor;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Test {
    public static void main(String[] args) throws Exception{
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        Data data = new Data();
//        Future<Data> future = executorService.submit(new Task(data), data); //runnable
        Future<Data> future = executorService.submit(new Task1(data)); //callable
        System.out.println(future.get().getName());
        executorService.shutdown();
    }
}

class Data {
    String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

class Task implements Runnable{
    Data data;
    public Task(Data data) {
        this.data = data;
    }
    @Override
    public void run() {
         data.setName("hello world");
    }
}

class Task1 implements Callable<Data>{
    Data data;
    public Task1(Data data) {
        this.data = data;
    }
    @Override
    public Data call() throws Exception {
        data.setName("hello world");
        return data;
    }
    
}

   3、Executors工具类

    提供了很多的工厂方法用于创建线程池,返回的线程池都实现了ExecutorService接口。

线程池属于进程级的重量级资源,默认的生命周期同JVM一致,当开启线程池后,直到jvm关闭,是线程池的默认的生命周期。
如果手动调用shutdown方法,可优雅关闭线程池,在当前所有任务执行结束后,关闭线程池。

  4、几种常用的线程池

    4.1、FixedThreadPool

     容量固定的线程池。使用LinkedBlockingQueue作为任务队列,当任务数量大于线程池容量的时候,未执行的任务进入任务等待队列LinkedBlockingQueue中,

     当线程有空闲的时候,自动从队列中取出任务执行。

        使用场景: 大多数情况下,推荐使用的线程池。因为os系统和硬件是有线程上限限制的,不可能去无限的提供线程池操作。

    4.2、CachedThreadPool

      缓存线程池。容量 0-Integer.MAX_VALUE,自动根据任务数扩容:如果线程池中的线程数不满足任务执行需求,则创建新的线程并添加到池中。

      生命周期默认60s,当线程空闲时长到60s的时候,自动终止销毁释放线程,移除线程池。

      使用场景 : 可用于测试最高负载量,用于对FixedThreadPool容量的参考。

      注意,放入CachedThreadPool的线程不必担心其结束,超过TIMEOUT(默认60s)不活动,其会自动被终止。 

    4.3、ScheduledThreadPool

      定时及周期性的任务执行的线程池,多数情况下可用来替代Timer类。

public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(3);
        System.out.println(service);
        
        // 定时完成任务。 scheduleAtFixedRate(Runnable, start_limit, limit, timeunit)
        // runnable - 要执行的任务。
     // start_limit - 第一次执行任务的时间间隔
     // limit - 多次任务执行的时间间隔
// timeunit - 时间单位 service.scheduleAtFixedRate(new Runnable() { @Override public void run() { try { TimeUnit.MILLISECONDS.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()); } }, 0, 300, TimeUnit.MILLISECONDS); }

    4.4、SingleThreadExceutor 单一容量线程池。

    4.5、自定义线程池

      自定义线程池,可以使用ThreadPoolExecutor类来进行创建管理。线程池中,除了ForkJoinPool外,其他常用的线程池底层,都是使用ThreadPoolExecutor实现的。

      参数说明:

        corePoolSize:核心线程数,也是最少线程数。在创建线程池时,默认情况下,是不会创建线程池的,也即此时的线程池中线程数为0,直到有任务来临时,才会去创建线程。当然,手动调用prestartCoreThread()或者prestartAllCoreThreads()方法,可以初始化创建线程池中的线程。默认情况下,当有任务来临时,就会创建新的线程去处理执行,即使此时线程池中有空闲的线程。当线程数达到corePoolSize时,线程数不增加,此时任务会放入等待队列BlockingQueue中。

        workQueue:阻塞队列,用来存储等待执行的任务资源。

          maximumPoolSize:最大线程数。当阻塞队列满了,开始扩充线程池中的线程数。直到达到此最大值的时候。

        handler:当线程池中的线程数等于maximumPoolSize的时候,此时再来任务的话,交由此拒绝策略执行。

        keepAliveTime:表示的线程在空闲多长时间后会被终止。默认是在线程数大于corePoolSize才生效,也可以手动设置allowCoreThreadTimeOut()方法让线程数在不大于  corePoolSize也生效。

 public ThreadPoolExecutor(
             int corePoolSize, //核心容量,创建线程池的时候,默认有多少的线程数。也是最少线程数
                   int maximumPoolSize, //最大线程数
                   long keepAliveTime,  //线程生命周期,0为永久。当线程空闲多长时间,自动回收。
                   TimeUnit unit,  //生命周期时间单位。
                  BlockingQueue<Runnable> workQueue,  //任务阻塞队列。
           RejectedExecutionHandler handler
      ) {     
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), handler);       }

      简单例子:

package com.cn.cfang.executor;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test2 {

    public static void main(String[] args){ 
        //创建等待队列 
        BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20); 
        //创建线程池,池中保存的线程数为3,允许的最大线程数为5
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3,5,50,TimeUnit.MILLISECONDS,bqueue); 
        //创建七个任务 
        Runnable t1 = new MyThread(); 
        Runnable t2 = new MyThread(); 
        Runnable t3 = new MyThread(); 
        Runnable t4 = new MyThread(); 
        Runnable t5 = new MyThread(); 
        Runnable t6 = new MyThread(); 
        Runnable t7 = new MyThread(); 
        //每个任务会在一个线程上执行
        pool.execute(t1); 
        pool.execute(t2); 
        pool.execute(t3); 
        pool.execute(t4); 
        pool.execute(t5); 
        pool.execute(t6); 
        pool.execute(t7); 
        //关闭线程池 
        pool.shutdown(); 
    } 
}

class MyThread implements Runnable{ 
    @Override
    public void run(){ 
        System.out.println(Thread.currentThread().getName() + "正在执行。。。"); 
        try{ 
            Thread.sleep(100); 
        }catch(InterruptedException e){ 
            e.printStackTrace(); 
        } 
    } 
}

 5、forkjoin框架

    拆分合并,将一个大的任务,拆分成若干子任务,并最终汇总子任务的执行结果,得到大任务的执行结果。并行执行,采用工作窃取机制,更加有效的利用cpu资源。

    5.1、主要类

      ForkJoinPool : 用于执行Task。任务分割出的子任务会添加到当前工作线程所维护的双端队列中,进入队列的头部。

              当一个工作线程的队列里暂时没有任务时,它会随机从其他未完成工作线程的队列的尾部获取一个任务。

      ForkJoinTask:ForkJoin任务,提供在任务中执行fork()和join()操作的机制(二叉分逻辑),通常不直接继承ForkJoinTask类,

             而是继承抽象子类RecursiveTask(有返回结果) 或者 RecursiveAction (无返回结果)。

      ForkJoinWorkerThread:ForkJoinPool 内部的worker thread,用来具体执行ForkJoinTask。内部有 ForkJoinPool.WorkQueue,来保存要执行的 ForkJoinTask。

      ForkJoinPool.WorkQueue:保存要执行的ForkJoinTask。

   5.2、工作窃取机制

      1、大任务分割成N个子任务,为避免线程竞争,于是分开几个队列去保存这些子任务,并为每个队列提供一个工作线程去处理其中的任务。工作线程与任务队列一一对应。

      2、如果A线程执行完自己队列中的所有任务,如果此时其他队列中还有未执行的任务,则A线程会去窃取一个其他队列的任务来执行。但是,此时两个线程同时访问,

        可能会产生竞争问题,所以,任务队列设计成了双向队列。A线程窃取的时候,从另一端开始执行,尽可能的去避免线程竞争问题。

      3、工作窃取机制,充分的利用线程资源,并尽可能的去避免线程间的竞争问题。但是,只能是尽可能避免,并不能规避。例如,双向队列只有一个任务。

     5.3、简单使用

      例:求和 0 - 10000000000L。

package com.cn.cfang.executor;

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

/**
 * 步骤:
 *  1、建立任务类Task,继承RecursiveTask或者RecursiveAction。需要返回值则选用RecursiveTask,无需返回值选用RecursiveAction
 *  2、任务类Task,满足一定的阈值,则对子任务进行计算,不满足,则二叉分后,递归调用自身
 *  3、调用中,新建ForkJoinPool对象,新建任务类对象Task,将任务类对象Task放入ForkJoinPool中执行。
 *     如果需要返回值,则可以invoke或者Future-submit。
 * @author cfang
 * 2018年5月15日 上午10:51:03
 */
public class Test3 {
    
    public static void main(String[] args) throws Exception{
        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinWorkTask task = new ForkJoinWorkTask(0l, 10000000l);
//        Long result = pool.invoke(task);
//        System.out.println(result);
        Future<Long> future = pool.submit(task);
        System.out.println(future.get());
    }
    
}

class ForkJoinWorkTask extends RecursiveTask<Long>{

    private static final long serialVersionUID = 1L;
    
    private Long start;    //起始
    private Long end;    //终止
    private static final Long THRESHOLD = 10000L; //子任务分割阈值
    
    public ForkJoinWorkTask(Long start, Long end){
        this.start = start;
        this.end = end;
    }
    
    @Override
    protected Long compute() {
        Long sum = 0l;
        if(end - start <= THRESHOLD){ //足够小的子任务,进行计算求和
            for(Long i = start; i < end; i++){
                sum += i;
            }
        }else{ //任务拆分不满足,继续拆分(二叉分逻辑)
            Long middle = (start + end) / 2;
            ForkJoinWorkTask rightTask = new ForkJoinWorkTask(start, middle);
            rightTask.fork();
            ForkJoinWorkTask leftTask = new ForkJoinWorkTask(middle + 1, end);
            leftTask.fork();
            sum = rightTask.join() + leftTask.join();
        }
        return sum;
    }
    
}

 

posted @ 2018-05-15 11:06  阿呆很呆非常呆  阅读(2780)  评论(0编辑  收藏  举报