Java多线程实现生产者消费者程序（Wait，Notify实现和Lock，Condition实现）

最新推荐文章于 2021-04-21 13:24:39 发布
最新推荐文章于 2021-04-21 13:24:39 发布
阅读量941 收藏 1
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dax1n/article/details/62222845
版权

Java多线程实现生产者消费者程序。

如下代码是反例，只适用于一个生产者和消费者的情景。对于多个生产者消费者的情景如下实现代码是错误的！！！（错误原因是对线程加锁了，而没有对临界区加锁，记录下来并不是想误导别人，就想提醒自己曾经犯过的错误）。正确的生产者消费者见下面部分！！！ （如果存在错误欢迎指导提出错误）



使用wait和notify的一个生产者一个消费者的实现：

package com.daxin;

import java.util.ArrayList;
import java.util.Random;
/**
 * 
 * 生产者消费者程序
 * 
 * @author Daxin
 *
 */
public class ProducerAndConsumer {

	private ArrayList<String> values = new ArrayList<String>();//共享数据临界区

	public static void main(String[] args) throws InterruptedException {

		ProducerAndConsumer pc = new ProducerAndConsumer();

		Producer p = pc.new Producer();

		Consumer c = pc.new Consumer();

		p.start();
		c.start();

	}

	class Producer extends Thread {

		@Override
		public void run() {

			while (true) {// 一直生产

				synchronized (values) {//进行加锁互斥访问
					if (values.size() == 10) {
						System.out.println("队列满了,无法生产数据");
						try {
							values.wait();//阻塞生产者生产，和消费者的notify对应，消费者的notify唤醒这一行的wait
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
							values.notify();
						}

					}
					//需要在同步代码块中实现
					String str = "" + new Random().nextInt(20);
					System.out.println("生产了数据为 " + str);
					values.add(str);
					values.notify();// 唤醒消费者去交费

				}
			}

		}

	}

	class Consumer extends Thread {
		@Override
		public void run() {

			while (true) {// 一直消费

				synchronized (values) {//进行加锁互斥访问
					if (values.size() == 0) {
						//
						System.out.println("没有数据了,无法完成消费了");
						try {

							values.wait();// 消费者进行等待
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
							values.notify();
						}
					}
					//需要在同步代码块中实现
					String value = values.remove(0);
					System.out.println("消费了数据为：" + value);
					values.notify();// 通知生产者生产消息

				}
			}

		}
	}

}


使用并发重入锁ReentrantLock和Condition的一个生产者一个消费者的实现：


package com.daxin;

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

public class ProducerAndConsumerReentrantLockCondition {
	ReentrantLock rl = new ReentrantLock();
	Condition cd = rl.newCondition();
	private ArrayList<String> values = new ArrayList<String>();// 共享数据临界区

	public static void main(String[] args) {
		ProducerAndConsumerReentrantLockCondition pc = new ProducerAndConsumerReentrantLockCondition();
		ProducerReentrantLockCondition p = pc.new ProducerReentrantLockCondition();
		ConsumerReentrantLockCondition c = pc.new ConsumerReentrantLockCondition();

		p.start();
		c.start();

	}

	class ProducerReentrantLockCondition extends Thread {

		@Override
		public void run() {
			while (true) {
				rl.lock();// 生产者获取锁进行互斥访问
				if (values.size() == 10) {
					try {
						System.out.println("生产满了");
						cd.await();// 阻塞生产者进行生产
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
						rl.unlock();
					}

				}

				String e = (new Random().nextInt(20)) + "";
				System.out.println("生产者生产数据为 " + e);
				values.add(e);

				cd.signal();// 唤醒消费者生产

			}

		}

	}

	class ConsumerReentrantLockCondition extends Thread {
		@Override
		public void run() {
			while (true) {
				rl.lock();

				if (values.size() == 0) {

					try {
						System.out.println("消费空了");
						cd.await();// 阻塞消费者进行消费
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}

				}

				String e = values.remove(0);

				System.out.println("消费的数据为 " + e);

				cd.signal();// 唤醒消费者消费

				rl.unlock();

			}

		}
	}

}
上面代码是错误的代码示例，作为提醒避免犯这种错误。


