java并发经典案例-生产者与消费者

注：本文面向有一定java基础的用户

 

前置知识

我们都知道java的顶级父对象为超类    java.lang.Object

其中里面有3个跟线程通信的方法为


//注意，以下的方法都需要在synchronized同步块中进行使用，否则会报错，因为实际上锁是存在一个称为对象头的数据结构里面的，有兴趣的话可以自行百度，每个java对象都会有一个对象头

wait(); // 把当前的线程抢到的对象锁释放出来,并挂起自己

notify(); //唤醒一个由于调用wait()方法而被挂起的线程，随机唤醒

notifyAll(); //唤醒全部线程



当某个线程调用了wait()之后如果没有其他人调用对象的notify()或者notifyAll()方法，那么该线程就会被永远挂起直到天荒地老

//一个简单的例子
 Object object = new Object();

        new Thread(() -> {

            System.out.println("调用对象锁的wait方法");
            synchronized (object) {
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("永远不会停止了,因为线程被永远挂起，也没有人可以唤醒它");
}).start();


当然obejct提供了一些重载方法，比如
wait(long timeout)之类的，这里就不细说了，大概意思就是说只挂起线程多久

      Object object = new Object();

        new Thread(() -> {

            System.out.println("调用对象锁的wait方法");
            synchronized (object) {
                try {
                    object.wait(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("1s后自动恢复,因为线程被指定了挂起时间");
        }).start();

 

生成者与消费者的例子

 

package com.zxc.shradingjdbc.juc;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;

public class ThreadTest {

    private static int size = 10;

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

        Queue<Integer> queue = new LinkedList<>();
        Object object = new Object();
        Thread producer = producer(queue, object);
        Thread consumer = consumer(queue, object);

        //注：由于while(true)底层占用cpu的级别非常高，所以可能交替效果不是太明显，
        //可以把size调大点，这个效果就会比较明显了
        producer.start();
        consumer.start();

    }

    public static Thread producer(Queue<Integer> queue, Object object) throws InterruptedException {
        return new Thread(() -> {
           while (true) {
               synchronized (object) {
                   while (queue.size() >= size) {
                       try {
                           object.wait();  //如果队列满了，就挂起当前线程，等待唤醒
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }
                   //往队列里面放数据，同时通知其他线程，这里只有消费者线程，可以进行消费了
                   int nextInt = new Random().nextInt(1000);
                   queue.add(nextInt);
                   System.out.println("生成者--->放数据add=" + nextInt + "size=" + queue.size());
                   object.notifyAll();
               }
           }
        });
    }

    public static Thread consumer(Queue<Integer> queue, Object object) throws InterruptedException {
        return new Thread(() -> {
          while (true) {
              synchronized (object) {
                  while (queue.size() == 0) {
                      {
                          try {
                              object.wait();  //如果队列为空，就挂起当前线程，等待唤醒
                          } catch (InterruptedException e) {
                              e.printStackTrace();
                          }
                      }
                  }
                  //获取数据，并且通知其他线程，这里只有生成者可以进行生产数据了
                  Integer poll = queue.poll();
                  System.out.println("消费者拿数据poll=" + poll + "size=" + queue.size());
                  object.notifyAll();
              }
          }
        });
    }

}

注：最底层的原理需要参考jvm虚拟机实现逻辑，以下的分析是个人的一种看法，并不保证一定是对的，实际上synchronized就是把并发的线程给整成串行的逻辑去处理了，那么必然需要一个数据结构来存储这些要执行的线程，同时需要有对应的唤醒机制


实现的基本原理，从对象锁本身来看待这件事可能就会比较清晰


synchronized 锁的是对象里面一个叫Monitor的对象，可以简单理解为一个属性


对象头里面的大概数据有这2个数据

Monitor  锁对象
waitSet  等待线程集合



比如有线程A,B同时要抢对象的锁

A抢到了以后，那么会进入A线程的代码块，然后执行业务逻辑
B线程此时就会被临时放到waitSet里面去，等待A线程释放锁
当A线程业务执行完毕以后，他就会通知B线程可以去拿锁了


while(加锁) {
    if(成功){
        跳出循环;
    }
    //放入waitset集合里面去   
}

//业务代码数据

//释放锁，通知B线程去重新获取锁，获取成功他就也可以执行自己的业务代码块了




而上面的例子，调用对象的wait方法，实际上就类似于把当前线程放到waitset里面去
调用对象的Notify方法，实际上就是类似于通知waitset里面的线程锁已经被释放，可以去抢锁了