JAVA六大线程池详解

最新推荐文章于 2024-08-24 17:39:43 发布

OnlyGky

最新推荐文章于 2024-08-24 17:39:43 发布

阅读量295

点赞数

分类专栏：多线程 Java

本文链接：https://blog.csdn.net/printfxgd/article/details/93749719

版权

Java 同时被 2 个专栏收录

40 篇文章 0 订阅

订阅专栏

多线程

9 篇文章 0 订阅

订阅专栏

1）Executor执行器

详解

线程池的最顶层接口，内部就一个execute方法yong书写线程的具体执行方式

public class testExecutor implements Executor {

    public static void main(String[] args) {
        new testExecutor().execute(()-> System.out.println("hello "));
    }

    @Override
    public void execute(Runnable command) {
//        command.run();
        new Thread(command).start();
    }
}

2）Executors

这是一个工厂类，里面包含了创建线程池的方法

3）ExecutorService

一个继承了Executor的接口，基本上所有的线程池都是继承了这个接口或者它的实现类

4）Callable

主要是跟Runnable的区别：Callable有返回值并且可以抛出异常

5）启动一个固定个数的线程池

ExecutorService service= Executors.newFixedThreadPool(5);

public class To_5_ThreadPool {
    public static void main(String[] args) throws InterruptedException {
        //启动一个固定的线程池，所以的线程池都实现了这个接口 ExecutorService
        ExecutorService service= Executors.newFixedThreadPool(5);
        for(int i=0;i<6;i++){
            service.execute(()->{
                try{
                    TimeUnit.MICROSECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            });
        }
        System.out.println(service);
        service.shutdown();//等待所有的任务都执行完再关闭
        System.out.println(service.isTerminated());//是不是所有的线程都执行完了
        System.out.println(service.isShutdown());//是不是正在关闭
        System.out.println(service);

        TimeUnit.SECONDS.sleep(5);

        System.out.println(service.isTerminated());
        System.out.println(service.isShutdown());
        System.out.println(service);
    }
}

作用：该线程池拥有一个共享无边界队列，在任何时间点，最多有指定的个数线程在活动，当所有线程都在活动时，有任务提交过来，这个任务会一直在队列中等待，直到线程执行完这个任务。队列实例为

6)Future

表示一个可能还没有完成的异步任务的结果，有RunnableFuture和SchedualFuture继承这个接口，以及CompleteFuture和ForkJoinTask。

public static void main(String[] args) throws ExecutionException, InterruptedException {
        //包装一个Callable方法
        FutureTask<Integer>task=new FutureTask<>(()->{
            TimeUnit.MICROSECONDS.sleep(500);
            return 1000;
        });
        new Thread(task).start();
        System.out.println(task.get());//阻塞获取task方法

        ExecutorService service= Executors.newFixedThreadPool(5);
        Future<Integer>f=service.submit(()->{
            TimeUnit.MICROSECONDS.sleep(500);
            return 1;
        });

        System.out.println(f.isDone());

        System.out.println(f.get());//什么时候执行完什么时候拿到结果

        System.out.println(f.isDone());
    }

RunnableFuture

这个接口同时继承Future接口和Runnable接口，在成功执行run（）方法后，可以通过Future访问执行结果。这个接口都实现类是FutureTask,一个可取消的异步计算，这个类提供了Future的基本实现，后面我们的demo也是用这个类实现，它实现了启动和取消一个计算，查询这个计算是否已完成，恢复计算结果。计算的结果只能在计算已经完成的情况下恢复。如果计算没有完成，get方法会阻塞，一旦计算完成，这个计算将不能被重启和取消，除非调用runAndReset方法。
FutureTask能用来包装一个Callable或Runnable对象，因为它实现了Runnable接口，而且它能被传递到Executor进行执行。为了提供单例类，这个类在创建自定义的工作类时提供了protected构造函数。

SchedualFuture

这个接口表示一个延时的行为可以被取消。通常一个安排好的future是定时任务SchedualedExecutorService的结果

CompleteFuture

一个Future类是显示的完成，而且能被用作一个完成等级，通过它的完成触发支持的依赖函数和行为。当两个或多个线程要执行完成或取消操作时，只有一个能够成功。

ForkJoinTask

基于任务的抽象类，可以通过ForkJoinPool来执行。一个ForkJoinTask是类似于线程实体，但是相对于线程实体是轻量级的。大量的任务和子任务会被ForkJoinPool池中的真实线程挂起来，以某些使用限制为代价。

主要方法：

get（）方法可以当任务结束后返回一个结果，如果调用时，工作还没有结束，则会阻塞线程，直到任务执行完毕

get（long timeout,TimeUnit unit）做多等待timeout的时间就会返回结果

cancel（boolean mayInterruptIfRunning）方法可以用来停止一个任务，如果任务可以停止（通过mayInterruptIfRunning来进行判断），则可以返回true,如果任务已经完成或者已经停止，或者这个任务无法停止，则会返回false.

isDone（）方法判断当前方法是否完成