上面代码不健全的原因就是对线程加锁了。所以如果在多个生产者和多个消费者的模型中，程序的声明周期中只有第一个获取到所的生产者和第一个获取锁的消费者能够相互等待唤醒，其他线程在程序声明周期内是一直等待的！因此解决这个问题就是创建临界区，然后对临界区进行加锁：


健全的wait和notify的实现

/**
 * 缓冲区容量为10
 * 
 * 使用notify和wait实现的缓冲区
 *
 */
class Buffer_WN {

	private List<Integer> buffer = new ArrayList<>();

	private final int capacity = 10;
	private  int sum = 0;
	
	

	/**
	 * synchronized对当前this实例加锁。静态方法对class字节码文件加锁。
	 * 
	 * @throws Exception
	 */
	public void put(String name) throws Exception {
		// 对临界区进行加锁 
		synchronized (buffer) {

			// while解决伪唤醒
			while (buffer.size() == capacity) {
				buffer.wait();
			}
			if((++sum)>20)
			{
				System.out.println("数据生产完毕！");
				return ;
			}
			buffer.add(8);
			System.out.println(name + " 生产了一条数据 +.");
			buffer.notifyAll();
		}

	

	}

	public  void get(String name) throws Exception {
		// 对临界区进行加锁 
		synchronized (buffer) {
			
			// while解决伪唤醒
			while (buffer.size() == 0) {
				buffer.wait();
			}

			buffer.remove(0);
			System.out.println(name + " 消费了一条数据 -.");
			buffer.notifyAll();
		}
		
	}
}

/**
 * 
 * 
 * @author Daxin
 *
 */
public class ProducerAndConsumer_Wait_Notify {

	// 锁：是互斥变量 。控制互斥访问时候资源不可用时候进行阻塞
	static Lock lock = new ReentrantLock();
	// condition：条件变量，操作系统的。当不满足需要的条件时候进行互斥。
	static Condition c = lock.newCondition();

	static List<Integer> buffer = new ArrayList<>();

	public static void main(String[] args) {
		Buffer_WN buffer = new Buffer_WN();
		Thread producer = newProducer("1111", buffer);
		producer.start();
		Thread producer1 = newProducer("2222", buffer);
		producer1.start();

		Thread consumer = newConsumer("3333", buffer);
		consumer.start();
		Thread consumer1 = newConsumer("4444", buffer);
		consumer1.start();

	}

	public static Thread newProducer(final String name, final Buffer_WN buffer) {
		return new Thread(new Runnable() {

			@Override
			public void run() {

				try {
					while (true) {

						buffer.put(name);
						Thread.sleep(500);
					}
				} catch (Exception e) {
					e.printStackTrace();
				}

			}

		});
	}

	public static Thread newConsumer(final String name, final Buffer_WN buffer) {
		return new Thread(new Runnable() {

			@Override
			public void run() {

				try {
					while (true) {

						buffer.get(name);
						Thread.sleep(500);
					}
				} catch (Exception e) {

					e.printStackTrace();
				}

			}
		});

	}

}





健全的ReentrantLock和Condition实现方式1，对Lock绑定一个Condition对象（对临界区加锁），并使用if 判断解决伪唤醒：

package com.daxin.lock.condition;

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

/**
 * 缓冲区容量为10
 * @author Daxin
 *
 */
class Buffer {

	private List<Integer> buffer = new ArrayList<>();
	// 锁：是互斥变量 。控制互斥访问时候资源不可用时候进行阻塞
	Lock lock = new ReentrantLock();
	// condition：条件变量，操作系统的。当不满足需要的条件时候进行互斥。
	Condition c = lock.newCondition();

