生产者与消费者 代码实现 java

　　　　　　　　首先，我利用忙测试写出了第一次版本的代码

 package How;
 //自写代码  缺陷 无法完全实现pv操作线程处于忙测试状态
 public class bin_1_1
 {

     public static void main(String[] args)
     {
             Producter  producter;  //生产者线程
             Consumer   consumer;   //消费者线程
             Buffer     buffer;
             buffer=new Buffer(10);
             producter =new Producter(buffer);
             consumer =new Consumer(buffer);
             producter.start();
             consumer.start();
     }

 }
 class Producter extends Thread
 {
     Buffer buffer;
     public Producter(Buffer buffer)
     {
         this.buffer=buffer;
     }
     public void run()
     {
        while(true)
        {

          try
         {
             //模拟数据生产时间
             Thread.sleep((int)Math.random()*5000+400);
             IsEmpty();   //p(Empty)
             //寻找空的缓存区   记录其标号为K
             int k = 0;
             for(int i=0; i<buffer.state_of_objs.length; i++)
             {
                 if(buffer.state_of_objs[i]==0)
                 {
                     k=i;
                     break;
                 }

             }
             write(k);
         }
          catch (InterruptedException e)
         {

             e.printStackTrace();
         } 

        }
     }
     synchronized public void IsEmpty() throws InterruptedException
     {

         while(true)
         {
             if(buffer.empty==0)
             {
                 this.sleep(1);
             }
             else
             {
                 buffer.empty--;
                 break;
             }
         }
     }
      public void write( int k )   //写入互斥，进制其他生产者访问
     {
         try
         {
             //模拟数据写入时间
             Thread.sleep((int)Math.random()*1000+100);
             //更改状态
             System.out.println(Thread.currentThread().getName()+":  写"+k+"号缓存区");
             buffer.state_of_objs[k]=1;
             buffer.full++;
         } catch (InterruptedException e)
         {
             e.printStackTrace();
         }
     }
 }
 class Consumer extends Thread
 {
     Buffer buffer;
     public Consumer(Buffer buffer)
     {
         this.buffer=buffer;
     }
     public void run()
     {
         while(true)
         {
             try
             {
                 IsFull();
                 int k = 0;
                 for(int i=0; i<buffer.state_of_objs.length; i++)
                 {
                     if(buffer.state_of_objs[i]==1)
                     {
                         k=i;
                         break;
                     }
                 }
                 read(k);
                 //模拟消费时间
                 Thread.sleep((int)Math.random()*5000+300);
             }
         catch (InterruptedException e)
         {
             e.printStackTrace();
         }
         }
     }
     synchronized public void IsFull() throws InterruptedException
     {

         while(true)
         {
             if(buffer.full==0)
             {
                 this.sleep(1);
             }
             else
             {
                 buffer.full--;
                 break;
             }
         }
     }
     public void read( int k)
     {
         try
         {
             //模拟读时间
             Thread.sleep((int)Math.random()*3000+250);
             System.out.println(Thread.currentThread().getName()+":  读"+k+"号缓存区");
             //更改状态
             buffer.state_of_objs[k]=0;
             buffer.empty++;
         } catch (InterruptedException e)
         {
             e.printStackTrace();
         }
     }
 }
 class Buffer   //缓存区    临界资源记录区
 {
     int size;        //缓存区大小
     Object[] objs;   //
     int full=0;
     int empty;
     int []state_of_objs;
     public Buffer(int size)
     {
         this.size=size;
         this.empty=size;
         objs =new Object[size];
         state_of_objs=new int[size];
         for(int i=0; i<size; i++)
         {
             state_of_objs[i]=0;
         }
     }
 }

针对上述情况我，参考了一些其他人的代码

package How;
//参考代码  主要学习线程的各种锁！
public class bin_1_2 {
    private static Integer count = 0;
    private final Integer  FULL  = 10;
    private static String  LOCK  = "LOCK";

    class Producer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (LOCK) {
                    while (count == FULL) {
                        try {
                            LOCK.wait();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    count++;
                    System.out.println(Thread.currentThread().getName() + "生产者生产，目前总共有" + count);
                    LOCK.notifyAll();
                }
            }
        }
    }

    class Consumer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
                synchronized (LOCK) {
                    while (count == 0) {
                        try {
                            LOCK.wait();
                        } catch (Exception e) {
                        }
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName() + "消费者消费，目前总共有" + count);
                    LOCK.notifyAll();
                }
            }
        }
    }

    public static void main(String[] args) throws Exception {
        bin_1_2 bin_1_2 = new bin_1_2();
        new Thread(bin_1_2.new Producer()).start();
        new Thread(bin_1_2.new Consumer()).start();
        new Thread(bin_1_2.new Producer()).start();
        new Thread(bin_1_2.new Consumer()).start();
        new Thread(bin_1_2.new Producer()).start();
        new Thread(bin_1_2.new Consumer()).start();
        new Thread(bin_1_2.new Producer()).start();
        new Thread(bin_1_2.new Consumer()).start();
    }
}

  这个代码为 多个消费者，生产者的问题，通过这个代码，我了解了synchronized使用方式。

