import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class ProductConsumer {

        /**
         * 需求：通过lock实现生产者消费者多线程同步

           思路：创建生成和消费方法，在要同步的代码前用lock对象锁住
         * 判断过产品是否为空，为空则生产，否则不生产，唤醒消费者消费，并 解锁，同理消费方法也是先加锁，判断的是否有产品，有则消费，没有则
         * 唤醒生产者生产，然后解锁.
         *
         *
         */
       
        private ProductConsumer p;
       
        private int count = 1;
        private boolean flag = false;
        private Lock lock = new ReentrantLock();
        private Condition condition_pro = lock.newCondition();
        private Condition condition_con = lock.newCondition();

        public void product() {
                lock.lock();
                try {

                        while (flag)
                                try {
                                        condition_pro.await();
                                } catch (InterruptedException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
                       
                        System.out.println(Thread.currentThread().getName() + "生成产品->"
                                        +  count++);
                        flag = true;
                        condition_con.signal();

                } finally {
                        lock.unlock();
                }

        }

        public void consumer() {
                try {
                        lock.lock();
                        while (!flag)
                                try {
                                        condition_con.await();
                                } catch (InterruptedException e) {

                                        e.printStackTrace();
                                }
                        System.out.println(Thread.currentThread().getName() + "消费产品->"
                                        + this.count);
                        flag = false;
                        condition_pro.signal();

                       

                } finally {
                        lock.unlock();
                }
        }

        public static void main(String[] args) {

                new Thread(new ProductConsumer().new Product(new ProductConsumer()))
                                .start();
                new Thread(new ProductConsumer().new Consumer(new ProductConsumer()))
                                .start();
                new Thread(new ProductConsumer().new Product(new ProductConsumer()))
                                .start();
                new Thread(new ProductConsumer().new Consumer(new ProductConsumer()))
                                .start();

        }

        class Product implements Runnable {

                Product(ProductConsumer pro) {
                        p = pro;
                }

                @Override
                public void run() {
                        product();

                }
        }

        class Consumer implements Runnable {
                Consumer(ProductConsumer con) {
                        p = con;
                }

                @Override
                public void run() {
                        consumer();

                }
        }

}
如题：为什么我调用了 consumer()方法却没有输出，而且生产者的输出也不对呢，求解。。。。。谢谢

嗯 谢谢啦  我参照你的代码把该改的都改了还是一样的结果，暂时没发现主要问题吧，过短时间再看看。。。。。。。

/*这是我按照毕老师视频打出来的，运行正常，希望对你有用
* lock方法和condition的应用
* */
import java.util.concurrent.locks.*;//必须要加上这个包，否则编译错误
public class LockCondition {
        public static void main(String[] args) {
                Res1 r=new Res1();
                Input2 in=new Input2(r);
                Output2 out=new Output2(r);
                Thread t1=new Thread(in);
                Thread t2=new Thread(in);
                Thread t3=new Thread(out);
                Thread t4=new Thread(out);
                t1.start();
                t2.start();
                t3.start();
                t4.start();
        }
}
class Res1
{
        private String name;
        private int count=1;
        private boolean flag=false;
        private Lock lock=new ReentrantLock();//创建一个锁对象
        private Condition con_c=lock.newCondition();
        private Condition con_p=lock.newCondition();
        public void set(String name)throws InterruptedException//注意没有同步代码了，但是lock要抛出异常
        {
                lock.lock();//相当于给程序加了一把锁
                try
                {
                        while(flag)
                        {
                                con_c.await();
                        }
                        this.name=name+count++;
                        System.out.println(Thread.currentThread().getName()+"..生产者.."+name);
                        flag=true;
                        con_p.signalAll();//注意此处为什么不是signal()，这和notify()以及notifyAll()原理一样
                }
                finally
                {
                        lock.unlock();//解锁，这一步必须要执行，所以在finally中
                }       
        }
        public void out()throws InterruptedException
        {
                lock.lock();//相当于给程序加了一把锁
                try
                {
                        while(!this.flag)
                        {
                                con_p.await();
                        }
                        System.out.println(Thread.currentThread().getName()+"..消费者.."+name);
                        flag=false;
                        con_c.signalAll();//注意此处为什么不是signal()，这和notify()以及notifyAll()原理一样
                }
                finally
                {
                        lock.unlock();//解锁，这一步必须要执行，所以在finally中
                }       
        }
}
class Input2 implements Runnable
{
        private Res1 r;
        Input2(Res1 r)
        {
                this.r=r;
        }
        public void run()
        {
                while (true)
                {
                        try
                        {
                                r.set("商品");
                        }
                        catch (InterruptedException e) //处理抛出的异常
                        {       
                        }
                       
                }
        }       
}
class Output2 implements Runnable
{
        private Res1 r;
        Output2(Res1 r)
        {
                this.r=r;
        }
        public void run()
        {
                while (true)
                {
                        try
                        {
                                r.out();
                        }
                        catch (InterruptedException e) //处理抛出的异常
                        {       
                        }
                }       
        }
}