四种常见线程池介绍及使用举例

线程池

• 线程池：Executor管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。这里的异步是指多个任务的执行互不干扰，不需要进行同步操作。

主要有四种线程池：

1. 缓存池

• newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

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

public class NewCachedThreadPoolExample {
    public static void main(String[] args) {
        //创建可缓存线程池：如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            cachedThreadPool.execute(new MyRunnable());
        }
        cachedThreadPool.shutdown();
    }
}

class MyRunnable implements Runnable {
    public void run() {
        //获取当前线程名字
        String name = Thread.currentThread().getName();
        System.out.println(name);
        try {
            Thread.sleep(2000);
        } catch (InterruptedException ie) {
            ie.printStackTrace();
        }
    }
}

运行结果：创建10个新线程

2. 定长池

• newFixedThreadPool可以创建一个定长的线程池。定长线程池最多只能同时执行一定个数的线程，这个容量在new的时候设定。

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

public class NewFixedThreadPoolExample {
        public static void main(String[] args) {
            //newFixedThreadPool可以创建一个定长的线程池。
            // 定长线程池最多只能同时执行一定个数的线程，这个容量在new的时候设定。
            ExecutorService cachedThreadPool = Executors.newFixedThreadPool(3);
            for (int i = 0; i < 10; i++) {
                cachedThreadPool.execute(new MyRunnable2());
            }
            cachedThreadPool.shutdown();
        }
    }

    class MyRunnable2 implements Runnable {
        public void run() {
            //获取当前线程名字
            String name = Thread.currentThread().getName();
            System.out.println(name);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException ie) {
                ie.printStackTrace();
            }
        }
    }

结果如图：只创建三个线程

3. 定时池

• newScheduledThreadPool创建一个定时线程池，支持延迟执行和周期性任务执行。后一种执行方式类似于单片机的定时器中断。

3.1 延迟执行

import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/*
newScheduledThreadPool创建一个定长线程池，支持延迟执行和周期性任务执行。
1、延迟执行
 */
public class NewScheduledThreadPoolExample {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        System.out.println(new Date().toString());
        scheduledThreadPool.schedule(new MyRunnable3(), 3, TimeUnit.SECONDS);
    }
}
class MyRunnable3 implements Runnable {
    public void run() {
        System.out.println(new Date().toString());
    }
}

如下图：延迟3秒执行线程

3.2 周期执行

• scheduleAtFixedRate(x,x,x,x)的第二个参数的意义是初始化延迟，第三个参数的意义是定时间隔延迟。

import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class NewScheduledThreadPoolExample2 {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        System.out.println(new Date().toString());
        scheduledThreadPool.scheduleAtFixedRate(new MyRunnable4(), 1, 3, TimeUnit.SECONDS);
        try {
            Thread.sleep(15 * 1000);
        } catch (InterruptedException ie) {
            ie.printStackTrace();
        }
        scheduledThreadPool.shutdown();
    }
}
class MyRunnable4 implements Runnable {
    public void run() {
        System.out.println(new Date().toString());
    }
}

运行的结果
结果中第一二行的原因就是初始化延迟参数形成的

4. 单线程线程池

• newSingleThreadExecutor创建一个单线程化的线程池，这个线程池当前池中的线程死后(或发生异常时)，才能重新启动新的一个线程来替代原来的线程继续执行下去。也就是说按照单线程的模式，会按照线程添加的顺序，一个一个的执行这些线程的工作。

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

public class NewSingleThreadPool1 {
    public static void main(String[] args) {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new MyRunnable5(index));
        }
    }
}
class MyRunnable5 implements Runnable {
    int i = 0;
    public MyRunnable5(int i) {
        this.i = i;
    }
    public void run() {
        try {
            System.out.print(i+" ");
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果

按照顺序，一个一个一次执行。