isCancel（）方法判断当前方法是否取消

public static void main(String[] args) throws ExecutionException, InterruptedException {
        //包装一个Callable方法
        FutureTask<Integer>task=new FutureTask<>(()->{
            TimeUnit.MICROSECONDS.sleep(500);
            return 1000;
        });
        new Thread(task).start();
        System.out.println(task.get());//阻塞获取task方法

        ExecutorService service= Executors.newFixedThreadPool(5);
        Future<Integer>f=service.submit(()->{
            TimeUnit.MICROSECONDS.sleep(500);
            return 1;
        });

        System.out.println(f.isDone());

        System.out.println(f.get());//什么时候执行完什么时候拿到结果

        System.out.println(f.isDone());
    }

7) CachedThreadPool

public static void main(String[] args) throws InterruptedException {
//每来一个线程如果有空闲的话直接用空闲的，如果没有的话new一个新的，空闲线程超过一分钟的话就
// 自动销毁
ExecutorService service= Executors.newCachedThreadPool();
System.out.println(service);

    for(int i=0;i<2;i++){
        service.execute(()->{
            try{
                TimeUnit.MICROSECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
        });
    }
    System.out.println(service);

    TimeUnit.SECONDS.sleep(10);

    System.out.println(service);


}

}

public static void main(String[] args) throws InterruptedException {
        //每来一个线程如果有空闲的话直接用空闲的，如果没有的话new一个新的，空闲线程超过一分钟的话就
        // 自动销毁
        ExecutorService service= Executors.newCachedThreadPool();
        System.out.println(service);

        for(int i=0;i<2;i++){
            service.execute(()->{
                try{
                    TimeUnit.MICROSECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            });
        }
        System.out.println(service);

        TimeUnit.SECONDS.sleep(10);

        System.out.println(service);
    }
}

作用：

该线程池创建的数量几乎没有限制，如果往该线程池中提交任务，线程池中没有空闲现程，则新建线程，如果有则直接重用，线程在规定时间内如果一直空闲，则自动终止。

8） SingleThreadExecutor

  public static void main(String[] args) {

        //永远都只有一个线程的线程池
        ExecutorService service= Executors.newSingleThreadExecutor();
        for(int i=0;i<6;i++){
            final int j=i;
            service.execute(()->{

                System.out.println(Thread.currentThread().getName());
            });
        }
    }

作用：

它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

9） ScheduledThreadPool

ScheduledExecutorService service= Executors.newScheduledThreadPool(4);

 public static void main(String[] args) {
        //定时器线程池
        ScheduledExecutorService service= Executors.newScheduledThreadPool(4);
        //以固定的频率来执行某个任务
       service.scheduleAtFixedRate(()->{
                try{
                    TimeUnit.MICROSECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            },0,500,TimeUnit.MICROSECONDS);
        }
    }

作用：

继承ThreadPoolExecutor且实现了ScheduledExecutorService接口，它就相当于提供了“延迟”和“周期执行”功能的ThreadPoolExecutor。任务队列为DelayQueue

10) WorkStealingPool

public static void main(String[] args) throws IOException {
        //使用forkjoinpool实现的
        ExecutorService service= Executors.newWorkStealingPool();

        service.execute(new R(1000));
        service.execute(new R(2000));
        service.execute(new R(2000));
        service.execute(new R(2000));
        service.execute(new R(2000));
//产生的是后台线程，主线程不阻塞看不到输出
        System.in.read();
    }
    static class R implements Runnable{

        int time;

        R(int t){
            time=t;
        }
        @Override
        public void run() {
            try{
                TimeUnit.MICROSECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
        }
    }

特点

每个线程都有要处理的队列中的任务，如果其中的线程完成自己队列中的任务，那么它可以去其他线程中获取其他线程的任务去执行，其内部会创建ForkJoinPool，利用Work-Stealing算法，并行的处理任务，不保证处理顺序。

11) ForkJoinPool

public class T11_FORKjOINpool {
static int[] nums=new int[1000000];
static final  int MAX_NUM=50000;
static Random r=new Random();
static {
    for(int i=0;i<nums.length;i++){
        nums[i]=r.nextInt();
    }
    System.out.println(Arrays.stream(nums).sum());
}
static class AddTask extends RecursiveAction{//递归任务，无返回值RecursiveTask

    int start,end;
    AddTask(int s,int e){
        start=s;
        end=e;
    }
    @Override
    protected void compute() {
        if(end-start<=MAX_NUM){
            long sum=0L;
            for(int i=start;i<end;i++) sum+=nums[i];
            System.out.println("from: "+start+" to:"+end+" = "+sum);
        }else {
            int middle=start+(end-start)/2;
            AddTask subTask1=new AddTask(start,middle);
            AddTask subTask2=new AddTask(start,middle);
            subTask1.fork();
            subTask2.fork();
        }
    }

    public static void main(String[] args) throws IOException {
        ForkJoinPool fjp=new ForkJoinPool();
        AddTask task=new AddTask(0,nums.length);
        System.in.read();
    }
}
}