阻塞队列步步升华

最新推荐文章于 2024-08-23 15:54:50 发布
最新推荐文章于 2024-08-23 15:54:50 发布
阅读量126 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jefry2008/article/details/84048700
版权
[size=x-large][b]1、首先我们定义一个简单的队列。这个队列可以不断的往队列中放数据，一个放数据的线程，一个取数据的线程。队列可以无限大，所以这样会有内存泄露的危险。[/b][/size] 
package com.zte;

import java.util.Random;
import java.util.Vector;


public class SimpleQueue {

	Vector<Integer>  vector = new Vector<Integer>();

	public synchronized void put(){
		System.out.println(Thread.currentThread().getName() + "，开始放数据。");
		vector.add(new Random().nextInt(1000));
		System.out.println(Thread.currentThread().getName() + "，已放完数据。");
		System.out.println("队列中还有：" + vector.size());
		this.notify(); //只是通知另外的线程你可以获得锁，如果本线程获取了锁，其他线程也是获取不到锁的
	}

	public synchronized Integer get(){
		System.out.println(Thread.currentThread().getName() + "，开始取数据。");
		while(vector.size() == 0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}					
		}

		Integer integer = vector.firstElement();
		vector.remove(integer);
		System.out.println(Thread.currentThread().getName() + "，已取完数据。");
		System.out.println("队列中还有：" + vector.size());
		return integer;	
	}


	public static void main(String[] args){
		final SimpleQueue simpleQueue = new SimpleQueue();
		new Thread(new Runnable() {

			@Override
			public void run() {
				try {
					while(true){
					simpleQueue.get();
					Thread.sleep(new Random().nextInt(1000));
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}).start();

		new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					while(true){
			        simpleQueue.put();
					Thread.sleep(new Random().nextInt(1000));
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

			}
		}).start();

	}

}



[size=x-large][b]2、我们定义一个简单的队列。三个放数据的线程，三个取数据的线程。队列可以无限大，如果放数据的线程远多余取数据的线程，这样就会大大增加内存泄露的危险[/b][/size] 
package com.zte;

import java.util.Random;


public class MitThreadBufferArraySimpleQueue {

	Integer[] array = new Integer[20];
	int putPostion;
	int getPostion;
	int count;
	public synchronized void put(){
		if(count == array.length) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName() + "，开始放数据。");
		array[putPostion] = new Random().nextInt(1000);
		putPostion ++;
		count ++;
		if(putPostion == array.length) putPostion = 0;
		System.out.println(Thread.currentThread().getName() + "，已放完数据。");
		System.out.println("队列中还有：" + count +"个对象");
		this.notify(); //只是通知另外的线程你可以获得锁，如果本线程获取了锁，其他线程也是获取不到锁的
	}

	public synchronized Integer get(){
		if(count == 0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		System.out.println(Thread.currentThread().getName() + "，开始取数据。");
	    Integer intObject = array[getPostion];
	    getPostion ++ ;
	    count--;
	    if(getPostion == array.length) getPostion = 0;

		System.out.println(Thread.currentThread().getName() + "，已取完数据。");
		System.out.println("队列中还有：" + count + "个对象");
		this.notify();
		return intObject;	
	}


	public static void main(String[] args){
		final MitThreadBufferArraySimpleQueue bufferArraySimpleQueue= new MitThreadBufferArraySimpleQueue();
		for(int i=0 ; i<3;i++) {
		new Thread(new Runnable() {			
			@Override
			public void run() {
				try {
					while(true){
						bufferArraySimpleQueue.get();
					Thread.sleep(new Random().nextInt(1000));
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}).start();
		}

		for(int j=0 ; j<3;j++) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					while(true){
						bufferArraySimpleQueue.put();
					Thread.sleep(new Random().nextInt(1000));
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

			}
		}).start();
		}
	}

}


[size=x-large][b]3、定义一个带有缓冲区的队列，这样可以避免内存溢出。虽然避免了内存溢出问题，但拥塞现象严重[/b][/size] 
package com.zte;

import java.util.Random;


public class MitThreadBufferArraySimpleQueue {

