java线程池的简单介绍与使用

最新推荐文章于 2024-01-05 11:49:12 发布

十一月Siy

最新推荐文章于 2024-01-05 11:49:12 发布

阅读量277

点赞数

分类专栏： Java android

本文链接：https://blog.csdn.net/baidu_34012226/article/details/60138615

版权

android 同时被 2 个专栏收录

42 篇文章 0 订阅

订阅专栏

Java

15 篇文章 0 订阅

订阅专栏

一、介绍

线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件）,则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才启动。

二、作用

1，减少线程创建和销毁的次数，使每个工作线程都可以重复利用。

2，可以手动控制线程的数量，防止因为线程启动的过多使用系统超过负荷。

三、类的层级结构

1，Executor顶层接口，在它里面只声明了一个方法execute(Runnable)，返回值为void，参数为Runnable类型，从字面意思可以理解，就是用来执行传进去的任务的

2，ExecutorService定义了完成的线程池的行为，可以接受提交任务、执行任务、关闭服务。
3，AbstractExecutorService实现了ExecutorService接口，也实现了接口定义的默认行为。

4，ThreadPoolExecutor实现了ExecutorService接口的全部默认行为。

四、Java中的ThreadPoolExecutor类

1，构造方法：

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

corePoolSize：核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；

unit：参数keepAliveTime的时间单位

TimeUnit.DAYS;               //天
TimeUnit.HOURS;             //小时
TimeUnit.MINUTES;           //分钟
TimeUnit.SECONDS;           //秒
TimeUnit.MILLISECONDS;      //毫秒
TimeUnit.MICROSECONDS;      //微妙
TimeUnit.NANOSECONDS;       //纳秒

workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：

ArrayBlockingQueue;        //基于数组的先进先出队列，此队列创建时必须指定大小
LinkedBlockingQueue;      //基于链表的先进先出队列，如果创建时没有指定此队列大小，则默认为Integer.MAX_VALUE
SynchronousQueue;         //不保存提交的任务，而是将直接新建一个线程来执行新来的任务

threadFactory：线程工厂，主要用来创建线程；

handler：表示当拒绝处理任务时的策略

ThreadPoolExecutor.AbortPolicy        //丢弃任务并抛出RejectedExecutionException异常。 
ThreadPoolExecutor.DiscardPolicy      //也是丢弃任务，但是不抛出异常。 
ThreadPoolExecutor.DiscardOldestPolicy    //丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy        //由调用线程处理该任务

如果当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会创建一个线程去执行这个任务；
如果当前线程池中的线程数目>=corePoolSize，则每来一个任务，会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（一般来说是任务缓存队列已满），则会尝试创建新的线程去执行这个任务；
如果当前线程池中的线程数目达到maximumPoolSize，则会采取任务拒绝策略进行处理；
如果线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；如果允许为核心池中的线程设置存活时间，那么核心池中的线程空闲时间超过keepAliveTime，线程也会被终止。

五、几个常用的线程池

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。

1，newSingleThreadExecutor

corePoolSize和maximumPoolSize都设置为1，也使用的LinkedBlockingQueue

创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

2，newFixedThreadPool

corePoolSize和maximumPoolSize值是相等的，它使用的LinkedBlockingQueue

创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

3，newCachedThreadPool

corePoolSize设置为0，将maximumPoolSize设置为Integer.MAX_VALUE，使用的SynchronousQueue，也就是说来了任务就创建线程运行，当线程空闲超过60秒，就销毁线程

创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，
那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
4，newScheduledThreadPool
创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

下面看看如何使用：

public class TestA {
    class MyThread extends Thread {
        String name;
        public MyThread(String name){
            this.name = name;
        }

        @Override
        public void run() {
            System.out.println(name+":"+Thread.currentThread().getName());
        }
    }

    private void createThreadPool() {
        Thread t1 = new MyThread("第一个");
        Thread t2 = new MyThread("第二个");
        Thread t3 = new MyThread("第三个");
        Thread t4 = new MyThread("第四个");
        Thread t5 = new MyThread("第五个");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }

