java线程池介绍及简单使用举例

最新推荐文章于 2024-04-26 21:56:37 发布

撸起柚子

最新推荐文章于 2024-04-26 21:56:37 发布

阅读量1.4w

点赞数 4

分类专栏：多线程、并发文章标签： java 多线程线程池

本文链接：https://blog.csdn.net/u014665856/article/details/71374259

版权

多线程、并发专栏收录该内容

3 篇文章 0 订阅

订阅专栏

多线程虽然能够提升程序的性能，但其实也是一把双刃剑。"为每一个任务分配一个线程"的问题在于资源管理的复杂性。当我们需要频繁的创建多个线程进行耗时操作时，每次通过new Thread来创建并不是一种好的办法。new Thread 新建和销毁对象的性能较差，线程缺乏统一的管理，而且可能出现无限制的创建线程。

每当看到这种形式的代码时：new Thread(runnable).start()

并且你希望获得一种更灵活的执行策略，请考虑使用Executor来替代Thread。(参考《Java并发编程实战》)

因此，我们可以通过使用线程池来管理线程。线程池是指管理一组同构工作线程的资源池。其原理简单解释就是会创建多个线程并进行管理，提交给线程的任务会被线程池指派给其中的线程进行执行。

java.util.concurrent提供了一种灵活的线程池实现作为Executor框架的一部分，Executor接口如下：

    public interface Executor {
         void execute(Runnable command);
    }

虽然 Executor是个简单的接口，但它缺位灵活且强大的异步任务执行框架提供了基础。

线程池都实现了ExecutorService接口，该接口定义了线程池需要实现的方法:

public interface ExecutorService extends Executor {
    void shutdown();
    List<Runnable> shutdownNow();
    boolean isShutdown();
    boolean isTerminated();
    boolean awaitTermination(long timeout, Ti
      meUnit unit)
        throws InterruptedException;
    <T> Future<T> submit(Callable<T> task);
    //.......(代码省略其他用于任务提交的便利方法)
}

ExecutorService接口的实现有，ThreadPoolExecutor和ScheduledThreadPoolExcecutor。

ThreadPoolExecutor继承自抽象类AbstractExecutorService,该抽象类实现了ExecutorService接口。ThreadPoolExecutor也是我们运用最多的线程池。

ScheduledThreadPoolExcecutor 继承了ThreadPoolExecutor 并实现了ScheduledExecutorService接口，ScheduledExecutorService接口继承自ExecutorService接口。ScheduledThreadPoolExcecutor用于周期性的执行任务，和Timer类类似。但Timer存在一些缺陷，因此应该考虑使用ScheduledThreadPoolExcecutor来代替它(Timer支持基于绝对时间而不是相对时间的调度机制，因此任务的执行对系统时钟变化很敏感，而ScheduledThreadPoolExcecutor只支持基于相对时间的调度)。

我们可以通过ThreadPoolExecutor的构造函数来实例化一个对象，但由于创建参数相对复杂，通常选择Exectors工厂类的静态方法来创建一个线程池：

newFixedThreadPool。将创建一个固定长度的线程池，每当提交一个任务时就创建一个线程池，直到达到线程池的最大数量，这时线程池的规模将不再变化。

newCachedThreadPool。将创建一个可缓存的线程池，如果线程池的当前规模超过了处理需求时，那么将回收空闲的线程，当需求增加时，则可以添加新的线程，线程池的规模不存在任何限制。

newSingleThreadPool。是一个单线程的Executor，它创建单个工作线程来执行任务，如果这个线程异常结束，会创建另一个线程来替代。newSingleThreadPool能确保依照任务在队列中的顺序来串行执行(例如FIFO、LIFO、优先级)。

newScheduledThreadPool。创建了一个固定长度的线程池，而且以延迟或定时的方式来执行任务，类似于Timer。

newFixedThreadPool和newCachedThreadPool 返回通用的ThreadPoolExecutor实例，这些实例可以直接用来构造专门用途的executor。

当默认的创建线程池策略无法满足要求时，那么可以通过ThreadPoolExecutor构造函数来实例化一个对象，根据自己的需求来实现定制，ThreadPoolExecutor最常见的构造函数形式如下：

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

参数说明：

corePoolSize:线程池中所保存的核心线程数。线程池启动后默认是空的，只有任务来临时才会创建线程以处理请求。

maximumPoolSize:线程池允许创建的最大线程数。它与corePoolSize的作用是调整“线程池中实际运行的线程的数量”。当新任务提交给线程池时，如果线程池中运行的线程数量小于corePoolSize，则创建新线程来执行任务；如果此时，线程池中运行的线程数量大于corePoolSize，但小于maximumPoolSize，则仅当阻塞队列满时才创建新线程。如果corePoolSize与maximumPoolSize相同，则创建固定大小的线程池。如果将maximumPoolSize设置为基本的无界值（如Integer.MAX_VALUE），则允许线程池适应任意数量的并发任务。

