00103_死锁、Lock接口、等待唤醒机制

1、死锁

　　（1）同步锁使用的弊端：当线程任务中出现了多个同步(多个锁)时，如果同步中嵌套了其他的同步。这时容易引发一种现象：程序出现无限等待，这种现象我们称为死锁。这种情况能避免就避免掉；

synchronzied(A锁){

    synchronized(B锁){

}

}

　　（2）代码演示

　　　　①定义锁对象

 public class MyLock {

     public static final Object lockA = new Object();

     public static final Object lockB = new Object();

 }

　　　　②线程任务类

 import java.util.Random;

 public class ThreadTask implements Runnable {

     int x = new Random().nextInt(1);// 0,1

     // 指定线程要执行的任务代码

     @Override

     public void run() {

         while (true) {

             if (x % 2 == 0) {

                 // 情况一

                 synchronized (MyLock.lockA) {

                     System.out.println("if-LockA");

                     synchronized (MyLock.lockB) {

                         System.out.println("if-LockB");

                         System.out.println("if大口吃肉");

                     }

                 }

             } else {

                 // 情况二

                 synchronized (MyLock.lockB) {

                     System.out.println("else-LockB");

                     synchronized (MyLock.lockA) {

                         System.out.println("else-LockA");

                         System.out.println("else大口吃肉");

                     }

                 }

             }

             x++;

         }

     }

 }

　　　　③测试类

 public class ThreadDemo {

     public static void main(String[] args) {

         // 创建线程任务类对象

         ThreadTask task = new ThreadTask();

         // 创建两个线程

         Thread t1 = new Thread(task);

         Thread t2 = new Thread(task);

         // 启动线程

         t1.start();

         t2.start();

     }

 }

2、Lock接口

　　（1）Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作；

　　（2）Lock提供了一个更加面对对象的锁，在该锁中提供了更多的操作锁的功能；

　　（3）我们使用Lock接口，以及其中的lock()方法和unlock()方法替代同步，对卖票案例中Ticket类进行如下代码修改：

 public class Ticket implements Runnable {

     //共100票

     int ticket = 100;

     //创建Lock锁对象

     Lock ck = new ReentrantLock();

     @Override

     public void run() {

         //模拟卖票

         while(true){

             //synchronized (lock){

             ck.lock();

                 if (ticket > 0) {

                     //模拟选坐的操作

                     try {

                         Thread.sleep(10);

                     } catch (InterruptedException e) {

                         e.printStackTrace();

                     }

                     System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);

                 }

             ck.unlock();

             //}

         }

     }

 }

3、等待唤醒机制

　　（1）线程之间的通信：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同；

　　（2）通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制；

　　（3）等待唤醒机制所涉及到的方法：

　　　　①wait() :等待，将正在执行的线程释放其执行资格和执行权，并存储到线程池中；

　　　　②notify()：唤醒，唤醒线程池中被wait（）的线程，一次唤醒一个，而且是任意的；

　　　　③notifyAll()：唤醒全部：可以将线程池中的所有wait() 线程都唤醒。

　　（4）其实，所谓唤醒的意思就是让线程池中的线程具备执行资格；

　　（5）这些方法都是在同步中才有效，同时这些方法在使用时必须标明所属锁，这样才可以明确出这些方法操作的到底是哪个锁上的线程；

　　（6）仔细查看JavaAPI之后，发现这些方法并不定义在 Thread中，也没定义在Runnable接口中，却被定义在了Object类中，为什么这些操作线程的方法定义在Object类中？

　　因为这些方法在使用时，必须要标明所属的锁，而锁又可以是任意对象。能被任意对象调用的方法一定定义在Object类中；

　　（7）模拟等待唤醒机制的实现，代码案例：

　　　　①模拟资源类

 public class Resource {

     private String name;

     private String sex;

     private boolean flag = false;

     public synchronized void set(String name, String sex) {

         if (flag)

             try {

                 wait();

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

         // 设置成员变量

         this.name = name;

         this.sex = sex;

         // 设置之后，Resource中有值，将标记该为 true ,

         flag = true;

         // 唤醒output

         this.notify();

     }

     public synchronized void out() {

         if (!flag)

             try {

                 wait();

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

         // 输出线程将数据输出

         System.out.println("姓名: " + name + "，性别: " + sex);

         // 改变标记，以便输入线程输入数据

         flag = false;

         // 唤醒input，进行数据输入

         this.notify();

     }

 }

　　　　②输入线程人任务类

 public class Input implements Runnable {

     private Resource r;

     public Input(Resource r) {

         this.r = r;

     }

     @Override

     public void run() {

         int count = 0;

         while (true) {

             if (count == 0) {

                 r.set("小明", "男生");

             } else {

                 r.set("小花", "女生");

             }

             // 在两个数据之间进行切换

             count = (count + 1) % 2;

         }

     }

 }

　　　　③输出线程任务类

 public class Output implements Runnable {

     private Resource r;

     public Output(Resource r) {

         this.r = r;

     }

     @Override

     public void run() {

         while (true) {

             r.out();

         }

     }

 }

　　　　④测试类

 public class ResourceDemo {

     public static void main(String[] args) {

         // 资源对象

         Resource r = new Resource();

         // 任务对象

         Input in = new Input(r);

         Output out = new Output(r);

         // 线程对象

         Thread t1 = new Thread(in);

         Thread t2 = new Thread(out);

         // 开启线程

         t1.start();

         t2.start();

     }

 }

巴特西

00103_死锁、Lock接口、等待唤醒机制

最新文章

热门文章