class Resource
{
        private String product;
        private int count=1;
        private boolean flag=false;
        public synchronized void set(String product)
        {
                /*同步函数或代码块中，执行线程处于等待状态了，其它线程就可以进来，
                  求解答，最好能与Lock锁一并分析下   thanks   */
                while(flag)
                        try{wait();}catch(InterruptedException e){}
                this.product = product;
                System.out.println("生产者： "+product+count);
                flag = true;
                notifyAll();

        }
        public synchronized void out()
        {
                while(!flag)
                                try{wait();}catch(InterruptedException e){}
                System.out.println("消费者"+product+count++);
                flag = false;
                notifyAll();
        }
}

个人见解，希望能帮到楼主。

Lock接口与Condition接口（也是JDk1.5的新特性）

Lock替代了synchronized；而Condition 替代了Object中的监视器方法（wait,notify,notifyall）使用，Condition可以通过Lock锁获取，一个Lock可以对应多个Condition。

与之对应上面代码，我们只要更改Res类中代码如下：

class Resource

{

private String name;

        private int count = 1;

        private boolean flag = false;//定义标志，用于进程间切换

        private Lock lock = new ReentrantLock();

        private Condition con = lock.newCondition();

//private Condition con_pro = lock.newCondition();

//private Condition con_con = lock.newCondition();

//此处抛了异常，在处理线程时一定要记得做异常处理

        public void set(String name)throws InterruptedException

        {

                lock.lock();//上锁，lock()与unlock()其实就类似于synchronized ，只是lock必须手动上锁和解锁

                try{

                        while(flag)

                                con.await();//线程等待，类似于wait

//con_pro.await();

                        this.name = name+"-->"+count++;

                        System.out.println("生产者.."+this.name);

                        flag = true;

                                con.signalAll();//唤醒全部线程，类似于notifyAll

//con_con.signal();

                }

                finally{

                        lock.unlock();//释放锁

                }

               

        }

//此处抛了异常，在处理线程时一定要记得做异常处理

        public void out()throws InterruptedException

        {

                lock.lock();//上锁

                try{

                        while(!flag)

                                con.await();//线程等待

//con_con.await();

                        System.out.println("消费者.."+this.name);

                        flag = false;

                        con.signalAll();//唤醒线程

//con_pro.signal();

                }

                finally{

                        lock.unlock();//释放锁

                }

        }

}

//以上注释的代码，实现了等待本方线程和只唤醒对方线程的功能。

　　

没壳的蜗牛 发表于 2014-5-26 11:18
个人见解，希望能帮到楼主。
Lock接口与Condition接口（也是JDk1.5的新特性）Lock替代了synchronized；而Co ...

挺到位的，很有帮助，谢谢