Java Semaphone信号量实现生产者消费者逻辑

问题描述：

       一组生产者（Producer）进程和一组消费者（Consumer）进程共享一个初始化为空、大小为n的缓冲区。里面存在的互斥和同步关系如下：

互斥：

• 缓存区是共享资源，因此同一时刻只能有一个进程对其进行修改

同步：

• 只有缓冲区有空位时（empty > 0），生产者才能够生产，把消息放入缓冲区，否则必须等待
• 只有缓冲区存在消息时（full > 0），消费者才能够从缓冲区取走消息进行消费，否则必须等待

问题分析：

缓存类：

设置缓存长度为5，并且在其中设置三个信号量，其中

mutex用来控制互斥地访问和修改buffer里面的值，

empty和full则用来控制生产者和消费者的同步

• empty表示buffer中有多少个空位，只有存在空位，生产者才能够生产，否则阻塞
• full表示buffer中有多少个资源，只有存在资源，消费者才能消费，否则阻塞

import java.util.ArrayList;
import java.util.concurrent.Semaphore;

/**
 * @author LK
 */
public class Buffer {
    final int BUFFER_LENGTH = 5;
    ArrayList<Integer> buffer = new ArrayList<>(BUFFER_LENGTH);
    Semaphore empty = new Semaphore(BUFFER_LENGTH);  // 开始时buffer时空的
    Semaphore full = new Semaphore(0);
    Semaphore mutex = new Semaphore(1);  // 互斥访问buffer
}

 生产者类  与  消费者类：：

这里需要注意的点是：PV操作的顺序问题

P操作（荷兰语proberen，表“试图”），相当于试图拿走、申请资源，对应 semaphone.acquire()

V操作（荷兰语verhogen，表“增加”），相当于释放资源、增加资源，对应 semaphone.release()

 技巧是：

1. 实现互斥的P操作（mutex）必须在实现同步的P操作（empty、full）之后
2. V操作不会导致进程阻塞，所以顺序没有影响

import java.util.Random;

/**
 * @author LK
 */
public class Producer implements Runnable {

    private final Buffer buffer;

    Producer(Buffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        try {
            while(true){
                // 在生产之前，要先判断是否有空闲位置
                buffer.empty.acquire();
                buffer.mutex.acquire();
                produce();
                buffer.mutex.release();
                buffer.full.release();  // 又多了一个
            }

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void produce() throws InterruptedException {
        Thread.sleep(1000);
        int temp = new Random().nextInt(10);
        buffer.buffer.add(temp);
        System.out.println(
                Thread.currentThread().getName() +
                        "生产了" + temp + ", 目前buffer是" +
                        buffer.buffer);
    }
}

/**
 * @author LK
 */
public class Consumer implements Runnable{

    private final Buffer buffer;

    Consumer(Buffer buffer){
        this.buffer = buffer;
    }

    @Override
    public void run() {
        try {
            while(true){
                // 判断buffer中是否有资源
                buffer.full.acquire();
                buffer.mutex.acquire();
                consume();
                buffer.mutex.release();
                buffer.empty.release();  // 又少了一个
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    private void consume() throws InterruptedException {
        Thread.sleep(1000);
        int index = (int)(Math.random() * (buffer.buffer.size() - 1));
        int temp = buffer.buffer.get(index);
        buffer.buffer.remove(index);
        System.out.println(Thread.currentThread().getName() + "消费了" + temp +
                ", 剩余buffer" + buffer.buffer);
    }
}

运行方法： 

/**
 * @author LK
 */
public class Main {
    public static void main(String[] args) {
        Buffer buffer = new Buffer();
        System.out.println("初始化：" + buffer.buffer);

        for(int i = 0; i < 2; i++){
            new Thread(new Producer(buffer), "生产者" + (i + 1)).start();
            new Thread(new Consumer(buffer), "消费者" + (i + 1)).start();
        }
    }
}