黑马程序员_多线程的死锁和等待唤醒机制

------- android培训、java培训、期待与您交流！ ----------

1.      死锁问题的发生一般是由于同步的嵌套但锁却不同，如下程序：

class MyLock {

    static Object locka = new Object();

    static Object lockb = new Object();

}

class DeadLock extends MyLock implements Runnable {

    private boolean flag;

 

    DeadLock(boolean flag) {

       this.flag = flag;

    }

 

    public void run() {

       if (flag) {

           //同步代码块的嵌套，锁不同

           synchronized (locka) {

              System.out.println("if locka");

              synchronized (lockb) {

                  System.out.println("if lockb");

              }

           }

       } else {

           //同步代码块的嵌套，锁不同

           synchronized (lockb) {

               System.out.println("else lockb");

              synchronized (locka) {

                  System.out.println("else locka");

              }

           }

       }

 

    }

}

public class Test{

    public static void main(String[] args) {

       new Thread(new DeadLock(true)).start();

       new Thread(new DeadLock(false)).start();

    }

}

在两个相互嵌套的同步代码块中，锁不相同，当各自拿着对方的锁不放时就会出现死锁现象。

2.    多线程的等待唤醒机制

class Student {

    private String name;

    private int age;

    static boolean flag = false;

 

    public synchronized void set(String name, int age) {

       if (flag)

//等待，所有等待的线程都存放在线程池里

           try{this.wait();}catch(Exception e){}

           this.name = name;

           this.age = age;

           flag =true;

//唤醒，首先唤醒第一个被等待的线程

           this.notify();

    }

 

    public synchronized void out() {

       if (!flag)

//等待，所有等待的线程都存放在线程池里

           try{this.wait();}catch(Exception e){}

           System.out.println("name:" + name + "age:" + age);

           flag = false;

//唤醒，首先唤醒第一个被等待的线程

           this.notify();

    }

}

class Input extends Student implements Runnable {

    private Student s;

    Input(Student s){

       this.s=s;

    }

    public void run() {

       int x = 0;

       while (true) {

              if (x == 0)

                  s.set("林青霞", 27);

              else

                  s.set("擎天柱", 5000);

              x = (x + 1) % 2;

       }

    }

}

class Output extends Student implements Runnable {

    private Student s;

    Output(Student s){

       this.s=s;

    }

    public void run() {

       while (true) {

              s.out();

       }

    }

}

public class Test11 {

    public static void main(String[] args) {

       Student s=new Student();

       new Thread(new Input(s)).start();

       new Thread(new Output(s)).start();

    }

}

wait();

notify();

notifyAll();

都使用在同步中，因为要对持有监视器（锁）的线程操作

所以要使用在同步中，因为只有同步才具有锁

为什么这些方法要定义在Object类中呢？

因为这些方法在操作同步中的线程时，都必须要标识他们所操作线程持有的锁

只有同一个锁上的被等待线程，才可以被同一个锁上的notify()唤醒

不可以对不同锁中的线程进行唤醒

也就是说，等待和唤醒必须是同一个锁

而锁可以是任意对象，所以可以被任意对象调用的方法定义在Object类中。