生产者消费者问题中的同步机制JAVA设计和实现

目录

• 问题描述
• 问题分析
• 利用记录型信号量解决
  • 运行环境
  • 实现思路
  • 代码实现
  • 运行截图
  • 过程中出现的问题和注意点
• 利用AND信号集解决
  • 运行环境
  • 实现思路
  • 代码实现
  • 运行截图

问题描述

若干进程通过有限的共享缓冲区交换数据。其中，X个“生产者”进程不断写入数据，而Y个“消费者”进程不断读出数据；共享缓冲区共有N个；任何时刻只能有一个进程可对公用缓冲池进行操作。

问题分析

  我们已经知道，这样设计就可以保证先后顺序:对于某一个需要后进行的进程:wait(sth),wait(mutex),signal(mutex),先进行的进程:wait(mutex),signal(mutex),signal(sth)。而本问题也有先后的问题，对于消费者来讲，只有先有货物才可以消费。对于生产者来讲只有有空位才可以生产。所以需要三个信号量，两个(full和empty)用来决定先后顺序，一个是共享共用缓冲池的标志。

  对于生产者(Producer):wait(empty),wait(mutex),其他操作,signal(mutex),signal(full)。

  对于消费者(Consumer):wait(full),wait(mutex),其他操作,signal(mutex),signal(empty)。

利用记录型信号量解决

运行环境

Java SE 12

实现思路

使用Semaphore类。

void acquire(int permits) ：获取指定数目的资源，如果无可用资源将会一直阻塞等待。相当于wait()。

void release(int permits)： 释放指定数目的资源。相当于signal()。

代码实现

final int N=5;//仓库容量
	private static Integer count = 0;//现有资源数目
	final Semaphore empty = new Semaphore(N);//表示空的数目
    final Semaphore full = new Semaphore(0);//表示满的数目
    final Semaphore mutex = new Semaphore(1);
	public static void main(String[] args) {
			TestG test=new TestG();
			new Thread(test.new Producer()).start();
			new Thread(test.new Consumer()).start();
			new Thread(test.new Producer()).start();
			new Thread(test.new Consumer()).start();
			new Thread(test.new Producer()).start();
			new Thread(test.new Producer()).start();
			new Thread(test.new Producer()).start();
			new Thread(test.new Consumer()).start();
	}
	class Producer implements Runnable{
		@Override
		public void run() {
		    for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(3000);//睡眠
                } catch (Exception e) {
                    e.printStackTrace();
                }
                try {
                    empty.acquire(1);//wait(empty)
                    mutex.acquire();//wait(mutex)
                    count++;
                    System.out.println(Thread.currentThread().getName()+ "生产者正在生产，目前总共有" + count);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    mutex.release();//signal(mutex)
                    full.release(1);//signal(full)
                }
            }
		}
	}
	class Consumer implements Runnable{
		@Override
		public void run() {
			for (int i = 0; i < 10; i++) {
				try {
					Thread.sleep(3000);//睡眠
				} catch (Exception e) {
					e.printStackTrace();
				}
				try {
					full.acquire(1);//wait(full)
					mutex.acquire();//wait(mutex)
					count--;
					System.out.println(Thread.currentThread().getName()+ "消费者正在消费，目前还剩" + count);
				} catch (InterruptedException e) {
					e.printStackTrace();
				} finally {
					mutex.release();//signal(mutex)
					empty.release(1);//signal(empty)
				}
			}
		}
	}

运行截图

过程中出现的问题和注意点

因为Semaphore三个信号量都被声明为了final所以一旦被声明不再会改变，所以如果通过构造函数传进来N是不行的，因为在这之前Semaphore已经被声明并且无法更改。

利用AND信号集解决

运行环境

Java SE 12

实现思路

将wait(empty)和wait(mutex)、signal (mutex )和signal (full)、wait (full) 和wait (mutex )、signal (mutex )和signal (empty)结合起来。其实结合起来之后，full和empty就可以用一个标志表示了，在这里我设置为count表示资源数。用synchronized给mutex加锁实现同步。

代码实现

private static  Integer count=0;//表示现有货物资源数目

    private static String mutex = "mutex";//标志资源区（仓库）是不是被占用
	public static void main(String[] args) {
		Test test=new Test();
		new Thread(test.new Producer()).start();
		new Thread(test.new Consumer()).start();
		new Thread(test.new Producer()).start();
		new Thread(test.new Consumer()).start();
		new Thread(test.new Producer()).start();
		new Thread(test.new Consumer()).start();
		new Thread(test.new Producer()).start();
		new Thread(test.new Producer()).start();
		new Thread(test.new Producer()).start();
		new Thread(test.new Consumer()).start();

	}
	class Producer implements Runnable{

		@Override
		public void run() {
		    for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (mutex) {//同步
                    while (count == 10) {//仓库满了
                        try {
                            mutex.wait();//释放mutex的锁
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    //生产
                    count++;
                    System.out.println(Thread.currentThread().getName() + "生产者正在生产,货物共有"+count);
                    mutex.notifyAll();
                }
            }
		}

	}
	class Consumer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (mutex) {//同步
                    while (count == 0) {
                        try {
                            mutex.wait();//释放mutex
                        } catch (Exception e) {
                        }
                    }
                    count--;//消费
                    System.out.println(Thread.currentThread().getName() + "消费者正在消费,货物还剩"+count);
                    mutex.notifyAll();
                }
            }
        }
}

运行截图