Java中的常见线程池

不积跬步，无以至千里；不积小流，无以成江海。要沉下心来，诗和远方的路费真的很贵！

Java中的常见线程池

类型

• newCacheThreadPool
• newFixedThreadPool
• newSingleThreadPool
• newScheduleThreadPool

区别

1. newCacheThreadPool

• 是一个拥有缓存的线程池，将每一个线程缓存起来（缓存释放时间默认为工作线程空闲一分钟），工作线程数量是无限大。

2. newFixedThreadPool

• 创建线程池的时候固定最大工作线程，当任务多的时候，工作线程达到上限，任务进入等待队列，等待某一个线程执行完。

3. newSingleThreadPool

• 保证线程池中只有一个工作线程，任务顺序执行。

4. newScheduleThreadPool

• 可以执行定时，延迟，周期性任务。

使用

1. newCacheThreadPool

可缓存的线程池。将线程缓存起来，复用线程，减少资源的消耗。当上一个任务结束后，复用当前线程去执行任务。以下十个任务，循环进行执行，所以复用线程，都是一个线程执行。

package com.hnucm;

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

public class Main {
	public static void main(String[] args) {
		//创建可缓存线程池
		ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
		for (int i = 0; i < 10; i++) {
			try {
				// sleep可明显看到使用的是线程池里面以前的线程，没有创建新的线程
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			//线程池持续任务
			cachedThreadPool.execute(new Runnable() {
				@Override
				public void run() {
					// 打印正在执行的缓存线程信息
					System.out.println(Thread.currentThread().getName() + "正在执行");			}
			});
		}
	}
}

2. newFixedThreadPool

固定工作线程的数量，多个线程并发执行任务，所以不能确定执行顺序。以下所以是三个线程同时执行。

package com.hnucm;

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

public class Main {
	public static void main(String[] args) {
		//创建固定线程池
		ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
		for (int i = 0; i < 10; i++) {
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                    	//同步执行三个任务
                    	//三个工作线程
                        //打印正在执行的缓存线程信息
                        System.out.println(Thread.currentThread().getName()+"正在被执行");
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
	}
}

3. newSingleThreadPool

单线程的线程池。只有一个工作线程，确保执行任务时，其他任务等待，确保任务顺序执行。

package com.hnucm;

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

public class Main {
	public static void main(String[] args) {
		//创建单工作线程线程池
		ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
		for (int i = 0; i < 10; i++) {
			//常量
            final int index = i;
            singleThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        //结果依次输出，相当于顺序执行各个任务
                    	//第i个任务
                        System.out.println(Thread.currentThread().getName()+"正在被执行,打印的值是:"+index);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
	}
}

4. newScheduleThreadPool

定长的线程池。用于执行延迟，定时，周期性任务。

• 延迟执行

package com.hnucm;

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

public class Main {
	public static void main(String[] args) {
		//创建一个定长线程池，支持定时及周期性任务执行——延迟执行
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //延迟1秒执行
        scheduledThreadPool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("延迟5秒执行");
            }
        }, 5, TimeUnit.SECONDS);
	}
}

• 延迟+定期（周期）执行

package com.hnucm;

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

public class Main {
	public static void main(String[] args) {
		//创建一个定长线程池，支持定时及周期性任务执行——延迟执行
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //延迟1秒执行
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("延迟1秒后每3秒执行一次");
            }
        }, 1, 3, TimeUnit.SECONDS);
	}
}