生产者与消费者问题，java实现

import java.util.concurrent.Semaphore;

public class OSTest01 {
public static void main(String[] args) {
// 启动线程
for (int i = 0; i <= 3; i++) {
// 生产者线程
new Thread(new Producer()).start();
// 消费者线程
new Thread(new Consumer()).start();
}
}

// 仓库
static Warehouse buffer = new Warehouse();

// 生产者，负责增加
static class Producer implements Runnable {
static int num = 1;
//重写父类的run（）方法
public void run() {
int n = num++;
while (true) {
try {
buffer.put(n);
System.out.println(Thread.currentThread().getName()+"--------------------produce线程: " + n);
// 速度较快。休息10毫秒
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

// 消费者，负责减少
static class Consumer implements Runnable {
//重写父类的run（）方法
public void run() {
while (true) {
try {
System.out.println(Thread.currentThread().getName()+"-----consume线程: " + buffer.take());
// 速度较慢，休息1000毫秒
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//仓库类
static class Warehouse {
// 非满信号量
final Semaphore notFull = new Semaphore(10);
// 非空信号量
final Semaphore notEmpty = new Semaphore(0);
// 互斥信号量
final Semaphore mutex = new Semaphore(1);
// 库存容量
final Object[] items = new Object[10];
int putptr, takeptr, count;

//把商品放进仓库
public void put(Object x) throws InterruptedException {
// 保证非满
notFull.acquire();
// 保证不冲突
mutex.acquire();
try {
// 增加库存
items[putptr] = x;

if (++putptr == items.length)  {

putptr = 0;
}
++count;
} finally {
// 退出临界区
mutex.release();
// 增加非空信号量，允许获取商品
notEmpty.release();
}
}

//从仓库取出商品
public Object take() throws InterruptedException {
// 保证非空
notEmpty.acquire();
// 临界区
mutex.acquire();
try {
// 减少库存
Object x = items[takeptr];
if (++takeptr == items.length)
takeptr = 0;
--count;
return x;
} finally {
// 退出临界区
mutex.release();
// 增加非满的信号量，允许加入商品
notFull.release();
}
}
}
}

输出结果解释：

8个线程，其中0，2，4，6为生产者线程，1，3，5，7为消费者线程，

生产前四个和消费前四个几乎是同时进行的，这些线程优先级是相同的，因此前八个输出顺序不固定的。

生产完后每个线程休眠10ms，而消费完后每个线程休眠1000ms,所以这时候只有生产者线程在运行，由于仓库有10个，所以生产者线程会生产十个，这时候由于非满信号量notFull变成0，非空信号量notEmpty变成10，因此生产者线程会等待消费者线程进行消费，当消费者线程休眠1000ms后，便会消费，也就是notEmpty会–，notFull会++，这时候生产者线程便可以继续进行生产，由于优先级一样，所以输出的顺序也是不固定的。