	public void put(String name) {

		try {
			lock.lock();

			if (buffer.size() == 10) {
				//代码位置1
				c.await(); // 缓冲区满了的话则阻塞当前线程在此处，等待消费者线程通知唤醒
			}
			
		//避免生产者1，在代码位置1处await，然后生产者2在代码位置2处恰好生产一个元素导致buffer是10个。所以执行代码位置3，而代码位置3恰好唤醒了生产者1，因此导致buffer缓冲区大于10
			if (buffer.size() < 10) {// 也就是所谓解决伪唤醒，也可以使用while循环解决伪唤醒
				int val = new Random().nextInt(100);
				buffer.add(new Integer(val));//代码位置2
				System.out.println("生产者"+name+" 生产数据完毕！生产的数据为：" + val + "缓冲区大小为：" + buffer.size());
			}
			
//			代码位置3
			c.signalAll();// 如果有资源可以获得的话，通知消费者消费（注意：此时如果当前缓冲区没有满的话，不会调用当前的c.await();
						// 所以不会释放锁，所以消费者线程也无法消费，只有缓冲区满了之后才可以获取锁进行消费）
			Thread.sleep(200);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			lock.unlock();
		}

	}

	public void get(String name) {
		try {

			lock.lock();

			if (buffer.size() == 0) {
				c.await(); // 阻塞，等待生产者生产

			}

			if (buffer.size() > 0) { //解决伪唤醒代码
				int val = buffer.get(0);
				System.out.println("消费者"+name+" 消费数据完毕！消费数据为：" + val + "缓冲区大小为：" + buffer.size());
				buffer.remove(0);

			}
			

			c.signalAll();
			Thread.sleep(200);
		}

		catch (

		Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}

	}
}

/**
 * 
 * 
 * @author Daxin
 *
 */
public class ProducerAndConsumer {

	// 锁：是互斥变量 。控制互斥访问时候资源不可用时候进行阻塞
	static Lock lock = new ReentrantLock();
	// condition：条件变量，操作系统的。当不满足需要的条件时候进行互斥。
	static Condition c = lock.newCondition();

	static List<Integer> buffer = new ArrayList<>();

	public static void main(String[] args) {
		Buffer buffer = new Buffer();
		Thread producer = newProducer("1", buffer);
		producer.start();
		Thread producer1 = newProducer("2", buffer);
		producer1.start();

		Thread consumer = newConsumer("1", buffer);
		consumer.start();
		Thread consumer1 = newConsumer("2", buffer);
		consumer1.start();

	}

	public static Thread newProducer(final String name, final Buffer buffer) {
		return new Thread(new Runnable() {

			@Override
			public void run() {

				while (true) {

					buffer.put(name);

				}

			}

		});
	}

	public static Thread newConsumer(final String name, final Buffer buffer) {
		return new Thread(new Runnable() {

			@Override
			public void run() {

				while (true) {

					buffer.get(name);

				}

			}
		});

	}

}


健全的ReentrantLock和Condition实现方式1，对Lock绑定一个Condition对象（对临界区加锁），并使用while解决伪唤醒：

package com.daxin.lock.condition;

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

/**
 * 
 * 
 * @author Daxin
 *
 */
class Buffer_WHX {

	private List<Integer> buffer = new ArrayList<>();
	// 锁：是互斥变量 。控制互斥访问时候资源不可用时候进行阻塞
	Lock lock = new ReentrantLock();
	// condition：条件变量，操作系统的。当不满足需要的条件时候进行互斥。
	Condition c = lock.newCondition();// 最好还是参见JDK文档使用两个Condition实例

	public void put(String name) {

		try {
			lock.lock();

			while (buffer.size() == 10) { //while死循环解决伪唤醒
				// 代码位置1
				c.await(); // 缓冲区满了的话则阻塞当前线程在此处，等待消费者线程通知唤醒
			}

				int val = new Random().nextInt(100);
				buffer.add(new Integer(val + 20));// 代码位置2
				System.out.println("生产者" + name + " 生产数据完毕！生产的数据为：" + val + "缓冲区大小为：" + buffer.size());

			// 代码位置3
			c.signalAll();// 如果有资源可以获得的话，通知消费者消费（注意：此时如果当前缓冲区没有满的话，不会调用当前的c.await();
							// 所以不会释放锁，所以消费者线程也无法消费，只有缓冲区满了之后才可以获取锁进行消费）
			 
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}

	}