    public void threadPool() {
       createThreadPool();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

输出：

第一个:Thread-0
第二个:Thread-1
第五个:Thread-4
第四个:Thread-3
第三个:Thread-2

分别开了5个不同的线程去执行不同的任务。

1，newSingleThreadExecutor：

 private void createThreadPool() {
        Thread t1 = new MyThread("第一个");
        Thread t2 = new MyThread("第二个");
        Thread t3 = new MyThread("第三个");
        Thread t4 = new MyThread("第四个");
        Thread t5 = new MyThread("第五个");

        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(t1);
        executorService.execute(t2);
        executorService.execute(t3);
        executorService.execute(t4);
        executorService.execute(t5);
        executorService.shutdown();
    }

输出：

第一个:pool-1-thread-1
第二个:pool-1-thread-1
第三个:pool-1-thread-1
第四个:pool-1-thread-1
第五个:pool-1-thread-1

它能保证所有的任务都在同一个线程中执行，而且所有的任务都顺序执行。

2，newFixedThreadPool

  private void createThreadPool() {
        Thread t1 = new MyThread("第一个");
        Thread t2 = new MyThread("第二个");
        Thread t3 = new MyThread("第三个");
        Thread t4 = new MyThread("第四个");
        Thread t5 = new MyThread("第五个");

        ExecutorService executorService = Executors.newFixedThreadPool(2);
        executorService.execute(t1);
        executorService.execute(t2);
        executorService.execute(t3);
        executorService.execute(t4);
        executorService.execute(t5);
        executorService.shutdown();
    }

输出：

第一个:pool-1-thread-1
第三个:pool-1-thread-1
第二个:pool-1-thread-2
第四个:pool-1-thread-1
第五个:pool-1-thread-1

能保证任务都在2个工作线程中执行，但是不能保证任务的执行顺序。
3，newCachedThreadPool,

  private void createThreadPool() {
        Thread t1 = new MyThread("第一个");
        Thread t2 = new MyThread("第二个");
        Thread t3 = new MyThread("第三个");
        Thread t4 = new MyThread("第四个");
        Thread t5 = new MyThread("第五个");
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(t1);
        executorService.execute(t2);
        executorService.execute(t3);
        executorService.execute(t4);
        executorService.execute(t5);
        executorService.shutdown();
    }

输出：

第二个:pool-1-thread-2
第一个:pool-1-thread-1
第四个:pool-1-thread-2
第三个:pool-1-thread-3
第五个:pool-1-thread-4

4，newScheduledThreadPool

  private void createThreadPool() {
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
       executorService.scheduleAtFixedRate(new Runnable() {
           @Override
           public void run() {
                System.out.println("---------------------------");
           }
       },500,1000, TimeUnit.MICROSECONDS);

        executorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(System.currentTimeMillis()+":"+Thread.currentThread().getName());
            }
        },500,1000, TimeUnit.MICROSECONDS);
    }

输出：

---------------------------
1488523824853:pool-1-thread-1
---------------------------
1488523824853:pool-1-thread-1
---------------------------
1488523824855:pool-1-thread-1
---------------------------
1488523824855:pool-1-thread-1

六、常用的API

1，submit，execute

 private void createThreadPool(){
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Thread t1 = new MyThread("第一个");
        Thread t2 = new MyThread("第二个");
        Thread t3 = new MyThread("第三个");
        Thread t4 = new MyThread("第四个");
        Thread t5 = new MyThread("第五个");

        executorService.submit(t1);
        executorService.submit(t2);
        executorService.submit(t3);
        executorService.submit(t4);
        executorService.submit(t5);
        executorService.shutdown();
    }

你会发现运行结果并没有什么改变。

那么它们的区别是什么呢？

a，方法参数

b，返回值不一样，submit有返回值，execute没有返回值

c，submit方便Exception的处理

execute是声明在Executor中的方法。

void execute(Runnable command);

submit是声明在ExecutorService中的方法，有三个重载。

<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);

submit传递Callable的例子：

    private void createThreadPool(){
        ExecutorService executorService = Executors.newSingleThreadExecutor();
       Future<String> future =  executorService.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(1000*10);
                return "执行完了";
            }
        });
        try {
            System.out.println(future.get());
        }catch (Exception e){

        }
        executorService.shutdown();
    }

输出：

执行完了

submit处理异常：

 private void createThreadPool(){
        ExecutorService executorService = Executors.newFixedThreadPool(6);
        List<Future<String>> futureList = new ArrayList<>();
        Future<String> future0 =  executorService.submit(new MyCallBack(0));
       Future<String> future1 =  executorService.submit(new MyCallBack(1));
       Future<String> future2 =  executorService.submit(new MyCallBack(2));
       Future<String> future3 =  executorService.submit(new MyCallBack(3));
       Future<String> future4 =  executorService.submit(new MyCallBack(4));
       Future<String> future5 =  executorService.submit(new MyCallBack(5));
      futureList.add(future0);
        futureList.add(future1);
        futureList.add(future2);
        futureList.add(future3);
        futureList.add(future4);
        futureList.add(future5);

        executorService.shutdown();

        for (Future<String> fs : futureList) {
            try {
                System.out.println(fs.get());
            }catch (Exception e){
                System.out.println(e.getMessage());
            }
        }
        }

    class MyCallBack implements Callable<String>{
        int num;

        public MyCallBack(int num){
          this.num = num;
        }

        @Override
        public String call() throws Exception {
            return String.valueOf(new  Random().nextInt()/num);
        }
    }

输出：

java.lang.ArithmeticException: / by zero
593066746
577670865
121567560
-406790238
343264803

2，shutdown,shutdownNow
a，返回值不同，shutdown没有返回值，shutdownNow有返回值

b，使用效果不一样，shutdown平稳的关闭线程池，shutdownNow立即关闭线程池，并返回没有执行的任务。

3,isShutdown

判断线程池是否关闭

十一月Siy

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java线程池的简单介绍与使用

一、介绍线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件）,则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅助线程但线程...
复制链接

扫一扫