java线程（2）——模拟生产者与消费者

蔚落 2022-07-26 01:46 22阅读 0赞

# **前言：** #

我们都听说过生产者和消费者的例子吧，现在来模拟一下。生产者生产面包，消费者消费面包。假定生产者将生成出来的面包放入篮子中，消费者从篮子中取。这样，当篮子中没有面包时，消费者不能取。当篮子满了以后，消费者不能一直生产。

# 思考： #

使用面向对象的思想进行分析，涉及的事物有：生产者、消费者、篮子和面包。两个线程有：生产者的生产行为、消费者的消费行为。

Bread面包类

class Bread{
    	int id;
    	Bread(int id){
    		this.id=id;
    	}
    	public String toString(){
    		return "Bread:"+id;
    	}
    }

SyncStack篮子类

在篮子中，一般先放入的面包最后才取出，因此这里可以模拟数据结构栈的操作，提供了两个方法push()和pop()。

这里，假定篮子的最大容量为6个面包。

class SyncStack{
    	int index=0;
    	Bread[] arrWT=new Bread[6];
    	
    	//1、放入
    	public synchronized void push(Bread wt){
    		//装满了
    		//if(index==arrWT.length){  防止发生异常之后，篮子满了仍然生成出现问题
    		while(index==arrWT.length){
    			try {
    				this.wait();
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    		//叫醒wait中的线程
    		this.notify();
    		//this.notifyAll(); //叫醒所有
    		arrWT[index]=wt;
    		index++;
    	}
    	
    	//2、拿出
    	public synchronized Bread pop(){
    		//篮子空了
    		while(index==0){
    			try {
    				this.wait();
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    		this.notify();
    		index--;
    		return arrWT[index];
    	};
    }

生产者和消费者

终于轮到线程类出场了！生产者Producer实现如下，消费者Consumer类也十分类似，只是不再具备生产面包的功能，并且将push方法换成了pop，在这里就不展示了。

class Producer implements Runnable{
    //持有框的引用
    	SyncStack ss=null;
    	Producer(SyncStack ss){
    		this.ss=ss;
    	}
    	@Override
    	public void run() {
    		for (int i = 1; i < 20; i++) {
    			Bread wt=new Bread(i);
    			//扔到框里
    			ss.push(wt);
    			System.out.println("producer:"+wt);
    			try {
    				Thread.sleep((long) (Math.random()*1000));
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    		
    	}
    	
    }

测试：

这里我们简单的测试一下，一个生产者和一个消费者。

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

执行结果：

基本符合前面的要求  
![20160406101047147][]

# 分析： #

**1、synchronized**

一种同步锁，可以修饰代码块、方法等。当一个线程访问其修饰的内容时，视图访问该对象的线程将被阻塞。举个小例子：

/**
     * 获得当前时间
     */
    	public synchronized static void getTime() {
    		System.out.println("1、进入获取时间方法=====");
    		Date date = new Date();
    		DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		String time = format.format(date);
    		System.out.println("2、"+Thread.currentThread().getName() + ":" + time);
    		System.out.println("3、获取时间成功=====");
    		System.out.println();
    	}

我们启100次线程去调用他，在没有加synchronized关键字时，截取部分打印结果如下图：

![20160406103119733][]

![20160406103128796][]

加上关键字之后，打印结果如下：

![20160406103224687][]

可以很容易看出，在该方法前加上synchronized关键字之后，其他线程如果想继续访问，就会被阻塞，等待该线程执行结束后，其他线程才可以继续访问。

在上面消费者和生成者的例子中，我们在SyncStack的push和pop方法前都加上了synchronized关键字，就是为了保证“放”和“取”的原子性，这样模拟的结果才是合理的。

那么有人可能会问，生产者生产馒头和消费者消费馒头是否需要保持原子性，同一时间只允许一个线程执行呢？结合实际情况，可能有多个生产者、消费者同时进行操作，因此，这里不应做限制。

**2、sleep()和wait()**

在上面的例子中，Producer和Consumer内部使用的Thread.sleep()方法，而在SyncStack中的push和pop中却是用的wait()方法。这两个方法看似功能类似，有什么差别呢？

首先，翻到他们的根去看定义。注释看不懂可以先不看，不过注释就把他们的区别都说明白了。

wait()

public class Object {
    
     /**
         * Causes the current thread to wait until another thread invokes the
         * {@link java.lang.Object#notify()} method or the
         * {@link java.lang.Object#notifyAll()} method for this object.
         * In other words, this method behaves exactly as if it simply
         * performs the call {@code wait(0)}.
         * <p>
         * The current thread must own this object's monitor.
    	*/
         public final void wait() throws InterruptedException {
        <span style="white-space:pre">	wait(0);</span>
        }
    }

sleep()

public
    class Thread implements Runnable {
     /**
         * Causes the currently executing thread to sleep (temporarily cease
         * execution) for the specified number of milliseconds, subject to
         * the precision and accuracy of system timers and schedulers. The thread
         * does not lose ownership of any monitors.
         */
     public static native void sleep(long millis) throws InterruptedException;
     }

**先说点肤浅的差别：**

wait()是Object类中的方法，sleep()是Thread类中的。sleep必须指明挂起或睡眠的时间，而wait不需要。

**上面注释中说的：**

sleep()方法——占着CPU睡觉：CPU部分资源别占用，其他线程无法进入，但并不会失去他的监控，等到指定时间到了以后，继续恢复执行。

wait()  方法——等待使用CPU：线程会放弃对象锁，直到收到notify()通知才会进入准备状态。

**我的理解：**

在该实例中，push和pop中在“篮子空了”、“篮子装满了”的情况下使用了wait()方法。此时，已经无法继续工作下去，需要让出CPU给其他操作，才能保证生产-消费线进行。等到"篮子中有面包"情况时，调用notify通知线程执行。

Producer和Consumer中的sleep()方法是为了让放大彼此交替的差距，来接近现实生活的状态。

[20160406101047147]: /images/20220724/b0ed647c43cf4751998502f25b89b922.png
[20160406103119733]: /images/20220724/388cd6d69c9a4445a0a5af6f8cbd54d8.png
[20160406103128796]: /images/20220724/76e5382010af4db889de7249692ca55a.png
[20160406103224687]: /images/20220724/a93a5d2bfd7349d8b965a3305d2537c2.png