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();
    }
}