Java学习——并发编程之线程池原理分析

最新推荐文章于 2023-06-03 19:47:32 发布
最新推荐文章于 2023-06-03 19:47:32 发布
阅读量203 收藏 1
点赞数
分类专栏： JAVA 多线程 基础 文章标签： 多线程 io Java 线程池 阻塞队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22774179/article/details/91829639
版权
JAVA 同时被 3 个专栏收录
7 篇文章 0 订阅
订阅专栏
基础
7 篇文章 0 订阅
订阅专栏
多线程
5 篇文章 0 订阅
订阅专栏

四、线程池原理分析

1.阻塞队列与非阻塞队列

1.1阻塞队列与非阻塞队列的区别：

（1）从空的阻塞队列中读取元素，将会阻塞，知道其他线程插入元素到这个队列中。

（2）往满的队列中添加元素，同样也会阻塞，知道有线程从队列中取出元素或者队列中的元素被清除。

1.2下面列举几个常见的队列：

（1）ArrayDeque, （数组双端队列） 
（2）PriorityQueue, （优先级队列） 
（3）ConcurrentLinkedQueue, （基于链表的并发队列） 
（4）DelayQueue, （延期阻塞队列）（阻塞队列实现了BlockingQueue接口） 
（5）ArrayBlockingQueue, （基于数组的并发阻塞队列） 
（6）LinkedBlockingQueue, （基于链表的FIFO阻塞队列） 
（7）LinkedBlockingDeque, （基于链表的FIFO双端阻塞队列） 
（8）PriorityBlockingQueue, （带优先级的无界阻塞队列） 
（9）SynchronousQueue （并发同步阻塞队列）

1.3ConcurrentLinkedQueue

ConcurrentLinkedQueue ：是一个基于高并发场景下的队列，通过无锁的方式实现了高并发下的高性能。他是一个聚集链接节点的无界安全队列。不允许有null元素。

ConcurrentLinkedQueue重要方法:
add 和offer() 都是加入元素的方法(在ConcurrentLinkedQueue中这俩个方法没有任何区别)
poll() 和peek() 都是取头元素节点，区别在于前者会删除元素，后者不会。

/**	
 * 
 * @author johson
 *阻塞队列和非阻塞队列
 *阻塞队列的最大好处就是能防止队列容器溢出，防止数据丢失
 */
public class test01 {
	
	public static void main(String[] args){
	
	//新建一个非阻塞式队列，无界的
	ConcurrentLinkedQueue<String> concurrentLinkedQueue = new ConcurrentLinkedQueue<>();
	
	concurrentLinkedQueue.add("张三"); //add()调用了offer方法
	
	//concurrentLinkedQueue.offer("王麻子");
	
	concurrentLinkedQueue.add("李四");
	
	concurrentLinkedQueue.add("王五");
	
	System.out.println("peek()方法showtime");
	//peek()是获取但不删除
	System.out.println(concurrentLinkedQueue.peek());
	System.out.println(concurrentLinkedQueue.peek());
	System.out.println(concurrentLinkedQueue.peek());
	
	System.out.println("pool()方法showtime");
	//一次性只能获取一个值，poll()是获取一个删除一个
	System.out.println(concurrentLinkedQueue.poll());
	System.out.println(concurrentLinkedQueue.poll());
	System.out.println(concurrentLinkedQueue.poll());
	

	
	System.out.println(concurrentLinkedQueue.size());
	
	}
}

peek()方法与poll()方法运行对比：

1.4BlockingQueue

阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是：

（1）在队列为空时，获取元素的线程会等待队列变为非空。

（2）当队列满时，存储元素的线程会等待队列可用。

阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。

阻塞队列的简单实验：

/**	
 * 
 * @author johson
 * 有界队列，阻塞队列
 */
