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
        }
    }  
}