	Integer[] array = new Integer[20];
	int putPostion;
	int getPostion;
	int count;
	public synchronized void put(){
		if(count == array.length) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName() + "，开始放数据。");
		array[putPostion] = new Random().nextInt(1000);
		putPostion ++;
		count ++;
		if(putPostion == array.length) putPostion = 0;
		System.out.println(Thread.currentThread().getName() + "，已放完数据。");
		System.out.println("队列中还有：" + count +"个对象");
		this.notify(); //只是通知另外的线程你可以获得锁，如果本线程获取了锁，其他线程也是获取不到锁的
	}

	public synchronized Integer get(){
		if(count == 0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		System.out.println(Thread.currentThread().getName() + "，开始取数据。");
	    Integer intObject = array[getPostion];
	    getPostion ++ ;
	    count--;
	    if(getPostion == array.length) getPostion = 0;

		System.out.println(Thread.currentThread().getName() + "，已取完数据。");
		System.out.println("队列中还有：" + count + "个对象");
		this.notify();
		return intObject;	
	}


	public static void main(String[] args){
		final MitThreadBufferArraySimpleQueue bufferArraySimpleQueue= new MitThreadBufferArraySimpleQueue();
		for(int i=0 ; i<3;i++) {
		new Thread(new Runnable() {			
			@Override
			public void run() {
				try {
					while(true){
						bufferArraySimpleQueue.get();
					Thread.sleep(new Random().nextInt(1000));
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}).start();
		}

		for(int j=0 ; j<3;j++) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					while(true){
						bufferArraySimpleQueue.put();
					Thread.sleep(new Random().nextInt(1000));
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

			}
		}).start();
		}
	}

}


[size=x-large][b]4、考虑带缓冲区的队列，启动多个线程存放数据，出现数据脏数据。[/b][/size] 
package com.zte;

import java.util.Random;


public class ConditionMitThreadBufferArraySimpleQueue {

	Integer[] array = new Integer[20];
	int putPostion;
	int getPostion;
	int count;
	public synchronized void put(){
		if(count == array.length) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName() + "，开始放数据。");
		array[putPostion] = new Random().nextInt(1000);
		putPostion ++;
		count ++;
		if(putPostion == array.length) putPostion = 0;
		System.out.println(Thread.currentThread().getName() + "，已放完数据。");
		System.out.println("队列中还有：" + count +"个对象");
		this.notify(); //只是通知另外的线程你可以获得锁，如果本线程获取了锁，其他线程也是获取不到锁的
	}

	public synchronized Integer get(){
		if(count == 0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		System.out.println(Thread.currentThread().getName() + "，开始取数据。");
	    Integer intObject = array[getPostion];
	    getPostion ++ ;
	    count--;
	    if(getPostion == array.length) getPostion = 0;

		System.out.println(Thread.currentThread().getName() + "，已取完数据。");
		System.out.println("队列中还有：" + count + "个对象");
		this.notify();
		return intObject;	
	}


	public static void main(String[] args){
		final ConditionMitThreadBufferArraySimpleQueue bufferArraySimpleQueue= new ConditionMitThreadBufferArraySimpleQueue();
		for(int i=0 ; i<3;i++) {
		new Thread(new Runnable() {			
			@Override
			public void run() {
				try {
					while(true){
						bufferArraySimpleQueue.get();
					Thread.sleep(new Random().nextInt(1000));
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}).start();
		}

		for(int j=0 ; j<3;j++) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					while(true){
						bufferArraySimpleQueue.put();
					Thread.sleep(new Random().nextInt(1000));
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

			}
		}).start();
		}
	}

}


运行部分结果：
队列中还有：-2个对象
Thread-0，开始取数据。
Thread-0，已取完数据。
队列中还有：-3个对象
Thread-1，开始取数据。
Thread-1，已取完数据。
队列中还有：-4个对象
Thread-5，开始放数据。
Thread-5，已放完数据。
队列中还有：-3个对象
Thread-4，开始放数据。
Thread-4，已放完数据。
队列中还有：-2个对象
Thread-3，开始放数据。
Thread-3，已放完数据。
队列中还有：-1个对象
Thread-0，开始取数据。
Thread-0，已取完数据。
队列中还有：-2个对象
Thread-2，开始取数据。
Thread-2，已取完数据。
队列中还有：-3个对象
Thread-0，开始取数据。
Thread-0，已取完数据。
队列中还有：-4个对象

[size=x-large][b]5、运用JAVA5中锁与Condition机制，完美解决问题[/b][/size] 
package com.zte;

import java.util.Random;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


public class BufferArraySimpleQueue {