keepAliveTime：当前线程池线程总数达到核心线程数时，终止多余的空闲线程的时间。

Unit：keepAliveTime参数的时间单位，可选值有毫秒、秒、分等。

workQueue:任务队列。如果当前线程池达到核心线程数量corePoolSize后，且当前所有线程都处于活动状态时，则将新加入的任务放到此队列中。

threadFactory：线程工厂，让用户可以定制线程的创建过程，一般不需要设置。

Handler：拒绝策略，当线程池和任务队列workQueue都满了的情况下，对新加的任务采取的处理策略。

下面通过两个简单的例子来说明线程池的简单使用：

1.通过Executors.newFixedThreadPool(int)来创建一个固定数量的线程池，代码如下：

public class MyExecutorDemo {
    //执行的任务数量
    private static int MAX = 10;

    public static void main(String args[]){
        try {
            fixedThreadPool(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
    private static void fixedThreadPool (int coreSize)
            throws InterruptedException,ExecutionException {
        //创建线程池
        ExecutorService exec = Executors.newFixedThreadPool(coreSize);
        for(int i = 0; i < MAX; i++){
            //提交任务
            Future<Integer> task = exec.submit(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    System.out.println("执行线程" + Thread.currentThread().getName());
                    return fibc(20);
                }
            });
            //获取执行结果
            System.out.println("第"+i+"次计算，结果为"+task.get());
        }
    }
    //模拟耗时操作，定义一个斐波那契数列
    private static int fibc(int num){
        if (num == 0){
            return 0;
        }
        if (num == 1){
            return  1;
        }
        return fibc(num-1)+fibc(num-2);
    }

}

在上述代码中，通过fixedThreadPool启动了含有4个线程的线程池，我们看一下该方法的构造函数，

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

第一个和第二个参数时相同的值，则创建固定大小的线程池，最后的参数为无界队列，因此该线程池可容纳无限个任务。创建成功后，向线程池中通过submit提交了10个Callable任务，每个任务计算前20个的斐波那契数列。通过结果可以看出，线程池中有4个线程交替的执行任务，执行运算结果如下：

执行线程pool-1-thread-1
第0次计算，结果为6765
执行线程pool-1-thread-2
第1次计算，结果为6765
执行线程pool-1-thread-3
第2次计算，结果为6765
执行线程pool-1-thread-4
第3次计算，结果为6765
执行线程pool-1-thread-1
第4次计算，结果为6765
执行线程pool-1-thread-2
第5次计算，结果为6765
执行线程pool-1-thread-3
第6次计算，结果为6765
执行线程pool-1-thread-4
第7次计算，结果为6765
执行线程pool-1-thread-1
第8次计算，结果为6765
执行线程pool-1-thread-2
第9次计算，结果为6765

newCachedThreadPool

2.通过Executors.newCacheThreadPool()创建带缓存的线程池

有时，我们需要任务尽可能快的被执行，这需要线程池中的线程足够多，也就是说需要用空间来换时间，创建的线程越多，占用的内存消耗也越大。但由于其并发量也越大，因此执行的速度也越快。考虑这样一种场景，在新提交了一个任务后，由于当前没有空闲线程可执行，因此需要马上创建一个线程来执行该任务。这种场景可通过该方法来实现。代码如下：

private static void newCachedThreadPool () throws ExecutionException,
            InterruptedException{

        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < MAX; i++){
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("执行线程为："+Thread.currentThread().getName()+
                            "，结果为："+fibc(30));
                }
            });
        }
    }

代码中，通过 newFixedThreadPool创建了一个线程池，并每次提交一个任务，来计算前30个的斐波那契数列，运行结果如下：

执行线程为：pool-1-thread-2，结果为：832040
执行线程为：pool-1-thread-1，结果为：832040
执行线程为：pool-1-thread-3，结果为：832040
执行线程为：pool-1-thread-4，结果为：832040
执行线程为：pool-1-thread-1，结果为：832040
执行线程为：pool-1-thread-5，结果为：832040
执行线程为：pool-1-thread-2，结果为：832040
执行线程为：pool-1-thread-6，结果为：832040
执行线程为：pool-1-thread-1，结果为：832040
执行线程为：pool-1-thread-5，结果为：832040

为了保证执行效率，每次提交任务，线程池都会创建一个新线程来执行任务，但前提是此时没有空闲线程才创建新线程，但有空闲线程时，则会使用空闲的线程来执行任务，如结果中所示，执行前4个任务时，线程池为每个任务都创建了一个线程，当执行到第5个任务时，此时第一个线程已经执行完任务，并处于空闲状态，那么第5个任务就被执行在第1个线程中了。

(参考书籍《Java并发编程实战》、《Android开发进阶从小工到专家》)