	public void get(String name) {
		try {

			lock.lock();

			while (buffer.size() == 0) {
				c.await(); // 阻塞，等待生产者生产

			}

			 
				int val = buffer.get(0);
				System.out.println("消费者" + name + " 消费数据完毕！消费数据为：" + val + "缓冲区大小为：" + buffer.size());
				buffer.remove(0);

			c.signalAll();

		}

		catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}

	}
}

/**
 * 
 * 
 * @author Daxin
 *
 */
public class ProducerAndConsumer_4 {

	// 锁：是互斥变量 。控制互斥访问时候资源不可用时候进行阻塞
	static Lock lock = new ReentrantLock();
	// condition：条件变量，操作系统的。当不满足需要的条件时候进行互斥。
	static Condition c = lock.newCondition();

	static List<Integer> buffer = new ArrayList<>();

	public static void main(String[] args) {
		Buffer buffer = new Buffer();
		Thread producer = newProducer("1111", buffer);
		producer.start();
		Thread producer1 = newProducer("2222", buffer);
		producer1.start();

		Thread consumer = newConsumer("3333", buffer);
		consumer.start();
		Thread consumer1 = newConsumer("4444", buffer);
		consumer1.start();

	}

	public static Thread newProducer(final String name, final Buffer buffer) {
		return new Thread(new Runnable() {

			@Override
			public void run() {

				while (true) {

					buffer.put(name);

				}

			}

		});
	}

	public static Thread newConsumer(final String name, final Buffer buffer) {
		return new Thread(new Runnable() {

			@Override
			public void run() {

				try {
					while (true) {

						buffer.get(name);
					}
				} catch (Exception e) {

					e.printStackTrace();
				}

			}
		});

	}

}



健全的ReentrantLock和Condition实现方式2，对Lock绑定两个Condition对象（对临界区加锁）：


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

/**
 * JDK文档携带的Condition示例
 * 
 * @author Daxin
 *
 */
class BoundedBuffer {
	final Lock lock = new ReentrantLock();
	// Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象
	final Condition notFull = lock.newCondition();
	// Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象
	final Condition notEmpty = lock.newCondition();

	final Object[] items = new Object[5];
	int putptr, takeptr, count;

	public void put(Object x) throws InterruptedException {
		lock.lock();
		try {
			while (count == items.length)
				// 满了的话阻塞此处，并释放锁。
				notFull.await();
			items[putptr] = x;
			if (++putptr == items.length)
				putptr = 0;
			++count;
			notEmpty.signal();
		} finally {
			// 没有满的话。执行finally释放锁
			lock.unlock();
		}
	}

	public Object take() throws InterruptedException {
		lock.lock();
		try {
			while (count == 0)
				notEmpty.await();
			Object x = items[takeptr];
			if (++takeptr == items.length)
				takeptr = 0;
			--count;
			notFull.signal();
			return x;
		} finally {
			lock.unlock();
		}
	}
}

public class JDK_Document_Lock_Condition {

	public static void main(String[] args) throws Exception {
		final BoundedBuffer bf = new BoundedBuffer();
		new Thread(new Runnable() {

			@Override
			public void run() {
				try {
					while(true){
						bf.put(new Object());
						System.out.println("生产者生产完毕！");
					}
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}

			}
		}).start();

		new Thread(new Runnable() {

			@Override
			public void run() {
				try {
					
				while(true){
					System.out.println("消费者消费完毕！ "+bf.take());
				}
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}

			}
		}).start();

	}
}


Lock和Condition在JDK中LinkedBlockingQueue的应用，核心源码如下：

import java.util.concurrent.LinkedBlockingQueue.Node;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * LinkedBlockingQueue核心方法源码分析
 *  
 *
 */
public class LinkedBlockingQueue {
	
	/** Current number of elements */
	//使用AtomicInteger的原因是：LinkedBlockingQueue的take和put使用的是两把锁。所以需要对count进行同步。
	//同时count使用AtomicInteger可以解决take和put的冲突操作
    private final AtomicInteger count = new AtomicInteger(0); 

	/** Lock held by take, poll, etc */
	private final ReentrantLock takeLock = new ReentrantLock();