	Integer[] array = new Integer[20];
	int putPostion;
	int getPostion;
	int count;
	Lock lock = new ReentrantLock();
	Condition readCondition = lock.newCondition();
	Condition writeCondition = lock.newCondition();
	public  void put(){
	 lock.lock();
	  try{	
		if(count == array.length) {
			try {
				writeCondition.await();				
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName() + "，开始放数据。");
		array[putPostion] = new Random().nextInt(1000);
		putPostion ++;
		count ++;
		if(putPostion == array.length) putPostion = 0;
		System.out.println(Thread.currentThread().getName() + "，已放完数据。");
		System.out.println("队列中还有：" + count +"个对象");
		readCondition.signal(); //只是通知另外的线程你可以获得锁，如果本线程获取了锁，其他线程也是获取不到锁的
	  }finally {
		  lock.unlock();
	  }
	  }

	public  Integer get(){
		lock.lock();
		try{
		if(count == 0) {
			try {
			   readCondition.await();	
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		System.out.println(Thread.currentThread().getName() + "，开始取数据。");
	    Integer intObject = array[getPostion];
	    getPostion ++ ;
	    count--;
	    if(getPostion == array.length) getPostion = 0;

		System.out.println(Thread.currentThread().getName() + "，已取完数据。");
		System.out.println("队列中还有：" + count + "个对象");
		writeCondition.signal();
		return intObject;	
		}finally{
			lock.unlock();
		}
		}


	public static void main(String[] args){
		final BufferArraySimpleQueue bufferArraySimpleQueue= new BufferArraySimpleQueue();

		new Thread(new Runnable() {			
			@Override
			public void run() {
				try {
					while(true){
						bufferArraySimpleQueue.get();
					Thread.sleep(new Random().nextInt(1000));
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}).start();


		new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					while(true){
						bufferArraySimpleQueue.put();
					Thread.sleep(new Random().nextInt(500));
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

			}
		}).start();

	}

}
Jefry2008
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剖析Java中阻塞队列的实现原理及应用场景
09-03
Java中的阻塞队列是一种特殊的线程安全的数据结构，它在多线程环境下用于高效地处理生产者-消费者问题。阻塞队列的核心特性在于当队列为空时，尝试获取元素的线程会被阻塞，直到队列中有元素可用；同样，当队列满时...
Java并发编程：阻塞队列
01-20
　在前面我们接触的队列都是非阻塞队列，比如PriorityQueue、LinkedList（LinkedList是双向链表，它实现了Dequeue接口）。 　使用非阻塞队列的时候有一个很大问题是：它不会对当前线程产生阻塞，那么在面对类似...
这一年，这些书：2022年读书笔记
热门推荐
Heartsuit的博客
12-31 3万+
Note: 以下 `markdown` 格式文本由 `json2md` 自动转换生成，可参考[JSON转Markdown：我把阅读数据从MongoDB中导出转换为.md了](https://blog.csdn.net/u013810234/article/details/113360229)了解具体的转换过程。2022年读书笔记
DirectX12（D3D12）基础教程（六）——多线程渲染
Gamebaby Rock Sun的博客
01-14 1万+
  目录   1、前言 2、为什么要多线程渲染 3、多线程 3.1、什么是线程 3.2、进程的主线程 3.3、线程的入口函数 3.4、创建线程 3.5、CreateThread示例 3.6、C/C++创建线程函数（VC版） 3.7、_beginthreadex示例 3.8、线程退出 3.9、线程的暂停(挂起)和恢复 3.10、线程的暂停式创建 3.11、线程栈 3...
java并发编程第十五课 并发基石AQS详解
fegus的博客
05-27 531
第75讲：为什么需要 AQS？AQS 的作用和重要性是什么？ 本课时我们主要讲解 AQS 的重要性，为什么需要 AQS，以及它的作用。 AQS 的重要性 我们先来介绍一下 AQS（AbstractQueuedSynchronizer）的重要性，来看看 AQS 被用在了哪些类里面。 如图所示，AQS 在 ReentrantLock、ReentrantReadWriteLock、Semaphore、CountDownLatch、ThreadPoolExcutor 的 Worker 中都有运用（JDK 1.8）
深入理解信号槽机制
frank的专栏
04-04 1万+
原文不可考 来源链接http://blog.csdn.net/liuuze5/article/details/53523463 深入理解信号槽（一） 这篇文章来自于 A Deeper Look at Signals and Slots，Scott Collins 2005.12.19。需要说明的是，我们这里所说的“信号槽”不仅仅是指 Qt 库里面的信号槽，而是站在一个全局的...
个人多线程与并发与精通笔记
qq_36280879的博客
06-21 288
最主要就是提高 CPU 的利用率多线程程序可以充分使用 CUP 的效率避免无效等待（IO 的时候可以做别的事）提高用户体验：避免卡顿，缩短等待时间并行处理：提高性能，通常是在服务器领域（例如 Tomcat），用多个线程去接收进来的 HTTP 请求，而不是排队等待单一的线程处理在 Android 开发中，主线程的重要任务之一就是绘制屏幕界面，该线程中不允许进行 IO 操作或网络请求，目的就是避免卡顿，影响用户的交互串行和并行并发和并行概念非常相似并发：这里是单核 CPU(1 核），A、B、C 任务分次调度，这
面向对象第四单元小结
weixin_30780221的博客
06-21 196
面向对象第四单元：UML类图、顺序图、状态图 一、架构设计 第一次作业      第四单元第一次作业，需要完成的任务为实现一个UML类图解析器UmlInteraction，学习目标为UML入门级的理解、UML类图的构成要素及其解析方法。最终需要实现一个UML类图解析器，可以通过输入各种指令来进行类图有关信息的查询。具体来说，需要新建一个类MyUmlInteraction，并实现相应的...
如何成为一名架构师,架构师成长之路
qq_27989563的博客
11-29 503
大量阅读别人的系统实现文章( 架构= 模块图 + 模块流程图(启动 和 主流程 ,可以用拟物 tag) 或者 模块时序图) 动态+静态 .对象很重要,模块很重要. 从产品角度,用户很重要 脑图不需要按空格,收缩行 https://www.processon.com/view/link/58c7cbbfe4b020bb58b2e0d6 架构脑图 编辑脑图 我理解的架构师需要掌握的知识 用例收集能...
如何成为一名架构师,架构师成长之路（转）
weixin_34204057的博客
02-23 839
转自http://blog.csdn.net/fei33423/article/details/61934514 如何成为一名架构师,架构师成长之路 原创 2017年03月13日 22:50:34 3116 大量阅读别人的系统实现文章( 架构= 模块图 + 模块流程图(启动 和 主流程 ,可以用拟物 tag) 或者 模块时序图) 动态+静态 .对象很重要,模块很...
大规模分布式存储系统 - 读书笔记
Syntactic Sugar
04-19 2379
文章目录大规模分布式存储系统（原理解析与架构实战OceanBase）第1章 概述1.1 分布式存储概述1.2 分布式存储分类第一篇 基础篇第2章 单机存储系统2.1 硬件基础2.1.1 CPU架构2.1.2 IO总线2.1.3 网络拓扑2.1.4 性能参数2.1.5 存储层次架构2.2 单机存储引擎2.2.1 哈希存储引擎2.2.2 B树存储引擎2.2.3 LSM树存储引擎2.3 数据模型2.3.1 文件模型2.3.2 关系模型2.3.3 键值模型2.3.4 SQL与NoSQL2.4 事务与并发控制2.4.
java阻塞队列实现原理及实例解析
08-25
阻塞队列与普通队列的不同在于，当队列是空的时候，从队列中获取元素的操作将会被阻塞，或者当队列满时，往队列里面添加元素将会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列...
详解java中的阻塞队列
08-19
阻塞队列是一个支持先进先出的队列，同时也支持阻塞操作的队列，即当队列满时，会阻塞执行插入操作的线程，直到队列不满；当队列为空时，会阻塞执行获取操作的线程，直到队列不为空。 阻塞队列可以分为有界队列和...
并发－线程池和阻塞队列.pdf
10-17
阻塞队列的一个重要特点是线程在队列满时加入元素会阻塞，在队列空时取出元素也会阻塞，直到有空间或元素可用。Java中的ArrayBlockingQueue和LinkedBlockingQueue都是典型的阻塞队列实现。 阻塞队列为线程间通信...
开发多线程程序时，需要注意那些问题
最新发布
OO_SEN的博客
08-23 398
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 727
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 492
@Transactional中使用线程锁导致了锁失效与解决方案
android apk 加固后的地图加载异常及重新签名
calivnBao的博客
08-20 231
android apk 加固后的地图加载异常及重新签名
Excel解析 阻塞队列
03-29
Excel解析是指将Excel文件中的数据提取出来并进行处理的过程。阻塞队列是一种特殊的队列数据结构，它在队列为空时会阻塞等待，直到队列中有新的元素加入，或者在队列已满时会阻塞等待，直到队列中有空位可以插入新的元素。 在Excel解析中，阻塞队列可以用于实现生产者-消费者模型，其中生产者负责读取Excel文件中的数据，并将数据放入阻塞队列中，而消费者则从阻塞队列中取出数据进行处理。这样可以有效地控制生产者和消费者之间的速度差异，避免数据丢失或者内存溢出的问题。 使用阻塞队列的好处是可以简化线程间的同步与通信，提高系统的可靠性和稳定性。当生产者线程读取Excel数据时，如果阻塞队列已满，则生产者线程会被阻塞，直到有空位可以插入数据。而消费者线程在处理数据时，如果阻塞队列为空，则消费者线程会被阻塞，直到有新的数据可以取出。 通过使用阻塞队列，可以有效地解耦生产者和消费者之间的关系，提高系统的并发性能和可扩展性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值