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

2019-11-06 08:17:49

字体：大中小

来源：转载

供稿：网友

一、介绍

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

二、作用

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

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

三、类的层级结构

1，Executor 结构定义了一个方法来执行执行任务。2，ExecutorService定义了完成的线程池的行为，可以接受提交任务、执行任务、关闭服务。3，AbstractExecutorService实现了ExecutorService接口，也实现了接口定义的默认行为。4，ThreadPool|Executor实现了ExecutorService接口的全部默认行为。四、几个常用的线程池

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。1，newSingleThreadExecutor创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。2，newFixedThreadPool创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。3，newCachedThreadPool创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（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-44，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 zero593066746577670865121567560-4067902383432648032，shutdown,shutdownNowa，返回值不同，shutdown没有返回值，shutdownNow有返回值b，使用效果不一样，shutdown平稳的关闭线程池，shutdownNow立即关闭线程池，并返回没有执行的任务。
3,isShutdown
判断线程池是否关闭