	/** Wait queue for waiting takes */
	private final Condition notEmpty = takeLock.newCondition(); //绑定takeLock

	/** Lock held by put, offer, etc */
	private final ReentrantLock putLock = new ReentrantLock();

	/** Wait queue for waiting puts */
	private final Condition notFull = putLock.newCondition();//绑定putLock

	/**
	 * Inserts the specified element at the tail of this queue, waiting if
	 * necessary for space to become available.
	 *
	 * @throws InterruptedException
	 *             {@inheritDoc}
	 * @throws NullPointerException
	 *             {@inheritDoc}
	 */
	public void put(E e) throws InterruptedException {
		if (e == null)
			throw new NullPointerException();
		// Note: convention in all put/take/etc is to preset local var
		// holding count negative to indicate failure unless set.
		int c = -1;
		Node<E> node = new Node(e);
		final ReentrantLock putLock = this.putLock;
		final AtomicInteger count = this.count;
		putLock.lockInterruptibly();
		try {
			/*
			 * Note that count is used in wait guard even though it is not
			 * protected by lock. This works because count can only decrease at
			 * this point (all other puts are shut out by lock), and we (or some
			 * other waiting put) are signalled if it ever changes from
			 * capacity. Similarly for all other uses of count in other wait
			 * guards.
			 */
			while (count.get() == capacity) {
				notFull.await(); //绑定putLock
			}
			enqueue(node);
			// 此处 c =size - 1（size为容器实际大小）
			c = count.getAndIncrement(); 
			if (c + 1 < capacity) //c+1 =size-1+1 =size ，如果c + 1 =size < capacity 的话
				notFull.signal(); //唤醒其他生产者生产数据
		} finally {
			putLock.unlock();
		}
		if (c == 0) //c=size-1==0，就是size==1？如果size=1代表还有元素，通知消费者生产数据
			signalNotEmpty(); //notEmpty.signal();
	}

	/**
	 * Signals a waiting take. Called only from put/offer (which do not
	 * otherwise ordinarily lock takeLock.)
	 */
	private void signalNotEmpty() {
		final ReentrantLock takeLock = this.takeLock;
		takeLock.lock();
		try {
			notEmpty.signal(); //绑定takeLock
		} finally {
			takeLock.unlock(); 
		}
	}

	public E take() throws InterruptedException {
		E x;
		int c = -1;
		final AtomicInteger count = this.count;
		final ReentrantLock takeLock = this.takeLock;
		takeLock.lockInterruptibly();
		try {
			while (count.get() == 0) {
				notEmpty.await();  //绑定takeLock
			}
			x = dequeue();
			// 有点绕：获取当前count的值，然后减1。
			c = count.getAndDecrement();
			//而此时由于x = dequeue()代码消费了一个数据，所以c=size+1
			if (c > 1)//当前c=size+1>1的话，则就是size>0.所以此时就是有元素的，唤醒其他消费者消费数据
				notEmpty.signal();  //绑定takeLock
		} finally {
			takeLock.unlock();
		}
		if (c == capacity) //c = size +1 ==capacity 所以size =capacity-1，则容器还没有满，所以通知生产者生产数据
			signalNotFull();  // 调用notFull.signal();
		return x;
	}

	/**
	 * Signals a waiting put. Called only from take/poll.
	 */
	private void signalNotFull() {
		final ReentrantLock putLock = this.putLock;
		putLock.lock();
		try {
			notFull.signal(); //绑定putLock
		} finally {
			putLock.unlock();
		}
	}
}









