package reentrantlock;
import java.util.ArrayList;
public class ProviderAndConsumerTest {
static ProviderAndConsumer providerAndConsumer = new ProviderAndConsumer();
public static void main(String[] args) throws InterruptedException {
// new Thread(new GetRunnable(), "消费者002").start();
// Thread.sleep(1000);
// new Thread(new PutRunnable(), "生产者001").start();
ArrayList<Thread> provider = new ArrayList<>();
for (int i = 0; i < 3; i++){
provider.add(new Thread(new PutRunnable(), "生产者00"+ (i+1)));
}
ArrayList<Thread> consumer = new ArrayList<>();
for (int i = 0; i < 3; i++){
consumer.add(new Thread(new GetRunnable(), " 消费者--99"+ (i+1)));
}
for (Thread i :
consumer) {
i.start();
}
// 先让消费者线程全部饥饿，进入消费者条件队列中
Thread.sleep(10000);
for (Thread i :
provider) {
i.start();
}
}
static class PutRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 3; i++){
providerAndConsumer.put(" (" +Thread.currentThread().getName() + "_data_" + i + ")");
try {
// 调整睡眠时间，等同于调整生产者生产数据的频率，但是不准，因为跟生产者内部逻辑执行时间有很大关系
Thread.sleep(500,1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
static class GetRunnable implements Runnable{
@Override
public void run() {
while(true){
providerAndConsumer.get();
try {
// 调整睡眠时间，等同于调整消费者消费数据的频率，但是不准，因为跟消费者内部执行时间有很大关系
Thread.sleep(10,1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
package reentrantlock; import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock; public class ProviderAndConsumer { ReentrantLock reentrantLock = new ReentrantLock();
Condition notEmpty = reentrantLock.newCondition();
Condition notFull = reentrantLock.newCondition();
int maxSize = 3;
int putIndex = 0;
int getIndex = 0;
int realDataCount = 0;
Object[] queue = new Object[maxSize]; boolean isConsumerWait = false;
boolean isProviderWait = false; public void put(Object data){
System.out.println(Thread.currentThread().getName() + "线程，-----尝试加锁-----");
reentrantLock.lock();
System.out.println(Thread.currentThread().getName() + "线程，-----加锁成功-----");
try { while (realDataCount == queue.length){
System.out.println(Thread.currentThread().getName() + "线程，-----数据满了，只好等待----" +
"哈哈要进生产者条件队列啦");
isProviderWait = true;
notFull.await();
} queue[putIndex] = data;
realDataCount++; putIndex++;
if (putIndex == queue.length) putIndex = 0;
System.out.println(Thread.currentThread().getName() + "线程，成功生产一个数据=" + data.toString()); if (isConsumerWait){
System.out.println(Thread.currentThread().getName() + "线程，" +
" 未 激活消费者条件队列节点前，获取消费者队列长度"
+ reentrantLock.getWaitQueueLength(notEmpty));
}
notEmpty.signal();
if (isConsumerWait){
int length = reentrantLock.getWaitQueueLength(notEmpty);
if (length == 0){
isConsumerWait = false;
}
System.out.println(Thread.currentThread().getName() + "线程，" +
" 已 激活消费者条件队列节点后，获取消费者队列长度"
+ reentrantLock.getWaitQueueLength(notEmpty));
}
// 调整睡眠时间，等同于调整生产者持有锁的时间
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println(Thread.currentThread().getName() + "线程，成功解锁");
reentrantLock.unlock();
} } public void get(){
System.out.println("\t\t" + Thread.currentThread().getName() + "线程，尝试加锁");
reentrantLock.lock();
System.out.println("\t\t" + Thread.currentThread().getName() + "线程，-----加锁成功----"); try { while (realDataCount == 0){
System.out.println("\t\t" + Thread.currentThread().getName() + "线程，-----没有数据，只好等待----"+
"哈哈 要进消费者条件队列啦");
isConsumerWait = true;
notEmpty.await();
} System.out.println("\t\t" + Thread.currentThread().getName() + "线程，成功消费一个数据=" + queue[getIndex]);
realDataCount--; getIndex++;
if (getIndex == queue.length) getIndex = 0; if (isProviderWait){
System.out.println("\t\t" + Thread.currentThread().getName() + "线程，" +
" 未 激活生产者条件队列节点前，获取生产者队列长度"
+ reentrantLock.getWaitQueueLength(notFull));
}
notFull.signal();
if (isProviderWait){
int length = reentrantLock.getWaitQueueLength(notFull);
if (length == 0){
isProviderWait = false;
}
System.out.println("\t\t" + Thread.currentThread().getName() + "线程，" +
" 已 激活生产者条件队列节点后，获取生产者队列长度"
+ length);
} } catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println("\t\t" + Thread.currentThread().getName() + "线程，成功解锁");
reentrantLock.unlock();
}
} }
跑通上面的例子可以得到一些总结：
1、在生产者-消费者模式下，消费者线程和生产者线程都在抢占cpu，谁抢到cpu谁就得到执行。抢不到的会进入AQS队列。
此时如果有多个线程在抢占不到cpu进入AQS队列时，进入AQS队列的顺序是不可预知的（比如恰好经历线程切换），
但可以保证的是: 一旦在AQS队列里，顺序就是绝对从前往后的。
换句话说，先尝试获取锁的线程在获取不到锁需要进入AQS队列时，不一定就比其他紧接着（也就是说几乎同时，但相对靠后）
尝试获取锁同样获取不到锁需要进入AQS队列要进入队列早。（比如恰好经历线程切换）
2、那什么时候会进入条件队列呢？什么时候出条件对列呢？
当消费者线程获取到cpu，但此时，没有任何数据可供消费，那么当前的这个消费者线程就会释放（完全释放，因为是可重入）锁并让出cpu资源（线程挂起）然后进入消费者条件队列
当接下来有生产者线程得到cpu执行并生产出数据后，生产者线程就会唤醒“消费者条件队列”中的第一个线程，并把第一个线程加入到AQS队列的尾部
对于“生产者条件对列”，跟上面是一个道理。
3、生产者-消费者模式中的数据缓存区，有一个生产者生产指针，指向下一个生产数据应该放的位置，有一个消费者消费指针，指向下一个要消费的数据的位置。
4、永远记住，锁只是一种资源控制方式，任何行为都不能控制cpu在何时切换，以及cpu切换到哪个线程。
ReentratLock和Synchronized对比：
相同点：
1、都是独占锁。synchronized属于隐式锁，编码简单。ReentrantLock需要手动控制加锁解锁，必须配对使用，控制灵活，但是相对技术要求高。
2、都具有可重入性。synchronized可重入简单，用在复杂场景中（比如递归）不需要考虑锁释放的问题。ReentrantLock手动控制，必须配对，在复杂场景中，对技术要求高，否则带来锁不能正确释放的问题。
不同点：
1、灵活性。synchronized属于非公平锁，cpu切换到哪个线程，哪个线程就获得执行。ReentrantLock可灵活配置公平锁、非公平锁。
2、是否可被中断。synchronized不可被中断，一直阻塞。ReentrantLock可被中断，更好的用于解决死锁问题。
3、ReentrantLock使用场景更多。可设置超时时间。可结合条件队列实现 等待-通知机制（例如生产者-消费者模式）