Java实现PV操作 | 生产者与消费者

• 导语

在学习操作系统的过程中，PV操作是很重要的一个环节。然而面对书本上枯燥的代码，每一个爱好技术的人总是想能亲自去实现。现在我要推出一个专题，专门讲述如何用Java实现PV操作，让操作系统背后的逻辑跃然屏上。

如有错误，请广大网友斧正，感激不尽！

---

经典问题1、生产者与消费者

 

• PV操作数据结构的构建

在书本上，我们给出了一种数据结构，叫做信号量。这种信号量有两个元素：

　　一个是count，如果是正值则表示当前资源的个数，如果是0，表示有一个进程在执行临界区的代码（也就是说这个进程位于临界区）；并且没有进程处于阻塞队列中。如果是负值，这个值的绝对值（abs(count)）表示阻塞队列中进程的个数。

　　一个是queue，即为阻塞进程队列。当进程不能申请相应的资源是，则使用P操作，将自己插入阻塞队列中。当运行的进程执行完临界区代码时，就执行V操作，唤醒一个阻塞队列中的进程。

现在我们定义一个PV操作类：syn。在这个类中我们可以通过构造函数设置count的值。可以看到这个类中并没有阻塞进程所在的queue，我是通过java的this.wait()与this.notifyAll()来实现的。

并且，通过关键字【synchronized】，保证了PV操作是一条【原语】，即在运行过程中，占有完整的一个时间片，不可分割。

 class syn{//PV操作类
     int count=0;//信号量
     syn(){}
     syn(int a){count=a;}
     public synchronized void Wait(){ //关键字 synchronized 保证了此操作是一条【原语】
         count--;
         if(count<0){//等于0 ：有一个进程进入了临界区
             try {         //小于0：abs(count)=阻塞的进程数目
                 this.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
     public synchronized void Signal(){   //关键字 synchronized 保证了此操作是一条【原语】
         count++;
         if(count<=0){//如果有进程阻塞
             this.notify();
         }
     }
 }

注1：P操作wait中，应为if(count<0)而不是while(count<0) 。在后续的编写中，发现如果引入了多个生产者与消费者，用语句while(count<0) 就会出错。

注2：V操作signal中，应为this.notify()而不是this.notifyAll()。也就是说只需要从阻塞队列中唤醒一个进程。

---

• 单个生产者与消费者的模型构建

我们构建实现了Runnable接口的生产者类和消费者类，使用empty（表示空缓冲区的数目）和full（表示满缓冲区的数目）两个信号量来实现进程的同步。（不同类型的进程共享某一资源为同步关系）

代码如下：

 public class Main {

     public static void main(String[] args) {
         Producer p=new Producer();
         Consumer c=new Consumer();
         Thread pp=new Thread(p);
         Thread cp=new Thread(c);
         pp.start();
         cp.start();
     }
 }

 class Global{
     static syn empty=new syn(8);
     static syn full=new syn(0);
     static int buffer []=new int[8];//缓冲区
 }

 //生产者类
 class Producer implements Runnable{
     int count=0;
     public void run(){
         while(count<20){
             Global.empty.Wait();
             //临界区
             int index=count%8;
             Global.buffer[index]=count;
             System.out.println("生产者在缓冲区"+index+"中生产了物品"+count);
             count++;
             try {
                 Thread.sleep(10);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             // end of 临界区
             Global.full.Signal();
         }
     }
 }

 //消费者类
 class Consumer implements Runnable{
     int count=0;
     public void run(){
         while(count<20){
             Global.full.Wait();
             //临界区
             int index=count%8;
             int value=Global.buffer[index];
             System.out.println("消费者在缓冲区"+index+"中消费了物品"+value);
             count++;
             try {
                 Thread.sleep(10);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             // end of 临界区
             Global.empty.Signal();
         }
     }
 }

运行结果：

可以看出进程严格按照先生产再消费的顺序，完美运行。

---

• 引入多个生产者与消费者

为保证同一类进程在进行访问时能保证互斥（互斥是同类进程共享某一资源时的方式）我们引入mutex信号量。

    static syn pMutex=new syn(1);//保证生产者之间互斥
    static syn cMutex=new syn(1);//保证消费者之间互斥

运行结果：

可见程序完美运行。

---

完整Java代码：

 public class Main {

     public static void main(String[] args) {
         Producer p[]=new Producer[3];//3个生产者
         Consumer c[]=new Consumer[3];
         int i;

         for(i=0;i<3;i++){
             p[i]=new Producer(i+1);
         }
         for(i=0;i<3;i++){
             c[i]=new Consumer(i+1);
         }

         Thread pp[]=new Thread[3];
         Thread cp[]=new Thread[3];

         for(i=0;i<3;i++){
             pp[i]=new Thread(p[i]);
         }
         for(i=0;i<3;i++){
             cp[i]=new Thread(c[i]);
         }

         for(i=0;i<3;i++){
             pp[i].start();
         }
         for(i=0;i<3;i++){
             cp[i].start();
         }

     }
 }

 class Global{
     static syn empty=new syn(8);
     static syn full=new syn(0);
     static syn pMutex=new syn(1);//保证生产者之间互斥
     static syn cMutex=new syn(1);//保证消费者之间互斥
     static int buffer []=new int[8];//缓冲区
     static int pCount=0;
     static int cCount=0;
 }

 //生产者类
 class Producer implements Runnable{
     int ID=0;
     Producer(){}
     Producer(int id){ID=id;}
     public void run(){
         while(Global.pCount<20){
             Global.empty.Wait();
             Global.pMutex.Wait();
             //临界区
             int index=Global.pCount%8;
             Global.buffer[index]=Global.pCount;
             System.out.println("生产者"+ID+"在缓冲区"+index+"中生产了物品"+Global.pCount);
             Global.pCount++;
             try {
                 Thread.sleep(10);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             // end of 临界区
             Global.pMutex.Signal();
             Global.full.Signal();
         }
     }
 }

 //消费者类
 class Consumer implements Runnable{
     int ID=0;
     Consumer(){}
     Consumer(int id){ID=id;}
     public void run(){
         while(Global.cCount<20){
             Global.full.Wait();
             Global.cMutex.Wait();
             //临界区
             int index=Global.cCount%8;
             int value=Global.buffer[index];
             System.out.println("消费者"+ID+"在缓冲区"+index+"中消费了物品"+value);
             Global.cCount++;
             try {
                 Thread.sleep(10);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             // end of 临界区
             Global.cMutex.Signal();
             Global.empty.Signal();
         }
     }
 }

 class syn{//PV操作类
     int count=0;//信号量
     syn(){}
     syn(int a){count=a;}
     public synchronized void Wait(){ //关键字 synchronized 保证了此操作是一条【原语】
         count--;
         if(count<0){//等于0 ：有一个进程进入了临界区
             try {         //小于0：abs(count)=阻塞的进程数目
                 this.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
     public synchronized void Signal(){   //关键字 synchronized 保证了此操作是一条【原语】
         count++;
         if(count<=0){//如果有进程阻塞
             this.notify();//All
         }
     }
 }