一. 用synchronized+wait+notify实现消费者跟生产者线程同步，库存扣减
1. 注意细节，使用wait,notify时，线程首先得获取锁。
2. 调用wait方法后，线程状态由Running转换为Waiting，并把当前线程放入等待队列
3. 调用notify或者NotifyAll后，调用线程释放锁后，被唤醒得线程才会被挪到同步队列争抢锁
4. 调用wait后，线程会阻塞在wait方法这里，后续获取锁后，会继续从这里开始执行
5. 调用wait后，会释放对象的锁
public class Test1 {
private Object object = new Object();
private int count;
public void producer(String threadName) throws InterruptedException {
//生产者判断库存数量，小于2时，进行生产，增加库存数量
//死循环可以一直检查条件变量，在这个里面就是count
//库存充足时，notify通知在对象上等待的线程，然后阻塞在wait方法这里
synchronized (object){
String str = threadName+":生产-"+Thread.currentThread().getId();
for(;;){
System.out.println(str+"当前库存值为："+count);
if(count < 2){
System.out.println(str+"库存不足***");
count++;
System.out.println(str+"生产后当前库存为："+count);
}else {
System.out.println(str+"通知消费notifyAll***");
object.notifyAll();
System.out.println(str+"[生产者wait]***");
object.wait();
System.out.println(str+"被唤醒*************************************************");
}
}
}
}
public void consumer(String threadName) throws InterruptedException {
String str = threadName+":消费-"+Thread.currentThread().getId();
//消费者这里一直检查库存，不足时，通知生产者。
//调用wait方法，进行阻塞暂停消费
synchronized(object){
for(;;){
System.out.println(str+"当前库存值为："+count);
if(count > 0){
System.out.println(str+"可以消费，当前库存为："+count);
count--;
System.out.println(str+"消费后，当前库存为："+count);
}else{
System.out.println(str+"库存不足，通知生产者###");
object.notifyAll();
System.out.println(str+"[消费者wait]###");
object.wait();
System.out.println(str+"被唤醒################################################");
}
}
}
}
public static void main(String[] args) {
Test1 test1 = new Test1();
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
try {
test1.producer("线程一");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"线程一");
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
try {
test1.consumer("线程二");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"线程二");
thread1.start();
thread2.start();
}
}
执行结果
//线程二:消费-15当前库存值为：2
//线程二:消费-15可以消费，当前库存为：2
//线程二:消费-15消费后，当前库存为：1
//线程二:消费-15当前库存值为：1
//线程二:消费-15可以消费，当前库存为：1
//线程二:消费-15消费后，当前库存为：0
//线程二:消费-15当前库存值为：0
//线程二:消费-15库存不足，通知生产者###
//线程二:消费-15[消费者wait]###
//线程一:生产-14被唤醒*************************************************
//线程一:生产-14当前库存值为：0
//线程一:生产-14库存不足***
//线程一:生产-14生产后当前库存为：1
//线程一:生产-14当前库存值为：1
//线程一:生产-14库存不足***
//线程一:生产-14生产后当前库存为：2
//线程一:生产-14当前库存值为：2
//线程一:生产-14通知消费notifyAll***
//线程一:生产-14[生产者wait]***
//线程二:消费-15被唤醒################################################
//线程二:消费-15当前库存值为：2
//线程二:消费-15可以消费，当前库存为：2
//线程二:消费-15消费后，当前库存为：1
//线程二:消费-15当前库存值为：1
//线程二:消费-15可以消费，当前库存为：1
//线程二:消费-15消费后，当前库存为：0
//线程二:消费-15当前库存值为：0
//线程二:消费-15库存不足，通知生产者###
//线程二:消费-15[消费者wait]###
//线程一:生产-14被唤醒*************************************************
//线程一:生产-14当前库存值为：0
//线程一:生产-14库存不足***
//线程一:生产-14生产后当前库存为：1
//线程一:生产-14当前库存值为：1
//线程一:生产-14库存不足***
//线程一:生产-14生产后当前库存为：2
//线程一:生产-14当前库存值为：2
//线程一:生产-14通知消费notifyAll***
//线程一:生产-14[生产者wait]***
//线程二:消费-15被唤醒################################################
//线程二:消费-15当前库存值为：2
//线程二:消费-15可以消费，当前库存为：2
//线程二:消费-15消费后，当前库存为：1
//线程二:消费-15当前库存值为：1
//线程二:消费-15可以消费，当前库存为：1
//线程二:消费-15消费后，当前库存为：0
//线程二:消费-15当前库存值为：0
//线程二:消费-15库存不足，通知生产者###
//线程二:消费-15[消费者wait]###
二. synchronized+wait+notify实现线程交替打印
线程1：【1，2，3，4】 线程2：【A,B,C,D】
输出：1A 2B 3C 4D
public class Test2 {
public synchronized void printNum() throws InterruptedException {
int[] array = new int[]{1,2,3,4};
for (int i = 0; i < 4; i++) {
//打印数字
System.out.print(array[i]);
//唤醒Test2 实例对象上的阻塞线程
notifyAll();
//当前线程进行阻塞或者说阻塞再此方法上(需要注意，线程被其它线程唤醒后，会开始从wait方法执行)
//切记，最开始学习时在这边吃了不少亏
//循环检查条件变量。
wait();
}
}
public synchronized void printChar() throws InterruptedException {
char[] chars = new char[]{'A','B','C','D'};
for (int i = 0; i < 4; i++) {
//打印字符
System.out.print(chars[i]);
//打印完成后，唤醒阻塞在此对象上的线程
notifyAll();
//当前线程进入阻塞队列，
//进入队列后，那就是等待被唤醒。唤醒后从wait方法后开始执行
wait();
}
}
public static void main(String[] args) {
Test2 test2 = new Test2();
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
try {
test2.printNum();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"线程一");
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
try {
test2.printChar();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"线程二");
thread1.start();
thread2.start();
}
}
//打印完成后，会发现程序一直在运行，但是又没有任何输出，这是为什么呢？线程2还在等待队列，等待唤醒。
//线程2打印字符，最后一次打印完成后，通知线程1并且阻塞自己。
//线程1从wait方法唤醒后，for循环执行完毕，直接退出方法啦，所以线程2一直是waiting状态
//所以程序一直未结束，有那么一句话，想和你一起到白头，你却偷偷焗了油，是不是。
//解决办法就是, 线程1退出循环后，在进行一次notify通知。唤醒线程2也结束执行！
三. synchronized+wait+notify线程交替打印2
线程1：【1，2，3，4....】 线程2：【A,B,C,D....】
输出：12A 34B 56C 78D 910E 1112F 1314G 1516H 1718I
public class Test3 {
private Object object = new Object();
// public void printNum() throws InterruptedException {
// int[] nums = new int[]{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18};
// synchronized (object){
// for(int i = 0;i<nums.length;i++){
// System.out.println(nums[i]);
// if(nums[i] % 2 == 0){
// object.notifyAll();
// object.wait();
// }
// }
// }
// }
public void printNum() throws InterruptedException {
int[] nums = new int[]{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18};
synchronized (object){
for(int i = 0;i<nums.length;i++){
System.out.print(nums[i]);
if(i % 2 !=0){
object.notifyAll();
object.wait();
}
}
}
}
public void printChar() throws InterruptedException {
char[] chars = new char[]{'A','B','C','D','E','F','G','H','I'};
synchronized (object){
for(int i = 0;i<chars.length;i++){
System.out.print(chars[i]+" ");
object.notifyAll();
object.wait();
}
}
}
public static void main(String[] args) {
Test3 test3 = new Test3();
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
try {
test3.printNum();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"线程一");
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
try {
test3.printChar();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"线程二");
thread1.start();
thread2.start();
}
}
最后这个我就不解释啦。直接运行代码吧。
后续出个Lock+Condition实现等待通知