public class test02 {
	//阻塞式队列:存队列的时候，如果满了。就会等待；取队列的时候，如果没有值或者取不到值也会等待
	public static void main(String[] args) throws InterruptedException{
	
		//新建一个大小为3的阻塞队列
		BlockingQueue<String> blockingDeque = new ArrayBlockingQueue<String>(3);
		//添加非阻塞队列
		blockingDeque.offer("张三");
		//添加阻塞式队列，如果队列已经满了，就会等待3秒，如果还是满的就会结束插入操作
		blockingDeque.offer("李四",3,TimeUnit.SECONDS);
		
		System.out.println(blockingDeque.poll());
		System.out.println(blockingDeque.poll(3,TimeUnit.SECONDS));
		//获取阻塞式队列，过了三秒没有获取到就不再等待
		System.out.println(blockingDeque.poll(3,TimeUnit.SECONDS));
	
	}
}

利用BlockingQueue实现生产者与消费者实验：

/**
 * 生产者线程
 * @author johson
 *
 */
class ProduceThread implements Runnable{
	
	private BlockingQueue<String> blockingQueue;
	
	private volatile boolean flag = true;
	//计数器，原子类
	AtomicInteger atomicInteger = new AtomicInteger();
	
	public ProduceThread(BlockingQueue<String> blockingQueue) {
		this.blockingQueue = blockingQueue;
	}
	
	@Override
	public void run() {
		System.out.println("生产者线程启动");
		try {
			while(flag){
				//基于线程安全的一个自增方法
				String data = atomicInteger.incrementAndGet()+"";
				boolean offer = blockingQueue.offer(data,2,TimeUnit.SECONDS);
				if(offer){
					System.out.println("生产者入列成功，data=" + data);
				}
				else {
					System.out.println("生产者入列失败，data=" + data);
				}
				
				Thread.sleep(1000);
			}			
		} catch (InterruptedException e) {
				e.printStackTrace();
		}
	}
	//停止方法
	public void stop(){
		this.flag  =false;
	}
}

/**
 * 消费者线程
 * @author johson
 *
 */
class ConsumerThread implements Runnable{
	
	private BlockingQueue<String> blockingQueue;
	
	private volatile boolean flag = true;
	
	public ConsumerThread(BlockingQueue<String> blockingQueue) {
		this.blockingQueue = blockingQueue;
	}
	@Override
	public void run() {
		try {
			while (flag) {
				String data = blockingQueue.poll(2, TimeUnit.SECONDS);	
				if(data == null){
					System.out.println("消费者超过2秒时间没有获取到信息");
					flag = true;
					return ;
				}
				System.out.println("消费者获取到data="+data);
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			System.out.println("消费者已经停止");
		}
	}

}

public class test03 {

	public static void main(String[] args) {
		BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<String>(10);
		ProduceThread produceThread = new ProduceThread(blockingQueue);
		
		ConsumerThread consumerThread = new ConsumerThread(blockingQueue);
		
		Thread t1 = new Thread(produceThread);
		
		Thread t2 = new Thread(consumerThread);
		
		t1.start();
		
		t2.start();
		
		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		produceThread.stop();
		
	}

}

实验结果：

2.线程池

2.1线程池的作用

线程池是为了突然大量爆发的线程而设计的，通过有限的几个固定线程为大量的操所服务，减少了线程创建和销毁的时间，从而提高效率。

2.2线程池能够带来3个好处


第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。复用原来的线程（但是run()方法体不一样了）
第三：提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。但是，要做到合理利用。

2.3线程池四种创建方式

Java通过Executors（jdk1.5并发包）提供四种线程池，分别为：

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

/**
 * newCachedThreadPool创建一个可缓存线程池
 * @author johson
 *
 */
public class test04 {

	public static void main(String[] args) {
		
		//创建了一个可缓存的线程池重复利用
		ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();

		for(int i = 0;i < 20;i++){
			final int t = i;
			newCachedThreadPool.execute(new Runnable() {
				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName()+" "+t);
				}
			});
		}

	}

}

（2）newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

/**
 * newFixedThreadPool 创建一个定长线程池
 * @author johson
 *
 */
public class test05 {
	
	public static void main(String[] args) {
		ExecutorService newCachedThreadPool = Executors.newFixedThreadPool(3);
		
		for(int i = 0;i < 20;i++){
			final int t = i;
			newCachedThreadPool.execute(new Runnable() {
				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName()+" "+t);
				}
			});
		}

	}

}

