浅谈Java简单实现的生产者与消费者问题

一、面对生产者和消费者的问题，首先我们得明白几点：

生产者：生产数据；
消费者：消费数据。
消费者在没有数据可供消费的情况下，不能消费；
生产者在原数据没有被消费掉的情况下，不能生产新数据。
假设，数据空间只有一个。
实际上，如果实现了正确的生产和消费，则，两个线程应该是严格的交替执行。

synchronized关键字若用在代码中，形成一个同步块，且，必须要执行锁：
    synchronized (锁对象) {
        同步块
    }
同步块使得锁对象称为thread monitor
二、代码实现：

1.首先我们建立一个生产者和消费者共同拥有的锁的类：

package com.mec.about_procuder_customer.core;

public class ProcuderCustomer {
    //初始状态的数据为0个
    protected static volatile int count = 0;
    //执行锁
    protected final static Object lock = new Object();
}

上述代码有一个关键字volatile，它是保证线程之间有序的一种方式,最重要也是最直接的是禁止寄存器优化。就是如果线程run方法中只是一个循环，并没有执行语句，那么，这个线程将不会执行。

2.我们再来建立一个生产者的类：

 

package com.mec.about_procuder_customer.core;

//生产者
public class Procuder extends ProcuderCustomer implements Runnable {
    
    //存放数据的空间
    private int[] dataSpace;
    
    public Procuder(int[] dataSpace, String threadName) {
        this.dataSpace = dataSpace;
        //启动线程
        new Thread(this, threadName).start();
    }
    
    @Override
    public void run() {
        int i = 0;
        
        while (true) {
            synchronized (lock) {
                //判断是否空间已满
                if (count < dataSpace.length) {
                    //产生者放数据
                    dataSpace[count] = i++;
                    System.out.println("[" + Thread.currentThread().getName()
                            + "]线程生产了一个数:" + dataSpace[count++]
                            + " " + count);
                    try {
                        //只是为了看的清楚，沉睡2秒
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //唤醒消费者
                    lock.notify();
                } else {
                    try {
                        //使自己处于阻塞状态
                        lock.wait();
                    } catch (InterruptedException e) {
                    e.printStackTrace();
                    }
                }
            }
        }
    }
}

 

3.建立消费者的类：

package com.mec.about_procuder_customer.core;

//消费者
public class Customer extends ProcuderCustomer implements Runnable {
    //存放数据的空间
    private int[] dataSpace;
    
    public Customer(int[] dataSpace, String threadName) {
        this.dataSpace = dataSpace;
        //启动线程
        new Thread(this, threadName).start();
    }
    
    @Override
    public void run() {
        while (true) {
            //加锁
            synchronized (lock) {
                //判断是否有数据
                if (count > 0) {
                    System.out.println("[" + Thread.currentThread().getName()
                            + "]线程消费了一个数:" + dataSpace[--count]);
                    //唤醒生产者
                    lock.notifyAll();
                } else {
                    try {
                        //使自己处于阻塞状态
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

}

4.测试类：

package com.mec.about_procuder_customer.test;

import com.mec.about_procuder_customer.core.Customer;
import com.mec.about_procuder_customer.core.Procuder;

public class Test {

    public static void main(String[] args) {
        int[] data = new int[10];
        new Procuder(data, "生产者1");
        new Procuder(data, "生产者2");
        new Customer(data, "消费者");
    }

}

运行结果：