深入浅出Java线程池

于 2019-02-16 18:26:24 发布
阅读量927 收藏
点赞数 2
分类专栏： 多线程 文章标签： 多线程 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tobearc/article/details/87456274
版权

使用线程池的好处：1、线程可以复用，减少创建、销毁线程的资源开销；2、避免创建线程，提高效率；3、便于对线程统一管理、监控等。大神Doug Lea为我们提供了多种构建线程池的方法：

1、直接构造ThreadPoolExecutor对象

源码分析：

    //构造方法1：使用默认的线程工厂，默认的拒绝策略（中止策略，直接抛RejectedExecutionException）
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }


    //构造方法2：可以自定义线程工厂
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }


    //构造方法3：可以自定义拒绝策略
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }


    //构造方法4：可以自定义线程工厂和拒绝策略
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

使用示例：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 直接构造线程池，new ThreadPoolExecutor
 * 使用灵活，方便扩展
 */
public class ThreadPoolExecutorTest {
	
	private static final int CORE_POOL_SIZE=10;
	private static final int MAXIMUM_POOL_SIZE=15;
	private static final int KEEP_ALIVE_TIME=0;
	
	//使用有界队列（Integer.MAX_VALUE）和Executors.newFixedThreadPool类似
	private ExecutorService threadPoolExecutor=new ThreadPoolExecutor(
			CORE_POOL_SIZE, //核心工作线程数
			MAXIMUM_POOL_SIZE, //线程池最大线程数
			KEEP_ALIVE_TIME, //空闲线程等待任务的时间
			TimeUnit.MILLISECONDS, 
			new LinkedBlockingQueue<Runnable>()//有界队列（Integer.MAX_VALUE），可以改为必须指定长度的有界队列ArrayBlockingQueue
			//ThreadFactory 可以指定线程构造工厂
			//RejectedExecutionHandler 可以指定队列满后的拒绝策略，理论来说如果队列太长，则此策略不易被触发
			);
	
	//指定队列长度，要注意拒绝策略
	private ExecutorService threadPoolExecutor2=new ThreadPoolExecutor(
			CORE_POOL_SIZE, //核心工作线程数
			MAXIMUM_POOL_SIZE, //线程池最大线程数
			KEEP_ALIVE_TIME, //空闲线程等待任务的时间
			TimeUnit.MILLISECONDS, 
			new ArrayBlockingQueue<Runnable>(5),//10个工作，5个扩展，5个排队，理论上最多并发15个，排队5个，超过数量会触发拒绝策略
			//ThreadFactory 可以指定线程构造工厂
			
			new ThreadPoolExecutor.AbortPolicy() //中止执行策略，抛异常
			//其他几种拒绝策略是：
			//ThreadPoolExecutor.CallerRunsPolicy//立即执行
			//ThreadPoolExecutor.DiscardPolicy//丢弃当前，不做处理
			//ThreadPoolExecutor.DiscardOldestPolicy//丢弃最早的,立即执行当前线程
			//可见几种策略都不太好用
			);
	
	public ThreadPoolExecutorTest() {
	}
	
