JAVA五种线程池的使用
Posted 木极子
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JAVA五种线程池的使用相关的知识，希望对你有一定的参考价值。
一、概要
线程池的主要作用就是减少系统创建大量，特别是大量生命周期比较短的线程二产生的开销，进而提高系统的性能。
在JDK1.5之前，需要手动创建线程池，在JDK1.5之后包含JDK1.5,JAVA内建支持线程池，而我们讨论的就是这五种内建线程池。
在说明之前先认识一个工厂类：Executors，要说明的这五种线程池全部都有其创建，这个类有一个静态方法：defaultThreadFactory() 可以创建ThreadFactory对象，进而由这个对象创建线程。这也是线程池中创建线程的基础。
演示如下：
package com.zxm.thread.factory;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import com.zxm.thread.threadbean.TestThread;
public class BaiseThreadFactore
private ThreadFactory threadFactory;
public BaiseThreadFactore()
threadFactory = Executors.defaultThreadFactory();
public Thread createThread(Runnable thread)
Thread newThread = threadFactory.newThread(thread);
return newThread;
public void test()
Thread thread1 = createThread(new TestThread());
Thread thread2 = createThread(new TestThread());
thread1.start();
thread2.start();
public static void main(String[] args)
BaiseThreadFactore baiseThreadFactore = new BaiseThreadFactore();
baiseThreadFactore.test();
二、五种线程池的分类和作用
1、newCachedThreadPool
作用：创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们，并在需要时使用提供的 ThreadFactory 创建新线程。
特征：
（1）线程池中数量没有固定，可达到最大值（Interger. MAX_VALUE）
（2）线程池中的线程可进行缓存重复利用和回收（回收默认时间为1分钟）
（3）当线程池中，没有可用线程，会重新创建一个线程
创建方式： Executors.newCachedThreadPool();
示例：
TestThread.java
package com.zxm.thread.threadbean;
public class TestThread implements Runnable
@Override
public void run()
for(int i=0;i<10;i++)
System.out.println(Thread.currentThread().getName()+":"+i);
try
Thread.sleep(500);
catch (InterruptedException e)
e.printStackTrace();
测试代码：
NewCachedThreadPoolTest.java
package com.zxm.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import com.zxm.thread.threadbean.TestThread;
public class NewCachedThreadPoolTest
public void test() throws InterruptedException
ExecutorService pool = Executors.newCachedThreadPool();
pool.submit(new TestThread());
//下面的语句开启就是为了让第一个提交的线程执行完
//Thread.sleep(6000);
pool.submit(new TestThread());
pool.shutdown();
public static void main(String[] args) throws InterruptedException
NewCachedThreadPoolTest newCachedThreadPoolTest = new NewCachedThreadPoolTest();
newCachedThreadPoolTest.test();
测试结果
未去掉注释（//Thread.sleep(6000);）
去掉注释（Thread.sleep(6000);）
2、newFixedThreadPool
作用：创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。
特征：
（1）线程池中的线程处于一定的量，可以很好的控制线程的并发量
（2）线程可以重复被使用，在显示关闭之前，都将一直存在
（3）超出一定量的线程被提交时候需在队列中等待
创建方式：
（1）Executors.newFixedThreadPool(int nThreads)；//nThreads为线程的数量
（2）Executors.newFixedThreadPool(int nThreads，ThreadFactory threadFactory)；//nThreads为线程的数量，threadFactory创建线程的工厂方式
示例：
TestThread.java
package com.zxm.thread.threadbean;
public class TestThread implements Runnable
@Override
public void run()
for(int i=0;i<10;i++)
System.out.println(Thread.currentThread().getName()+":"+i);
try
Thread.sleep(500);
catch (InterruptedException e)
e.printStackTrace();
测试代码：
package com.zxm.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import com.zxm.thread.threadbean.TestThread;
public class NewFixedThreadPoolTest
public void test()
ExecutorService pool =Executors.newFixedThreadPool(2);//创建只含两条线程的线程池
pool.submit(new TestThread());//执行1线程
pool.submit(new TestThread());//执行2线程
pool.submit(new TestThread());//先等待，等1或者2线程空闲执行1或者2线程
pool.shutdown();
public static void main(String[] args)
NewFixedThreadPoolTest newFixedThreadPoolTest = new NewFixedThreadPoolTest();
newFixedThreadPoolTest.test();
执行结果：
3、newSingleThreadExecutor
作用：创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。（注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，那么如果需要，一个新线程将代替它执行后续的任务）。可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。与其他等效的 newFixedThreadPool(1) 不同，可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。
特征：
（1）线程池中最多执行1个线程，之后提交的线程活动将会排在队列中以此执行
创建方式：
（1）Executors.newSingleThreadExecutor() ；
（2）Executors.newSingleThreadExecutor(ThreadFactory threadFactory)；// threadFactory创建线程的工厂方式
示例：
TestThread.java
package com.zxm.thread.threadbean;
public class TestThread implements Runnable
@Override
public void run()
for(int i=0;i<10;i++)
System.out.println(Thread.currentThread().getName()+":"+i);
try
Thread.sleep(500);
catch (InterruptedException e)
e.printStackTrace();
测试代码：
package com.zxm.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import com.zxm.thread.threadbean.TestThread;
public class NewSingleThreadExecutorTest
public void test()
ExecutorService pool =Executors.newSingleThreadExecutor();
pool.submit(new TestThread());
pool.submit(new TestThread());
pool.shutdown();
public static void main(String[] args)
NewSingleThreadExecutorTest newSingleThreadExecutorTest = new NewSingleThreadExecutorTest();
newSingleThreadExecutorTest.test();
测试结果：
这里针对上面的这三个连接池有一个共同特性，就是在创建这三个连接池的时候会返回一个对象ExecutorService，它代表的是一个线程池，而且是一个尽快执行的线程池，它可以执行Runable和Callable对象所代表的线程。该对象提供的方法有一下几种：
4、newScheduleThreadPool
作用： 创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
特征：
（1）线程池中具有指定数量的线程，即便是空线程也将保留
（2）可定时或者延迟执行线程活动
创建方式：
（1）Executors.newScheduledThreadPool(int corePoolSize)；// corePoolSize线程的个数
（2）newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)；// corePoolSize线程的个数，threadFactory创建线程的工厂
示例：
TestThread2.java
package com.zxm.thread.threadbean;
public class TestThread2 implements Runnable
@Override
public void run()
System.out.println(Thread.currentThread().getName()+":hello");
测试代码：
package com.zxm.thread;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import com.zxm.thread.threadbean.TestThread2;
public class NewScheduleThreadPoolTest
public static void test()
ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
//pool.scheduleAtFixedRate(new TestThread2(), 3, 2, TimeUnit.SECONDS);//首次在3秒后执行，接着每2秒执行一次,不可加pool.shutdown();
//pool.scheduleWithFixedDelay(new TestThread2(), 3, 2, TimeUnit.SECONDS);//首次在3秒后执行，接着在第一次结束后3秒后执行一直，注意是前一次执行完后，不可加pool.shutdown();
pool.schedule(new TestThread2(), 3, TimeUnit.SECONDS);//在3秒后执行
pool.shutdown();
public static void main(String[] args)
NewScheduleThreadPoolTest.test();
5、newSingleThreadScheduledExecutor
作用： 创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。
特征：
（1）线程池中最多执行1个线程，之后提交的线程活动将会排在队列中以此执行
（2）可定时或者延迟执行线程活动
创建方式：
（1）Executors.newSingleThreadScheduledExecutor() ；
（2）Executors.newSingleThreadScheduledExecutor(ThreadFactory threadFactory) ；//threadFactory创建线程的工厂
示例：
TestThread2.java
package com.zxm.thread.threadbean;
public class TestThread2 implements Runnable
@Override
public void run()
System.out.println(Thread.currentThread().getName()+":hello");
测试代码：
package com.zxm.thread;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import com.zxm.thread.threadbean.TestThread2;
public class NewSingleThreadScheduledExecutorTest
public static void test()
ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();
//pool.scheduleAtFixedRate(new TestThread2(), 3, 2, TimeUnit.SECONDS);//首次在3秒后执行，接着每2秒执行一次,不可加pool.shutdown();
//pool.scheduleWithFixedDelay(new TestThread2(), 3, 2, TimeUnit.SECONDS);//首次在3秒后执行，接着在第一次结束后3秒后执行一直，注意是前一次执行完后，不可加pool.shutdown();
pool.schedule(new TestThread2(), 3, TimeUnit.SECONDS);//在3秒后执行
pool.shutdown();
public static void main(String[] args)
NewSingleThreadScheduledExecutorTest.test();
这里针对上面的这两个连接池有一个共同特性，就是在创建这三个连接池的时候会返回一个对象ScheduledExecutorService它继承了ExecutorService，它代表的是一个线程池，而且是一个可以延迟或者定时执行的的线程池，它可以执行Runable和Callable对象所代表的线程。该对象提供的方法除了从ExecutorService过来之外，还有以下几种：
以上是关于JAVA五种线程池的使用的主要内容，如果未能解决你的问题，请参考以下文章