（3）newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。


/**
 * newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
 * @author johson
 *
 */
public class test06 {
	
	public static void main(String[] args) {
		ScheduledExecutorService newCachedThreadPool = Executors.newScheduledThreadPool (10);
		
		for(int i = 0;i < 20;i++){
			final int t = i;
			newCachedThreadPool.schedule(new Runnable() {
				
				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName()+" "+t);
					
				}
			},3,TimeUnit.SECONDS);//3秒后执行调度
/*			newCachedThreadPool.execute(new Runnable() {
				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName()+" "+t);
				}
			});*/
		}

	}

}

（4）newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

/**
 * newSingleThreadExecutor 创建一个单线程化的线程池
 * @author johson
 *
 */
public class test07 {

	public static void main(String[] args) {
		ExecutorService newCachedThreadPool = Executors.newSingleThreadExecutor();
		
		for(int i = 0;i < 10;i++){
			final int t = i;
			newCachedThreadPool.execute(new Runnable() {
				
				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName()+" "+t);
				}
			});

		}
	}

}

2.4线程池原理分析

常用的四个线程池都是通过ThreadPoolExecutor()封装的

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

corePoolSize：核心线程数

maximumPoolSize：最大线程数

核心线程数与最大线程数的区别：核心线程数是指实际用的线程数，最大线程数是指最多能创建的线程数

最多支持的线程数=最大线程数+队列长度

2.5自定义线程池


/**
 * 自定义线程池
 * @author johson
 *
 */

class TaskThread implements Runnable{
	
	private String threadName;
	
	public TaskThread(String threadName) {
		this.threadName = threadName;
	}
	
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+" "+threadName);
		
	}
}
public class test08 {
	
	public static void main(String[] args) {
		
		//核心线程数为1（最多运行的线程数），最大线程数为2（最多只能创建几个线程），线程空闲超时时间，分钟还是秒，队列为3个
		ThreadPoolExecutor executor = new ThreadPoolExecutor(
				1, 2, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(3));
		
		//任务1创建线程，正在执行
		executor.execute(new TaskThread("任务1"));
		//任务2存放在队列缓存中，因为只有一个核心线程
		executor.execute(new TaskThread("任务2"));
		//任务3存放在队列缓存中，因为只有一个核心线程
		executor.execute(new TaskThread("任务3"));

		executor.execute(new TaskThread("任务4"));
		//再创建一个线程，因为最大能创建的线程数为2
		executor.execute(new TaskThread("任务5"));
		//任务6会报错，拒绝策略为线程数>最大线程数+队列长度
		//executor.execute(new TaskThread("任务6"));
	}


}

3.合理配置线程池

3.1 IO密集

表示该任务需要大量的IO，即大量的阻塞。

3.2 CPU密集

表示该任务需要大量的运算，而没有阻塞，CPU一直全速运行。

CPU密集任务只有在真正的多核CPU上才可能得到加速(通过多线程)，而在单核CPU上，无论你开几个模拟的多线程，该任务都不可能得到加速，因为CPU总的运算能力就那些。

CPU密集型时，任务可以少配置线程数，大概和机器的cpu核数相当，这样可以使得每个线程都在执行任务

IO密集型时，大部分线程都阻塞，故需要多配置线程数，2*cpu核数

