本篇文章给大家分享的是有关怎么在Java中使用wait和notifyAll实现阻塞队列，小编觉得挺实用的，因此分享给大家学习，希望大家阅读完这篇文章后可以有所收获，话不多说，跟着小编一起来看看吧。

让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：主机域名、虚拟主机、营销软件、网站建设、淮阳网站维护、网站推广。

import java.util.concurrent.atomic.AtomicInteger;
/**
 * @author lhd
 */
public class BlockQueue {
	/**
  * 生产者锁对象
  */
	private final Object addLock = new Object();
	/**
  * 消费者锁对象
  */
	private final Object deleteLock = new Object();
	/**
  * 队列总大小
  */
	private final Integer size = 30;
	/**
  * 数据存放
  */
	private Object[] queue = new Object[size];
	/**
  * 存放的数量,使用AtomicInteger是因为普通的int递增递减操作会存在非原子性的问题，会使数量异常
  */
	private AtomicInteger count = new AtomicInteger(0);
	/**
  * 生产
  * @param o 对象
  */
	public void add(Object o) {
		//获取生产锁,wait方法必须获取到对象锁后才可以调用，否则抛出异常
		synchronized (addLock){
			//判断是否超过队列大小,超过则进入等待
			while (count.get() >= size){
				try {
					addLock.wait();
				}
				catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			//存放一个
			queue[count.get()] = o;
			//递增
			int i = count.incrementAndGet();
			//打印一下日志
			String name = Thread.currentThread().getName();
			System.out.println(name + "生产了一个，现有数量" + i);
		}
		//如果队列有数据，则调用notifyAll唤醒消费者
		if (count.get() >= 1){
			//notifyAll、notify都需要先获取对象锁,否则会抛出异常
			synchronized (deleteLock){
				deleteLock.notifyAll();
			}
		}
	}
	/**
  * 消费
  * @return
  */
	public Object poll(){
		Object o;
		//先获取对象锁，和生产者类似
		synchronized (deleteLock){
			//队列里没有数据则等待
			while (count.get() <= 0){
				try {
					deleteLock.wait();
				}
				catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			//获取数据
			o = queue[count.get()];
			//递减
			int i = count.decrementAndGet();
			String name = Thread.currentThread().getName();
			System.out.println(name + "消费了一个，现有数量" + i);
		}
		//如果队列没有满，则可以唤醒生产者
		if (count.get() < size){
			//需要先获取到锁
			synchronized (addLock){
				addLock.notifyAll();
			}
		}
		return o;
	}
	/**
  * 简单的测试
  * @param args
  */
	public static void main(String[] args) {
		BlockQueue blockQueue = new BlockQueue();
		Thread t1 = new Thread(()-> {
			while (true){
				blockQueue.add(new Object());
			}
		}
		);
		Thread t2 = new Thread(()-> {
			while (true){
				blockQueue.add(new Object());
			}
		}
		);
		Thread t3 = new Thread(()-> {
			while (true){
				blockQueue.add(new Object());
			}
		}
		);
		Thread t4 = new Thread(()-> {
			while (true){
				blockQueue.poll();
			}
		}
		);
		Thread t5 = new Thread(()-> {
			while (true){
				blockQueue.poll();
			}
		}
		);
		Thread t6 = new Thread(()-> {
			while (true){
				blockQueue.poll();
			}
		}
		);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		t5.start();
		t6.start();
	}
}

效果：其实这个递增递减操作和打印操作也不是原子操作

依次打印线程1,2,3

/**
 * @author lhd
 */
public class JoinTest {


 public static void main(String[] args) throws InterruptedException {
  Thread t1 = new Thread(() -> System.out.println(1));
  Thread t2 = new Thread(()-> System.out.println(2));
  Thread t3 = new Thread(()-> System.out.println(3));

  t1.start();
  t1.join();

  t2.start();
  t2.join();

  t3.start();
  t3.join();
 }
}

以上就是怎么在Java中使用wait和notifyAll实现阻塞队列，小编相信有部分知识点可能是我们日常工作会见到或用到的。希望你能通过这篇文章学到更多知识。更多详情敬请关注创新互联行业资讯频道。

网页题目：怎么在Java中使用wait和notifyAll实现阻塞队列
网页地址：http://pwwzsj.com/article/jeesgj.html