class BoundedBuffer {     final Lock lock = new ReentrantLock();//锁对象     final Condition notFull  = lock.newCondition();//写线程条件      final Condition notEmpty = lock.newCondition();//读线程条件        final Object[] items = new Object[100];//缓存队列     int putptr/*写索引*/, takeptr/*读索引*/, count/*队列中存在的数据个数*/;       public void put(Object x) throws InterruptedException {       lock.lock();       try {         while (count == items.length)//如果队列满了            notFull.await();//阻塞写线程,this.wait()         items[putptr] = x;//赋值          if (++putptr == items.length) putptr = 0;//如果写索引写到队列的最后一个位置了，那么置为0         ++count;//个数++         notEmpty.signal();//唤醒读线程,this.notify()       } finally {         lock.unlock();       }     }       public Object take() throws InterruptedException {       lock.lock();       try {         while (count == 0)//如果队列为空           notEmpty.await();//阻塞读线程,this.wait()  
       Object x = items[takeptr];//取值          if (++takeptr == items.length) takeptr = 0;//如果读索引读到队列的最后一个位置了，那么置为0         --count;//个数--         notFull.signal();//唤醒写线程,this,notify()         return x;       } finally {         lock.unlock();       }     }    }  

 public class SynDemo {    /**     * @param args     */    public static void main(String[] args) {        // TODO Auto-generated method stub         Q q=new Q ();         Consumer c=new Consumer(q);         Producer p=new Producer (q);         new Thread (c).start();         new Thread (p).start();             }}//消费者线程(读取)class Consumer implements Runnable{    private Q q=null;    public Consumer (Q q)    {        this.q=q;    }    public void run ()    {         while(true)         {             //System.out.println(Thread.currentThread().getName());            try {                q.get();            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }         }    }}//生产者线程(更改)class Producer implements Runnable{    private Q q=null;    private int num=1;    public Producer (Q q)    {      this.q=q;     }     public void run ()     {         while(true)         {                      //System.out.println(Thread.currentThread().getName());             if(num==1)             {                try {                    q.put("陈奕迅","男");                } catch (InterruptedException e) {                    // TODO Auto-generated catch block                    e.printStackTrace();                }             }             else if(num==0)             {                 try {                    q.put("王菲","女");                } catch (InterruptedException e) {                    // TODO Auto-generated catch block                    e.printStackTrace();                }             }                 num=(num+1)%2;         }     }}//共同操作的数据Q，由线程对其进行修改，读取，//因为要修改和读取同步(即两个方法的同步锁为Q对象),且数据在Q内部，所以应具有操作数据的方法class Q{    private String name;    private String sex;  private boolean flag=true;//以标志位来控制更改或读取操作。    //更改的同步方法    public synchronized void put(String name,String sex) throws InterruptedException    {        //默认标志位为true时更改否则等待        if(!isFlag())            wait();      this.name=name;        this.sex=sex;       //更改完后换读取,且唤醒读取(为false标志)的线程        this.flag=false;        notify();         System.out.println(Thread.currentThread().getName());             }  //读取的同步方法  public synchronized void get() throws InterruptedException    {        //默认标志位为flase时读取否则等待        if(isFlag())            wait();        System.out.println(this.name+":"+this.sex);        //读取完后换更改，且唤醒更改(为true)的线程        this.flag=true;        notify();         System.out.println(Thread.currentThread().getName());             }    public boolean isFlag()    {           return flag;    }    public void setFlag(boolean flag)    {           this.flag=flag;    }    public String getName()  {        return name;    }    public void setName(String name)    {        this.name=name;    }  public String getSex()  {        return sex;    }    public void getSex(String sex)    {        this.sex=sex;    }}

//synchronized 可用Lock代替//object的wait，notify和notifyAll方法可用condition对象下对应的方法代替。import java.util.concurrent.locks.ReentrantLock;import java.util.concurrent.locks.Condition;//共同操作的数据Q，由线程对其进行修改，读取，//因为要修改和读取同步(即两个方法的同步锁为Q对象),且数据在Q内部，所以应具有操作数据的方法class Q{    private String name;    private String sex;  private boolean flag=true;//以标志位来控制更改或读取操作。  private final  ReentrantLock l=new ReentrantLock();  private Condition rc=l.newCondition(); //读线程条件  private Condition wc=l.newCondition();//写线程条件    //更改的同步方法    public   void put(String name,String sex) throws InterruptedException    {        l.lock();        try{        //默认标志位为true时更改否则等待        while(!isFlag())            wc.await();      this.name=name;        this.sex=sex;       //更改完后换读取,且唤醒读取(为false标志)的线程        this.flag=false;        rc.signal();         System.out.println(Thread.currentThread().getName());        }        finally{         l.unlock();        }    }  //读取的同步方法  public   void get() throws InterruptedException    {       l.lock();       try       {        //默认标志位为flase时读取否则等待        while(isFlag())            rc.await();        System.out.println(this.name+":"+this.sex);        //读取完后换更改，且唤醒更改(为true)的线程        this.flag=true;        wc.signal();          System.out.println(Thread.currentThread().getName());       }       finally{       l.unlock();       }    }    public boolean isFlag()    {           return flag;    }    public void setFlag(boolean flag)    {           this.flag=flag;    }    public String getName()  {        return name;    }    public void setName(String name)    {        this.name=name;    }  public String getSex()  {        return sex;    }    public void getSex(String sex)    {        this.sex=sex;    }}

陈奕迅:男Thread-0Thread-1王菲:女Thread-0Thread-1陈奕迅:男Thread-0Thread-1王菲:女