java实现的PV操作经典例子：读者写者、贪睡的理发师、生产者消费者。

ゝ一世哀愁。 2023-02-22 12:24 22阅读 0赞

其中读者写者和贪睡的理发师使用的Semaphore类；生产者消费者使用的是管程。

# 读者写者 #

class Semaphore
    {
        int value;
     
        public Semaphore(int v)
        {
            this.value = v;
        }
     
        public synchronized void p()
        {
            value -= 1;
            if (value < 0)
            {
                try
                {
                    wait();
                } catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
        }
     
        public synchronized void v()
        {
            value += 1;
            if (value <= 0)
            {
                this.notify();
            }
        }
    }
     
    class Reader implements Runnable
    {
        int count;
        Semaphore rmutex;
        Semaphore wmutex;
     
        public Reader(int c, Semaphore r, Semaphore w)
        {
            this.count = c;
            this.rmutex = r;
            this.wmutex = w;
        }
     
        public void run()
        {
            while (true)
            {
                rmutex.p();
                if (count == 0)
                {
                    wmutex.p();
                    System.out.println("****************************reader has got lock no writer is allowed*************************");
                    System.out.println("ReaderReaderReaderReader Thread: " + Thread.currentThread().getName()
                            + " current count= " + count);
                }
                count++;
                rmutex.v();
                System.out.println("I AM Reader: " + Thread.currentThread().getName() + " count= " + count + " I am DOING SOME JOB!");
                try
                {
                    Thread.sleep((long) (Math.random() * 1000));
                } catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
                
                rmutex.p();
                count--;
                System.out.println("I AM Reader: " + Thread.currentThread().getName() + " count= " + count + " I am quiting work");
                if (count == 0)
                {
    //                System.out.println(
    //                        "ReaderReaderReaderReader Thread: " + Thread.currentThread().getName() + "give up lock");
                    wmutex.v();
                    
                    System.out.println("****************************readers all give up lock*************************");
                    System.out.println();
                }
                rmutex.v();
                try
                {
                    Thread.sleep((long) (Math.random() * 1000));
                } catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }
     
    class Writer implements Runnable
    {
        Semaphore wmutex;
     
        public Writer(Semaphore w)
        {
            this.wmutex = w;
        }
     
        public void run()
        {
            while (true)
            {
        	
                wmutex.p();
                System.out.println("====================writer has got lock no reader is allowed===================================");
                System.out.println("WriterWriterWriter Thread: " + Thread.currentThread().getName());
                System.out.println("begin writting data...");
                try
                {
                    Thread.sleep((long) (Math.random() * 1000));
                } catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
                System.out.println("finish writting data.");
                
                wmutex.v();
                
                System.out.println("=======================================writer give up lock==========================================");
                System.out.println();
             }
        }
    }
     
    public class ReaderWriter
    {
        public static void main(String[] args)
        {
            int count = 0;
            Semaphore rmutex = new Semaphore(1);
            Semaphore wmutex = new Semaphore(1);
            Reader reader = new Reader(count, rmutex, wmutex);
            Writer writer = new Writer(wmutex);
            Thread r1 = new Thread(reader);
            Thread r2 = new Thread(reader);
            Thread w1 = new Thread(writer);
            Thread w2 = new Thread(writer);
            w1.start();
            r1.start();
            w2.start();
            try
            {
                Thread.sleep(1000);
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            r2.start();
        }
    }

# 贪睡的理发师 #

class Semaphore{
    	int value;
    	public Semaphore(int v) {
    		this.value = v;
    	}
    	public synchronized void p() {
    		value--;
    		if(value < 0) {
    			try {
    				wait();
    			}catch(InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    	public synchronized void v() {
    		value++;
    		if(value <= 0) {
    			notifyAll();
    		}
    	}
    }
     
     
    class Customer implements Runnable{
    	Semaphore mutex;
    	Semaphore customer;
    	Semaphore barber;
    	int index;
    	
    	public Customer(int index, Semaphore mutex, Semaphore customer, Semaphore barber) {
    		this.index = index;
    		this.mutex = mutex;
    		this.customer = customer;
    		this.barber = barber;
    	}
    	public void run() {
    		mutex.p();
    		if(BC.count >= BC.MAX) {
    			System.out.println("椅子已经坐满，顾客" + index + " 离开");
    			mutex.v();
    		}else {
    			BC.count++;
    			customer.v(); // 通知理发师等待理发人数加1
    			mutex.v();
    			barber.p();		// 抢夺理发师
    			
    			System.out.println("顾客" + index + " 开始理发");
    //			System.out.println("顾客： " + Thread.currentThread().getName().toString() + " 正在理发");
    			
    		}
    	}
    }
     
    class Barbe implements Runnable{
    	Semaphore mutex;
    	Semaphore customer;
    	Semaphore barber;
    	
    	public Barbe(Semaphore mutex, Semaphore customer, Semaphore barber) {
    		this.mutex = mutex;
    		this.customer = customer;
    		this.barber = barber;
    	}
    	public void run() {
    		while(true) {
    			customer.p();
    			mutex.p();
    			BC.count--;
    			barber.v();
    			mutex.v();
    			System.out.println(" 理发师理发");
    			try {
    				Thread.sleep((long)(Math.random() * 1000));
    			}catch(InterruptedException e) {
    				e.printStackTrace();
    			}
    			
    		}
    	}
    }
     
     
    public class BC{
    	static int count;
    	static int MAX = 5;
    	static Semaphore mutex = new Semaphore(1); 
    	static Semaphore barber = new Semaphore(1);
    	static Semaphore customer = new Semaphore(0);
    	
    	public static void main(String[] args) {
    		Barbe bar = new Barbe(mutex, customer, barber);
    		Thread b1 = new Thread(bar);
    		b1.start();
    		int n = 10;
    		for(int i=0;i<n;i++) {
    			Customer cus = new Customer(i, mutex, customer, barber);
    			Thread t = new Thread(cus);
    			t.start();
    			System.out.println("顾客: " + i + " 等待理发");
    			try {
    				Thread.sleep((long)(Math.random() * 2000));
    			}catch(InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    	
    }

# 监控器实现的是生产者消费者 #

什么是监控器？

监控器每次只能由一个线程访问；对共享变量的访问只能发生在监控器内定义的过程中。

import java.util.Vector;
     
     
    class CP{
    	Vector pool;
    	int product = 0; // 产品数量
    	public static int EMPTY = 0;
    	public static int FULL = 25;
    	public CP() {
    		pool = new Vector();
    	}
    	public synchronized void produce() {
    		try {
    			if(pool.size() == FULL)
    				wait();
    			product++;
    			pool.addElement(new Integer(product));
    			// 把产品放到产品池中
    			System.out.println("Produce: " + product);
    			if(pool.size() == EMPTY + 1)
    				notify();
    		}catch(InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    	public synchronized void consume() {
    		try {
    			if(pool.size() == EMPTY)
    				wait();
    			System.out.println("Consume: " + pool.firstElement().toString());
    			pool.removeElementAt(0);
    			if(pool.size() == FULL - 1)
    				notify();
    		}catch(InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    }
     
     
    class Producer extends Thread{
    	CP cp;
    	public Producer(CP cp) {
    		super();
    		this.cp = cp;
    	}
    	public void run() {
    		while(true) {
    			cp.produce();
    			//模拟做其他工作
    			try {
    				Thread.sleep((long)(Math.random()* 1000));
    			}catch(InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    }
     
     
    class Consumer extends Thread{
    	CP cp;
    	public Consumer(CP cp) {
    		super();
    		this.cp = cp;
    	}
    	public void run() {
    		while(true) {
    			cp.consume();
    			//模拟做其他事情
    			try {
    				Thread.sleep((long)(Math.random() * 1000));
    			}catch(InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    }
     
     
    public class ProducerConsumer{
    	public static void main(String[] args) {
    		CP cp = new CP();
    		Producer producer = new Producer(cp);
    		Consumer consumer = new Consumer(cp);
    		producer.start();
    		consumer.start();
    	}
    }