package How;
//参考代码
import java.util.LinkedList;

public class bin_1_3 {
    private LinkedList<Object> storeHouse = new LinkedList<Object>();
    private int MAX = 10;

    public bin_1_3()
    {
    }

    public void start() {
        new Producer().start();
        new Comsumer().start();
    }

    class Producer extends Thread {
        public void run() {
            while (true) {
                synchronized (storeHouse) {
                    try {
                        while (storeHouse.size() == MAX) {
                            System.out.println("storeHouse is full , please wait");
                            storeHouse.wait();
                        }
                        Object newOb = new Object();
                        if (storeHouse.add(newOb)) {
                            System.out.println("Producer put a Object to storeHouse");
                            Thread.sleep((long) (Math.random() * 3000));
                            storeHouse.notify();
                        }
                    } catch (InterruptedException ie) {
                        System.out.println("producer is interrupted!");
                    }

                }
            }
        }
    }

    class Comsumer extends Thread {
        public void run() {
            while (true) {
                synchronized (storeHouse) {
                    try {
                        while (storeHouse.size() == 0) {
                            System.out.println("storeHouse is empty , please wait");
                            storeHouse.wait();
                        }
                        storeHouse.removeLast();
                        System.out.println("Comsumer get  a Object from storeHouse");
                        Thread.sleep((long) (Math.random() * 3000));
                        storeHouse.notify();
                    } catch (InterruptedException ie) {
                        System.out.println("Consumer is interrupted");
                    }

                }
            }

        }
    }

    public static void main(String[] args) throws Exception {
        bin_1_3 pc = new bin_1_3();
        pc.start();
    }
}

    这个代码学习到了 LinkedList这个类库，从此我便可以快捷的方式实现栈，队列
    最后我的改进代码如下：

package How;
class MyBuffer      // 模拟缓冲区，这个为临界资源
{
    String data;  //模拟缓存区存放的数据
    public MyBuffer(String data)
    {
        this.data=data;
    }
}

public class bin_1
{
    public static void main(String[] args)
    {
        MyBuffer buffer=new MyBuffer("");
        MyConsumer myConsumer=new  MyConsumer(buffer);
        MyProducter myProducter=new MyProducter(buffer);
        myConsumer.start();
        myProducter.start();
    }
}

class MyProducter  extends Thread
{
    MyBuffer buffer;
    public MyProducter(MyBuffer buffer)
    {
        this.buffer=buffer;
    }
    //生产作业
    public void ProducterJob()
    {
        //模拟生产时间
        try
        {
            Thread.sleep((int )Math.random()*1000+400);
        }
        catch (InterruptedException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        //进入互斥资源
        synchronized (buffer)
        {
            if(buffer.data!="")  //缓存区满着，阻塞
            {
                try
                {
                    buffer.wait();
                    System.out.println("生产者等待");
                    Thread.sleep(500);
                } catch (InterruptedException e)
                {
                    e.printStackTrace();

                }
            }
            buffer.data=""+System.currentTimeMillis();
            System.out.println("生产者 ：生产的数据为"+buffer.data);
            buffer.notify(); //唤醒消费者
        }
    }
    public void run()
    {
        while(true)
        {
            ProducterJob();
        }
    }
}
class MyConsumer  extends Thread
{
    MyBuffer buffer;
    public MyConsumer(MyBuffer buffer)
    {
        this.buffer=buffer;
    }
    //消费作业
    public void ConsumerJob()
    {
        //模拟消费时间
        try
        {
            Thread.sleep((int )Math.random()*1000+600);
        }
        catch (InterruptedException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        //进入互斥资源
        synchronized (buffer)
        {
            if(buffer.data=="")  //缓存区为空，阻塞
            {
                try
                {
                    buffer.wait();
                    System.out.println("消费者等待");
                    Thread.sleep(500);
                } catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
            System.out.println("消费者 ：消费的数据为"+buffer.data);

            buffer.data="";
            buffer.notify(); //唤醒生产者
        }
    }
    public void run()
    {
        while(true)
        {
            ConsumerJob();
        }
    }
}

运行结果：