第一个问题。
class Test implements Runnable
{
        private boolean flag;

        Test(boolean flag)
        {
                this.flag=flag;
        }

        public void run()
        {
                if(flag)
                {
                        synchronized(Lock.locka)
                        {
                                System.out.println("if locka");
                                synchronized(Lock.lockb)
                                {
                                        System.out.println("if lockb");
                                }

                        }
                }

                else
                {
                        synchronized(Lock.lockb)
                        {
                                System.out.println("else lockb");
                                synchronized(Lock.locka)
                                {
                                        System.out.println("else lockb");
                                }
                        }

                }
        }
}

class Lock
{
        static Lock locka = new Lock();//这里怎么可以加静态呢，这不是个对象吗？静态不是只能修饰成员吗？

        static Lock lockb = new Lock();
}

class DeadLockDemo
{
        public static void main(String[] args)
        {
                Thread t1 = new Thread(new Test(true));
                        
                Thread t2 = new Thread(new Test(false));
        

                t1.start();
                t2.start();
               
        }
}

为什么老毕这里写成这样呢？

static Object locka = new Object();
static Object lockb = new Object();

这个和我那个有什么区别呢？


第二个问题。

/*
class Resource
{
        private String name;

        private int count = 1;

        private boolean flag = false;
        /*
        Resource(String name)
        {
                this.name = name+"- -"+count++;

        }
        */

        public synchronized void set(String name)
        {
                while(flag)
                        try{this.wait();}catch(Exception e){}

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

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

                flag=true;
                this.notifyAll();
        }

        public synchronized void out()
        {
                if(flag)
                        try{this.wait();}catch(Exception e){}

                        System.out.println(Thread.currentThread().getName()+"....消费者"+this.name);
                flag=false;
                this.notifyAll();
        }
        
}

class Producer implements Runnable
{
        private Resource res;

        Producer(Resource res)
        {
                this.res=res;
        }

        public void run()
        {
                while(true)
                {
                        res.set("+商品+");
                }
        }
}

class Consumer implements Runnable
{
        private Resource res;
        
        Consumer(Resource res)
        {
                this.res=res;
        }
        

        public void run()
        {
                while(true)
                {
                        res.out();
                }
        }
}

class ProducerConsumerDemo
{

        public static void main(String[] args)
        {
                Resource res = new Resource();

                Producer pro = new Producer(res);

                Consumer con = new Consumer(res);

                Thread t1 = new Thread(pro);

                Thread t2 = new Thread(con);

                Thread t3 = new Thread(pro);

                Thread t4 = new Thread(con);

                t1.start();

                t2.start();

                t3.start();

                t4.start();
        }
}

*/

这里我真的不明白了，首先说先我的思路，Input往里面存对象，首先要判断flag是false，那就往里面存东西，然后存完之后要把标记改为true，
然后Input再来判断的时候一看是true就要wait()了，同时唤醒对方，然后Output一来判断一看是true就往外拉东西，拉完之后就把标记改为false，当再来判断之后
就要没有对象了，然后等待，同时唤醒对方，
public synchronized void set(String name)
        {
                while(flag)
                        try{this.wait();}catch(Exception e){}

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

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

                flag=true;
                this.notifyAll();
        }

        public synchronized void out()
        {
                if(!flag)//我不知道这里为什么要这样判断，这样一来不就是假了了吗，那怎么还往外面拉对象呢？
                        try{this.wait();}catch(Exception e){}

                        System.out.println(Thread.currentThread().getName()+"....消费者"+this.name);
                flag=false;
                this.notifyAll();
        }
请问大神我哪里理解错了？？？？

“static Lock locka = new Lock();//这里怎么可以加静态呢，这不是个对象吗？静态不是只能修饰成员吗？”
=左边是定义变量，右边才是对象；

“为什么老毕这里写成这样呢？

static Object locka = new Object();
static Object lockb = new Object();

这个和我那个有什么区别呢？”
这个是毕老师没有讲解到Lock之前写的，就是让我们明白锁是怎么回事。
  
“if(!flag)//我不知道这里为什么要这样判断，这样一来不就是假了了吗，那怎么还往外面拉对象呢？
      try{this.wait();}catch(Exception e){}
”
这句话你没有理解透，if(!flag)
                      try{this.wait();}catch(Exception e){}
if作用的只有try这个语句块，对其他没有作用。

邓超军 发表于 2012-6-30 11:29
“static Lock locka = new Lock();//这里怎么可以加静态呢，这不是个对象吗？静态不是只能修饰成员吗？”
...

那你说过程啊，if(!flag)  我的理解我都说了，你这样很模糊，

你那样的思路实现起来也没有问题，  但是效率会非常低。 因为你老是去判断是真或假，即使明明不满足条件，也要去执行下看能不能执行。这样就浪费cpu资源了。  之所以用等待唤醒机制，就是为了让他们实现互斥。当不满足的时候就等待，不用再去抢cpu资源。等待别人去唤醒，说现在你现在可以执行了，你再去执行。  这样效率会高些。

王德升 发表于 2012-6-30 11:38
那你说过程啊，if(!flag)  我的理解我都说了，你这样很模糊，

public synchronized void set(String name)
        {
                 /*判断flag真假，其中while(!flag)的 （flag）的值永远为true，与flag值无关。换句话说，当flag为true时，才执行while语句。
                而一旦flag为true，则生产就不能产生。就是通过flag的真假达到使生产和消费的过程互斥*/
                while(flag)
                        try{this.wait();}catch(Exception e){}
                this.name = name+"--"+count++;

                System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
                flag = true;
                this.notifyAll();
        }


        public synchronized void out()
        {
                /*判断flag真假，其中while(!flag)的 （!flag）的值永远为false，与flag值无关。换句话说，当flag为false时，才执行while语句。
                而一旦flag为false，则消费就不能产生。*/
                while(!flag)
                        try{wait();}catch(Exception e){}
                System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
                flag = false;
                this.notifyAll();
        }