JAVA 线程池入门事例

  线程池这个概念已经深入人心了,今天就是通过几个入门事例,学习一下线程池在JAVA中的应用。

一、大小固定的线程池——Executors.newFixedThreadPool()

  下面咱们明确两个类:

  1、ExecutorService:线程池的接口类

  2、Executors:Java里面线程池的顶级接口是Executor,但是严格意义上讲Executor并不是一个线程池,而只是一个执行线程的工具

  3、Executors.newFixedThreadPool():这是一个静态方法,也是这个事例的核心,目的是创建固定大小的线程池。每次提交一个任务就创建一个线程,直到线程达到线程池的最大值。线程池的大小一旦达到最大值就会保持不变,如果某个线程因为执行异常而结束,那么线程池会补充一个新线程。

package com.taobao.threadpool;

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

/**
 * 线程池的应用
 * @author liqiu
 *
 */
public class Test {
    public static void main(String[] args) {
        // 创建一个可重用固定线程数的线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);
        // 将线程放入池中进行执行
        for (int i=0; i<9; i++){
            pool.execute(new MyThread(i));
        }
        // 关闭线程池
        pool.shutdown();
    }
}

class MyThread extends Thread {
    int num;
    public MyThread(int i){
        this.num = i;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "正在执行。。。" + this.num);
    }
}

  执行的结果:

pool-1-thread-1正在执行。。。0
pool-1-thread-1正在执行。。。3
pool-1-thread-1正在执行。。。4
pool-1-thread-3正在执行。。。2
pool-1-thread-3正在执行。。。6
pool-1-thread-3正在执行。。。7
pool-1-thread-3正在执行。。。8
pool-1-thread-2正在执行。。。1
pool-1-thread-1正在执行。。。5

二、其他的Executores方法

  1、Executors.newSingleThreadExecutor():创建一个单线程的线程池。这个线程池只有一个线程在工作,也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束,那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。这种用法我认为违背了线程池的概念,毕竟是一个池子,竟然只有一条鱼,很没劲。事例和上一个一样,有兴趣的话自己试一试。

  2、Executors.newCachedThreadPool():创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程,那么就会回收部分空闲(60秒不执行任务)的线程,当任务数增加时,此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制,线程池大小完全依赖于操作系统(或者说JVM)能够创建的最大线程大小。说白了就是默认有若干个线程,如果请求增多了,也会继续增加线程的个数,但是会自动自动回收超出的部分线程。

  3、Executors.newScheduledThreadPool():创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

  4、Executors.newSingleThreadExecutor():创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

三、自定义线程池

  阅读了上面的内容,应该已经可以使用JAVA提供的线程池了,但是有一个特殊的情况还是需要咱们特制线程池。

package com.taobao.threadpool;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 线程池的应用
 * 
 * @author liqiu
 * 
 */
public class Test {
    public static void main(String[] args) {
        // 创建等待队列
        BlockingQueue bqueue = new ArrayBlockingQueue(20);
        // 创建一个单线程执行程序,它可安排在给定延迟后运行命令或者定期地执行。
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 3, 2, TimeUnit.MILLISECONDS, bqueue);
        // 创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口
        for (int i = 0; i <= 9; i++) {
            // 将线程放入池中进行执行
            pool.execute(new MyThread(i));
        } 
        // 关闭线程池
        pool.shutdown();
    }
}

class MyThread extends Thread {
    int num;
    public MyThread(int i){
        this.num = i;
    }
    @Override
    public void run() {
        System.out.println(this.num+" 正在被"+Thread.currentThread().getName() + "执行。。。");
        try {
            Thread.sleep(100L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

执行的结果:

0 正在被pool-1-thread-1执行。。。
1 正在被pool-1-thread-2执行。。。
2 正在被pool-1-thread-1执行。。。
3 正在被pool-1-thread-2执行。。。
4 正在被pool-1-thread-1执行。。。
5 正在被pool-1-thread-2执行。。。
6 正在被pool-1-thread-1执行。。。
7 正在被pool-1-thread-2执行。。。
8 正在被pool-1-thread-1执行。。。
9 正在被pool-1-thread-2执行。。。

下面解释一下程序:

ThreadPoolExecutor 类的方法:

  public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue)

  参数说明名如下:
  corePoolSize – 池中所保存的线程数,包括空闲线程。

  maximumPoolSize – 池中允许的最大线程数。

  keepAliveTime – 当线程数大于核心时,此为终止前多余的空闲线程等待新任务的最长时间。

  unit – keepAliveTime 参数的时间单位。

  workQueue – 执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。本例实用的是BlockingQueue,有关它的内容可以参考:http://www.cnblogs.com/liqiu/p/3630281.html

小结:

  可见用给定的初始参数和默认的线程工厂及处理程序创建新的 ThreadPoolExecutor。使用 Executors 工厂方法之一比使用此通用构造方法方便得多。

    原文作者:李秋
    原文地址: https://www.cnblogs.com/liqiu/p/3649360.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