Java 多线程学习——生产者消费者简单实现

Storage.java 仓库类

package threads;

import java.util.LinkedList;

public class Storage
{
    // 仓库最大存储量
    private final int MAX_SIZE = 100;

    // 仓库存储的载体
    private LinkedList<Object> list = new LinkedList<Object>();

    // 生产产品
    public void produce(String producer)
    {
        synchronized (list)
        {
            // 如果仓库已满
            while (list.size() == MAX_SIZE)
            {
                System.out.println("仓库已满，【"+producer+"】： 暂时不能执行生产任务!");
                try
                {
                    // 由于条件不满足，生产阻塞
                    list.wait();
                }
                catch (InterruptedException e)
                {
                    System.out.println("??");
                    return;
                }
            }

            // 生产产品            
            list.add(new Object());            

            System.out.println("【"+producer+"】：生产了一个产品\t【现仓储量为】:" + list.size());

            list.notifyAll();
        }
    }

    // 消费产品
    public void consume(String consumer)
    {
        synchronized (list)
        {
            //如果仓库存储量不足
            while (list.size()==0)
            {
                System.out.println("仓库已空，【"+consumer+"】： 暂时不能执行消费任务!");
                try
                {
                    // 由于条件不满足，消费阻塞
                    list.wait();
                }
                catch (InterruptedException e)
                {
                    System.out.println("InterruptedException");
                    return;
                }
            }
            
            list.remove();
            System.out.println("【"+consumer+"】：消费了一个产品\t【现仓储量为】:" + list.size());
            list.notifyAll();
        }
    }

    public LinkedList<Object> getList()
    {
        return list;
    }

    public void setList(LinkedList<Object> list)
    {
        this.list = list;
    }

    public int getMAX_SIZE()
    {
        return MAX_SIZE;
    }
}

Consumer.java 消费者类

package threads;

public class Consumer extends Thread
{
    private String consumer;
    private Storage storage;
    private volatile boolean flag = true; 

    public Consumer(Storage storage)
    {
        this.storage = storage;
    }
    
    public Consumer(Storage storage,String consumer)
    {
        this.storage = storage;
        this.consumer = consumer;
    }

    @Override
    public void run()
    {
        
        while(flag){
        	consume(consumer);
    		try {
			this.sleep(2000);
		} catch (InterruptedException e) {
			System.out.println("con");
		}
    	}
        System.out.println("线程"+"【"+consumer+"】"+"已终止");
       
    }

    public void consume(String consumer)
    {
        storage.consume(consumer);
    }

    public Storage getStorage()
    {
        return storage;
    }

    public void setStorage(Storage storage)
    {
        this.storage = storage;
    }

    public String getConsumer() {
        return consumer;
    }

    public void setConsumer(String consumer) {
        this.consumer = consumer;
    }
    public boolean isFlag() {
		return flag;
	}
	public void setFlag(boolean flag) {
		this.flag = flag;
	}
}

Producer.java 生产者类

package threads;

public class Producer extends Thread
{
    private String producer;
    private Storage storage;
    private volatile boolean flag = true; 

    
    public Producer(Storage storage)
    {
        this.storage = storage;
    }
    public Producer(Storage storage,String producer)
    {
        this.storage = storage;
        this.producer = producer;
    }

    @Override
    public void run()
    {
    	while(flag){
    		produce(producer);
    		try {
			this.sleep(4000);
		} catch (InterruptedException e) {
			System.out.println("pro");
		}
    	}
    	System.out.println("线程"+"【"+producer+"】"+"已终止");
    	
        
    }

    public void produce(String producer)
    {
        storage.produce(producer);
    }

    public String getProducer()
    {
        return producer;
    }

    public void setProducer(String producer)
    {
        this.producer = producer;
    }

    public Storage getStorage()
    {
        return storage;
    }

    public void setStorage(Storage storage)
    {
        this.storage = storage;
    }
    public boolean isFlag() {
		return flag;
	}
	public void setFlag(boolean flag) {
		this.flag = flag;
	}
}

Main.java 实现测试类

package threads;

public class Main {
	public static void main(String[] args){
		Storage s = new Storage();
		
		Producer p1 = new Producer(s,"生产者1");
		p1.start();
		
		Consumer con1 = new Consumer(s,"消费者1");
		con1.start();
		Consumer con2 = new Consumer(s,"消费者2");
		con2.start();
		
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		p1.setFlag(false);

		con1.setFlag(false);
		con2.setFlag(false);
		
		p1.interrupt();
		con1.interrupt();
		con2.interrupt();    //使用interrupt函数结束处于阻塞状态的线程
		
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		
		System.out.println("主线程已终止");
	}
}