	private void test() {
		for(int i=0;i<100;i++) {
			final int num=i;
			threadPoolExecutor.submit(new Runnable() {
				public void run() {
					System.out.println("num:"+num);
					try {
						TimeUnit.SECONDS.sleep(1);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
		}
		threadPoolExecutor.shutdown();
	}
	
	private void test2() {
		for(int i=0;i<100;i++) {
			final int num=i;
			threadPoolExecutor2.submit(new Runnable() {
				public void run() {
					System.out.println("num:"+num);
					try {
						TimeUnit.SECONDS.sleep(1);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
		}
		threadPoolExecutor2.shutdown();
	}

	public static void main(String[] args) {
		ThreadPoolExecutorTest threadPoolExecutorTest=new ThreadPoolExecutorTest();
		//threadPoolExecutorTest.test();
		threadPoolExecutorTest.test2();
	}
}

2、通过Executors工具类创建

2.1、Executors.newFixedThreadPool构造一个固定工作线程数量，有个有界队列（Integer.MAX_VALUE）可以支持排队的线程池

源码分析：

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

可见，最终构造的还是ThreadPoolExecutor对象，其中corePoolSize=maximumPoolSize，空闲线程不会等待，有个有界队列（Integer.MAX_VALUE）负责缓存排队（注意没有指定长度）

使用示例：

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

/**
 * 固定数量的工作线程，有有界队列（Integer.MAX_VALUE）支持排队进入
 */
public class FixedThreadPoolTest {

	private ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);//固定线程池数量

	/**
	 * 
	 */
	public FixedThreadPoolTest() {
	}

	private void test() {
		for (int i = 0; i < 100; i++) {
			final int num = i;
			fixedThreadPool.submit(new Runnable() {
				public void run() {
					System.out.println("NO:" + num + ",Name:" + Thread.currentThread().getName());
					try {
						TimeUnit.SECONDS.sleep(1);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
		}

		fixedThreadPool.shutdown();
	}

	public static void main(String[] args) {
		FixedThreadPoolTest fixedThreadPoolTest = new FixedThreadPoolTest();
		fixedThreadPoolTest.test();
	}
}

2.2、Executors.newSingleThreadExecutor构造一个只有一个工作线程的线程池，其和newFixedThreadPool一样，也有个有界队列（Integer.MAX_VALUE）支持任务排队

源码分析：

    //corePoolSize=maximumPoolSize=1，外加一个有界队列（Integer.MAX_VALUE）支持排队
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

使用示例：

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

/**
 * 固定线程大小为1，有个有界队列（Integer.MAX_VALUE）可以方便排队
 */
public class SingleThreadExecutorTest {

	private ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

	public SingleThreadExecutorTest() {
	}

	private void test() {
		for (int i = 0; i < 100; i++) {
			final int num = i;
			singleThreadExecutor.submit(new Runnable() {
				public void run() {
					System.out.println("num:" + num);
				}
			});
		}
		singleThreadExecutor.shutdown();
	}

	public static void main(String[] args) {
		SingleThreadExecutorTest singleThreadExecutorTest = new SingleThreadExecutorTest();
		singleThreadExecutorTest.test();
	}

}

2.3、Executors.newCachedThreadPool创建一个根据需要创建新线程的线程池，但在可用时将重新使用以前构造的线程。 这些池通常会提高执行许多短暂异步任务的程序的性能。 调用execute将重用以前构造的线程（如果可用）。 如果没有可用的线程，将创建一个新的线程并将其添加到该池中。 未使用六十秒的线程将被终止并从缓存中删除。 因此，长时间保持闲置的池将不会消耗任何资源。

源码分析：

    //注意：其和newFixedThreadPool/newSingleThreadExecutor是不一样的，
    //其空闲线程的超时时间是60秒，且使用了SynchronousQueue一个不存储元素的阻塞队列，
    //每一个put操作必须等待一个take操作，否则不能继续添加元素
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

使用示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 创建一个根据需要创建新线程的线程池，但在可用时将重新使用以前构造的线程。 这些池通常会提高执行许多短暂异步任务的程序的性能。
 * 调用execute将重用以前构造的线程（如果可用）。 如果没有可用的线程，将创建一个新的线程并将其添加到该池中。
 * 未使用六十秒的线程将被终止并从缓存中删除。 因此，长时间保持闲置的池将不会消耗任何资源。
 */
public class CachedThreadPoolTest {

	private ExecutorService cachedThreadPool = Executors.newCachedThreadPool();//可以看做是没有排队队列，有线程就执行了
	
	//自定义，看是否会阻塞
	private ExecutorService cachedThreadPool2= new ThreadPoolExecutor(
			5, 
			10,
            60L, 
            TimeUnit.SECONDS,
            new SynchronousQueue<Runnable>());//本构造限定了大小，而这里又类似没有队列，会导致线程池满后抛异常

	public CachedThreadPoolTest() {
	}
	
	private void test() {
		for (int i = 0; i < 100; i++) {
			final int num = i;
			cachedThreadPool.submit(new Runnable() {
				public void run() {
					System.out.println("num:" + num);
				}
			});
		}
		cachedThreadPool.shutdown();
	}
	
	private void test2() {
		for (int i = 0; i < 100; i++) {
			final int num = i;
			cachedThreadPool2.submit(new Runnable() {
				public void run() {
					System.out.println("num:" + num);
					try {
						TimeUnit.SECONDS.sleep(1);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
		}
		System.out.println("循环完了");
		cachedThreadPool2.shutdown();
	}

	public static void main(String[] args) {
		CachedThreadPoolTest cachedThreadPoolTest=new CachedThreadPoolTest();
		//cachedThreadPoolTest.test();
		cachedThreadPoolTest.test2();
	}
}

2.4、Executors.newScheduledThreadPool创建一个线程池，可以调度命令在给定的延迟之后运行，或定期执行。

源码分析：

    //注意这里构造的是：ScheduledThreadPoolExecutor
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

使用示例：

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 可以延时执行，或定时执行，用到了：DelayedWorkQueue
 */
public class ScheduledThreadPoolTest {

	private ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(10);
	private SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	
	public ScheduledThreadPoolTest() {
	}
	
	private String getCurrentTime() {
		return simpleDateFormat.format(Calendar.getInstance().getTime());
	}

	private void test() {
		// 就像其他线程池一样直接执行任务
		/*
		scheduledThreadPool.submit(new Runnable() {
			public void run() {
				System.out.println("直接执行");
			}
		});
		*/
		
		// 延时执行后，再按固定间隔执行
		/*
		scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
			public void run() {
				System.out.println(getCurrentTime()+" scheduleWithFixedDelay");
			}
		}, 1, 2, TimeUnit.SECONDS);
		*/

		// 延时执行后，再定时执行
		scheduledThreadPool.scheduleWithFixedDelay(new Runnable() {
			public void run() {
				System.out.println(getCurrentTime()+" scheduleWithFixedDelay");
			}
		}, 1, 2, TimeUnit.SECONDS);
	}

	public static void main(String[] args) {
		ScheduledThreadPoolTest scheduledThreadPoolTest=new ScheduledThreadPoolTest();
		scheduledThreadPoolTest.test();
	}
}

 

 

 

tobearc
关注
专栏目录
Java基础知识总结：深入浅出Java线程池
旧时光 | YoungChen's 博客
01-31 361
ThreadPoolExecutor Java 中线程池的核心类为 ThreadPoolExecutor，它有五个具体的参数： 如果以下的文字解释你看的实在头疼，推荐你看看这种 图解线程池的文章 corePoolSize：核心线程数，最初为 0，接收一个任务创建一个直到数目增长至 corePoolSize 为止，类似于 lazyinit 的形式，之后核心线程也不会被回收，而是一直以这个数目稳定...
深入浅出 Java 多线程.pdf
09-15
在本文中，我们将深入浅出Java多线程编程的世界，探索多线程编程的基本概念、多线程编程的优点、多线程编程的缺点、多线程编程的应用场景、多线程编程的实现方法等内容。 一、多线程编程的基本概念 多线程编程是指...
黑马程序员_张孝祥_Java多线程与并发库 视频+代码+资料
10-29
黑马程序员_张孝祥_Java多线程与并发库，视频+代码+资料
深入浅出Java线程池ThreadPoolExecutor
jonnyhsu_0913的博客
03-08 477
本文基于JDK1.7的源码进行分析并解读。ThreadPoolExecutor是JUC提供的一类线程池工具，也是Java语言中应用场景最多的并发框架，可以说，几乎所有需要异步或者并发执行的，都可以使用Java线程池。那么首先，我们一起来比较一下“单纯使用线程的方案”和“使用ThreadPoolExecutor线程池的方案”，在解决问题上有什么区别吧。案例：抄写员在中世纪，有一种叫做抄写员（Scri...
线程池的使用
人生不设限，高飞吧~
12-03 4728
在Java5之后，并发线程这块发生了根本的变化，最重要的莫过于新的启动、调度、管理线程的一大堆API了。在Java5以后，通过Executor来启动线程比用Thread的start（）更好。在新特征中，可以很容易控制线程的启动、执行和关闭过程，还可以很容易使用线程池的特性。 　　一、创建任务 　　任务就是一个实现了Runnable接口的类。 　　创建的时候实run方法即可。
java中的线程池
diandiekang7035的博客
06-25 222
为什么要使用线程池在Java中，如果每当一个请求到达就创建一个新线程，开销是相当大的。在实际使用中，每个请求创建新线程的服务器在创建和销毁线程上花费的时间和消耗的系统资源，甚至可能要比花在处理实际的用户请求的时间和资源要多得多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个JVM里创建太多的线程，可能会导致系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了...
深入浅出之java线程池
huangyh技术栈
08-07 279
创建线程的方式：     1.继承Thread类     class XxxThread extends Thread{         public void run(){         }     }     new XxxThread().start();     2.实现Runnable接口：      class XxxRunnable implements Runnable{ ...
深入浅出java设计模式（高清中文PDF）
01-03
《深入浅出Java设计模式》是一本专注于Java编程领域中的设计模式专著，旨在帮助开发者深化对设计模式的理解，提高代码质量和可维护性。设计模式是软件开发中经过时间检验的解决方案，它们是解决常见问题的最佳实践。...
深入浅出 Java 多线程.pdf_java_
10-03
Java多线程是Java编程中的核心概念，尤其在如今并发性能至关重要的软件开发中，它的重要性不言而喻。...深入学习这一部分将极大地提升Java程序员的设计能力和解决问题的能力，使得能够编写出更加健壮、高效的并发程序。
深入浅出 Java 虚拟机
11-18
《深入浅出 Java 虚拟机》是一本旨在帮助开发者深入理解Java虚拟机（Java Virtual Machine, JVM）的著作。JVM是Java语言的核心组成部分，它负责将编译后的字节码转换为机器可执行的指令，是Java平台的重要特性之一。...
深入浅出Java：英文原版阅读指南
《Head First Java》这本书深入浅出地介绍了Java语言的核心概念，包括但不限于： 1. **基础语法**：讲解了变量、数据类型、运算符、流程控制语句（如if-else，switch，循环）等基础知识，使读者能够编写简单的Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值