听风_22774179
关注
专栏目录
Java并发编程面试题——JUC专题
二蛋的博客
02-20 7453
1.1AQS是什么？1.2唤醒线程时，AQS为什么从后往前遍历？1.3AQS为什么用双向链表，（为啥不用单向链表）？1.4AQS为什么要有一个虚拟的head节点1.5ReentrantLock的底层实现原理1.6ReentrantLock的公平锁和非公平锁的区别1.7ReentrantReadWriteLock如何实现的读写锁2.1说下你熟悉的阻塞队列？2.2虚假唤醒是什么？3.1线程池的7个参数3.2线程池的状态有什么，如何记录的？3.3线程池常见的拒绝策略3.4线程池执行流程3.5线程池为什么添加空任务
01蚂蚁-并发编程——并发编程线程池原理——1.阻塞队列与非阻塞队列并发队列
qq_28461661的博客
08-14 561
1.并发队列ConcuttrentLinkedQueue(非阻塞)、BlockingQueue(阻塞式) 阻塞式与非阻塞式队列的区别 入列、出列 阻塞式： 入列（存队列）阻塞式队列，如果超出队列总数，这时候会进行等待。 出列（获取队列），如果获取队列为空的情况下，这时候也会进行等待（阻塞）。 队列：主要遵循先进先出、后进后出。 注意事项：消费者，在消费队列信息的时候，一定要清空掉。 1.当消...
Java多线程-工具篇-BlockingQueue
weixin_30933531的博客
11-24 4008
前言： 在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员，包括他们各自的功能以及常见使用场景。 认识BlockingQueue阻塞队列，顾名思义，首先它是一个队列，而一个...
Java必实验四：线程应用
qq_62215764的博客
03-28 1347
一、 实验目的 1.掌握Java程序设计中的线程同步等技术。 二、实验内容与要求 (1). 运行以下三个程序（每个程序运行10次），并对输出结果给出分析。 (2). 编写Java应用程序实现如下功能：第一个线程生成一个随机数，第二个线程每隔一段时间读取第一个线程生成的随机数，并判断它是否是奇数。要求采用实现Runnable接口和Thread类的构造方法的方式创建线程，而不是通过Thread类的子类的方式。在报告中附上程序截图、完整的运行结果截图和简要文字说明。（20分） (3). 编写Jav.
线程池分析及原理 C语言
weixin_45868783的博客
06-06 350
线程池的作用： 第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。 第三：提高线程的可管理性。 线程池的组成部分： 1、线程池管理器 : 用于创建并管理线程池 2、工作线程: 线程池中线程 3、任务接口:每个任务必须实现的接口，以供工作线程调度任务的执行。 4、任务队列:用于存放没有处理的任务。提供一种缓冲机制。 对程序进行整体分析： 1、在主函数中： -> 先对线程池进行初始化，初始化各个数据
死磕Java多线程之线程池的基本使用与核心原理
学习和工作总结，共勉！
03-01 467
Java多线程之线程池 一、线程池的自我介绍 1. 线程池的重要性（为什么使用线程池） 线程池可以应对突然大爆发量的访问，通过有限个固定线程为大量的操作服务，减少创建和销毁线程所需的时间。 降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 提高响应：当任务到达时，任务可以不需要等到线程创建就能立即执行。 提高线程的可管理性：线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源...
JAVA并发编程——线程池详解
共勉
11-04 879
本文搞清Executor结构，ThreadPoolExecutor以及三种变式详解以及拓展，ScheduledThreadPoolExecutor与ThreadPoolExecutor区别在哪？核心线程如何复用？线程退出做了些什么？
Java 并发编程面试题——线程池
最新发布
代码星辰的博客
06-03 1682
本文主要参考《Java 并发编程的艺术》这本书，对面试中与线程池有关的面试题进行了总结。
并发编程系列——6线程池核心原理分析
Eclipse_2019的博客
10-18 195
线程池的核心原理分析
并发编程——线程池
一只奋斗的程序羊博客
08-08 553
目录 一、为什么要使用线程池 二、自定义线程池 自定义任务队列 自定义线程池管理器 拒绝策略接口 测试(任务生产者) 总结流程 三、线程池 ThreadPoolExecutor 线程池状态 线程池的工作状态 四、Executors 类 newFixedThreadPool（固定大小的线程池） newCachedThreadPool(带缓冲工厂的线程池) newSingleThreadExecutor(单线程的线程池) ...
java并发编程(二十七)——自定义线程池
程序员资料站
01-03 1335
前言 在Java并发编程(十)——常见几种线程池 中我们学习了常见的几种线程池，创建线程池的方法有两种，一种是手动创建，一种是自动创建。所谓自动创建线程池就是直接调用 Executors 的各种方法来生成前面学过的常见的线程池，例如 Executors.newCachedThreadPool()。 本文我们来分析自动创建线程池所可能带来的问题，以及我们自定义线程池时需要考虑的重点参数。 FixedThreadPool 第一种线程池 FixedThreadPool， 它是线程数量固定的线程池，如源码所示，ne
JAVA并发编程——源码原理全面剖析与重点梳理
lianghongliang66的博客
05-25 1199
帧与帧栈 每个线程有一块栈内存 每个栈由多个栈帧组成，每个栈帧对应每次方法调用占用的内存 每个线程只能有一个活动栈帧，对应当前正在执行的那个方法 线程上下文切换 线程的CPU时间片用完 垃圾回收 有更高优先级的线程需要运行 线程自己调用了sleep、yield、wait、join、park、synchronized、lock等方法 其中程序计数器的作用 操作系统保存当前线程的状态，记住下一条jvm指令的执行地址，用于恢复线程的状态 PS：状态：程序计数器、栈中每个帧栈的信息 线程状态
Java并发线程池
页页的博客
03-24 2138
线程池 一、为什么要用线程池？ 使用线程池的好处： 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。 比较重要的几个类： 类名 描述 ExecutorService 真正的线程池接口。 ScheduledExecutorService 能和Timer/Tim
java——比较难和底层的面试题 多线程相关
崔向阳@李晓的博客
07-04 374
多线程相关： 线程池的原理，为什么要创建线程池？创建线程池的方式； 答：线程池的大致原理：就是利用队列保存不能处理的请求，当有可用线程时再处理队列里的请求。为什么要创建线程： 降低资源消耗。通过重复利用已创建的线程降低线程创建、销毁线程造成的消耗。 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配、调优和监控 Jav..
Java并发编程-进阶篇（下）
JimmyU1的专栏
01-24 285
本章节主要讲解的是常用的并发队列 ConcurrentLinkedQueue并发无阻塞队列 BlockingQueue是并发阻塞队列 1. 无阻塞队列 ConcurrentLinkedQueue 无阻塞、无锁、高性能、无界、线程安全，性能优于BlockingQueue，不允许null值。 内部使用的链表存储数据，因此不会有容量限制。 static final class Node&lt;E&gt;...
SSM框架实现登录注册功能
热门推荐
听风的声音
09-18 6万+
很久之前用SSM框架写了一个注册登录的小程序（当然前端用的是模板），也算是自己的入门之作。今晚稍作修改，拿出来给大家学习，程序也许会有BUG，还请见谅。 下面说一下我的运行环境： Myeclipse 2017 CI 1 MySQL 5.7 Tomcat 8.5 项目结构如下 在数据库中新建user表： 有几个主要的配置文件，先了解下每个配置文件...
细粒度的权限控制
听风的声音
09-15 2361
权限控制，顾名思义，就是对不同的角色显示不同的内容以及给予不同角色不同的操作权限。这里举个非常简单的例子，普通员工只能查看自己发布的消息，而上级领导可以查看底下所有员工发布的消息。 其实权限控制并没有想象中的那么复杂，一般我们在查询列表的时候一般都会用  select * from table 假设我们要筛选列表，只显示部分内容，那么我们必须加上where条件。同理权限控制也是如此，只需要...
SpringBoot学习——SpringBoot监控中心SpringBoot Admin
听风的声音
08-10 374
一、SpringBoot Admin简介 Spring Boot Admin是一个开源社区项目，用于管理和监控SpringBoot应用程序，是一个分布式微服务监控中心一个应用程序就是一个Client，向Spring Boot Admin Server注册（通过HTTP）或使用SpringCloud注册中心（例如Eureka，Consul）发现。SpringBoot Admin是基于Actuat...
Java学习——并发编程之锁的深入化
听风的声音
06-14 268
五、锁的深入化 锁是并发编程共享数据，保证数据一致性的工具。在Java中有多种实现，例如synchronized（重量级锁）、ReentrantLock(轻量级锁)等，这些锁为我们的来发提供了便利。下面我跟大家聊一聊Java中锁的相关知识。 1.重入锁 重入锁的概念：重入锁也叫递归锁。就是说同一线程中，外层函数获取了锁，可以传递给内层函数去使用，可重入性可以避险死锁现象。synchroniz...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值