javartisan
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python条件变量之生产者与消费者操作实例分析
01-21
本文实例讲述了python条件变量之生产者与消费者操作。分享给大家供大家参考，具体如下： 互斥锁是最简单的线程同步机制，面对复杂线程同步问题，Python还提供了Condition对象。Condition被称为条件变量，除了提供与...
生产者消费者问题的三种实现方式（wait/notify，ReentrantLock，BlockingQueue）——Java
Stay Hungry Stay Foolish
08-22 720
使用wait，notify package com.tju.edu.frank; //多生产者多消费者问题 //if判断标记，只有一次，会导致不该运行的线程运行了（即同阵营重复运行，造成多生产单消费，或单生产多消费问题）。出现了数据错误的情况。 //while判断标记，解决了线程获取执行权后，是否要运行（解决了上述问题） //notify:只能唤醒一个线程，如果本方唤醒了本方线程，没有意义。而...
Java并行编程-lock中使用多条件condition（生产者消费者模式实例）
热门推荐
记忆力不好的博客
06-05 2万+
Java 并发包下的提供Lock，Lock相对于Synchronized可以更好的解决线程同步问题，更加的灵活和高效，并且ReadWriteLock锁还能实现读、写的分离。但线程间仅仅互斥是不够的，还需要通信，本篇的内容是基于上篇之上，使用Lock如何处理线程通信。阻塞队列(BlockingQueue)就是使用condition的和lock实现的。可以查看：Java并发编程-阻塞队列(Blockin
生产者消费者消费者模式之通过Condition唤醒(和wait、notify模式做对比)
凌夜知惜
05-01 748
下面的代码有详细的注释，通过Condition的方式实现更细粒度的通知! 仔细阅读下面的代码，对多线程的理解有很大的帮助 package com.lyzx.concurrent.lock; import java.util.LinkedList; import java.util.Queue; import java.util.concurrent.locks.Condition; impo
使用wait和notifyAll实现生产者消费者模型
wang704987562的博客
05-07 350
wait和notifyAll是JDK中Object类的两个方法，主要用来线程间通讯，最经典的应用场景就是【生产者-消费者】，下面给出简单示例。/** * @Auothor wzx * @Date 2017/5/7 0007 */ public class ProducerConsumer { public static void main(String[] args) {
Java使用wait和notify实现生产者和消费者
coderate
05-25 7260
1. 使用注意事项 永远在synchronized的函数或对象里使用wait、notify和notifyAll，不然Java虚拟机会生成IllegalMonitorStateException。 永远在while循环里而不是if语句下使用wait。这样，循环会在线程睡眠前后都检查wait的条件，并在条件实际上并未改变的情况下处理唤醒通知。 永远在多线程间共享的对象上使用wait。 notify...
汪文君高并发编程实战视频资源全集
08-08
│ 高并发编程第一阶段28讲、线程生产者消费者的综合实战结合Java8语法.mp4 │ 高并发编程第一阶段29讲、如何实现一个自己的显式锁Lock精讲上.mp4 │ 高并发编程第一阶段30讲、如何实现一个自己的显式锁Lock精讲...
汪文君高并发编程实战视频资源下载.txt
08-08
│ 高并发编程第一阶段28讲、线程生产者消费者的综合实战结合Java8语法.mp4 │ 高并发编程第一阶段29讲、如何实现一个自己的显式锁Lock精讲上.mp4 │ 高并发编程第一阶段30讲、如何实现一个自己的显式锁Lock精讲...
Java并发编程原理与实战
08-14
使用Condition重写waitnotify案例并实现一个有界队列.mp4 深入解析Condition源码.mp4 实战：简易数据连接池.mp4 线程之间通信之join应用与实现原理剖析.mp4 ThreadLocal 使用及实现原理.mp4 并发工具类...
java并发编程
03-22
第30节通过生产者消费者模型理解等待唤醒机制00:20:50分钟 | 第31节Condition的使用及原理解析00:17:40分钟 | 第32节使用Condition重写wait/notify案例并实现一个有界队列00:22:05分钟 | 第33节深入解析Condition...
java多线程实现生产者消费者问题
weixin_44991304的博客
03-29 924
wait/notify机制实现原理 在使用wait/notify方法前我们需要对这两个方法进行简单的介绍： 使用wait/notify方法前提是拥有相同锁的线程才可以实现此机制。 1）wait方法是object的方法，他的作用是使当前执行wait方法的线程等待，在wait方法后面的代码暂停执行，并且释放锁，直到接到通知或被中断为止。在调用wait方法前，线程必须获得该对象的对象级别的锁，即只能在同步方法或同步代码块中调用wait方法。如果调用wait方法时没有适当的锁会抛出IllegalMonitorSta
精通Java多线程学习（五）用Lock和condition实现生产者与消费者
qq_21963133的博客
03-21 244
需求：实现生产一个消费一个。定义一个保存资源的类Res：class Resource{ private String name; private int count = 1; private boolean flag = false; private Lock lock = new ReentrantLock(); private Condition con...
java wait()/notify() 实现生产者消费者模式
ZK_小小世界的专栏
08-18 6285
java中的多线程会涉及到线程间通信，常见的线程通信方式，例如共享变量、管道流等，这里我们要实现生产者消费者模式，也需要涉及到线程通信，不过这里我们用到了java中的wait()、notify()方法： wait()：进入临界区的线程在运行到一部分后，发现进行后面的任务所需的资源还没有准备充分，所以调用wait()方法，让线程阻塞，等待资源，同时释放临界区的锁，此时线程的状态也从RUNNABLE
如何在 Java 中正确使用 wait, notify 和 notifyAll
极北三少
08-05 2705
wait, notify 和 notifyAll，这些在多线程中被经常用到的保留关键字，在实际开发的时候很多时候却并没有被大家重视。本文对这些关键字的使用进行了描述。 在 Java 中可以用 wait、notify 和 notifyAll 来实现线程间的通信。。举个例子，如果你的Java程序中有两个线程——即生产者和消费者，那么生产者可以通知消费者，让消费者开始消耗数据，因为队列缓冲区中有内
sleep、wait以及notify方法区别于联系
LLLLEE 的博客
01-22 1768
前言  本文基于源码注释的解读，对sleep、wait、notify方法进行学习与了解。 另外，文章中出现了“持有对象锁，释放对象锁”的描述，之所以对对象进行加锁，是因为我们讨论问题的背景是多线程。如果多个线程同时对一个变量进行操作，有可能发生意想不到的情形，因此我们需要对对象先进行加锁，再进行操作。既然有加锁这一操作，当然也就有释放锁这一操作。 sleep方法 Thread类中的
【Java基础】-- 线程同步举例：生产者消费者（通过Object类提供的wait()、notify()、notifyAll()实现）
HuLuoBo
04-21 160
一 线程同步和互斥 1 互斥：是指某一个资源某个时刻只允许一个访问者对其进行访问，具有唯一性和排他性。 2 同步：在互斥的基础上，通过其他机制实现访问者对资源的有序访问，通过一定的逻辑关系来共同完成一个任务。 3 同步和互斥的联系：同步其实已经实现了互斥，所以同步是一种更为复杂的互斥。 4 同步和互斥的区别： （1）互斥是不同线程通过竞争进入临界区（共享的数据和硬件资源），为了防止冲突，在同一时刻只允许一个线程使用共享资源，如不能同时写。 （2）同步时多个线程彼此合作，通过一定的逻辑关系来共同完
关于LinkedBlockingQueue中notEmpty和notFull-Condition的一点困惑
靡不有初，鲜克有终。
07-11 2523
/** * Inserts the specified element at the tail of this queue, waiting if * necessary for space to become available. */ public void put(E e) throws InterruptedException { i...
java生产者与,用 Java 实现生产者和消费者的三种方法
weixin_35792040的博客
03-10 82
生产者消费者问题是多线程的一个经典问题，它描述是有一块缓冲区作为仓库，生产者可以将产品放入仓库，消费者则可以从仓库中取走产品。在Java中有四种方法支持同步，其中前三个是同步方法，一个是管道方法。wait() / notify()方法await() / signal()方法BlockingQueue阻塞队列方法wait() / notify()方法wait() / nofity()方法是基类Obj...
Java多线程-生产者消费者例子-使用Lock实现
wisgood的专栏
03-28 2007
import java.util.LinkedList; import java.util.List; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * Create...
多线程生产者与消费者
最新发布
10-15
多线程生产者与消费者问题是一个经典的并发编程问题，主要涉及到线程间的同步和互斥。在这个问题中，有一个生产者线程和一个消费者线程，它们共享一个缓冲区。生产者线程负责往缓冲区中生产数据，而消费者线程则负责...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值