多线程基础-06

7.线程锁基础

(1)死锁

• 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步代码块同时拥有 " 两个以上对象的锁 "时，就可能会发生"死锁"的问题。

代码实现

// 死锁：多个线程互相抱着对方需要的资源，然后形成僵持
public class DeadLock {

    public static void main(String[] args) {
        Makeup g1 = new Makeup(0,"小黑");
        Makeup g2 = new Makeup(1,"小白");

        g1.start();
        g2.start();

    }

}

// 口红
class LipStick {

}

// 镜子
class Mirror {

}

// 化妆
class Makeup extends Thread{

    // 为什么要定义成static：需要的资源只有一份，需要用static来保证
    static LipStick lipStick = new LipStick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String name;//化妆的人

    // 有了自定义的字段必然有构造器【构造器的方法名称一定与该类的方法名称一样】
    Makeup(int choice,String name) {
        this.choice = choice;
        this.name = name;
    }

    @Override
    public void run() {
        // 化妆1
        /*try {
            makeup(choice,name);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }*/

        // 化妆2
        try {
            makeup(name,choice);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // 互相持有对方的锁，就是需要拿到对方的资源
    // 化妆形成死锁情况
    private void makeup(int choice,String name) throws InterruptedException {
        if (choice == 0) {
            synchronized (lipStick) {// 先锁定口红
                System.out.println(name + ">>>>使用口红中");

                Thread.sleep(1000);

                synchronized (mirror) {// 口红没用完的情况下，加上使用镜子
                    System.out.println(name + ">>>>使用口红的同时使用镜子！");
                }
            }
        } else {
            synchronized (mirror) {// 先锁定镜子
                System.out.println(name + ">>>>使用镜子中");
                synchronized (lipStick) {// 镜子没用完的情况下，加上使用口红
                    System.out.println(name + ">>>>使用镜子的同时使用口红！");
                }
            }
        }
    }

    // 化妆不会发生死锁情况
    private void makeup(String name,int choice) throws InterruptedException {
        if (choice == 0) {
            synchronized (lipStick) {// 锁定口红
                System.out.println(name + ">>>>使用口红中");
                Thread.sleep(1000);
            }
            synchronized (mirror) {// 口红用完并且释放，再使用镜子
                System.out.println(name + ">>>>使用口红结束，开始使用镜子！");
            }
        } else {
            synchronized (mirror) {// 先锁定镜子
                System.out.println(name + ">>>>使用镜子中");

            }
            synchronized (lipStick) {// 镜子用完并且释放，再使用口红
                System.out.println(name + ">>>>使用镜子结束，开始使用口红！");
            }
        }
    }
}

形成死锁的执行结果：

小白>>>>使用镜子中
小黑>>>>使用口红中

正常结束,不会形成死锁的执行结果：

小黑>>>>使用口红中
小白>>>>使用镜子中
小黑>>>>使用口红结束，开始使用镜子！
小白>>>>使用镜子结束，开始使用口红！

(2)死锁避免的方法

• 产生死锁的四个必要条件：
  1. 互斥条件：一个资源每次只能被一个进程使用。
  2. 请求与保持条件：一个进程因请求资源而阻塞时，对已经获得的资源保持不放。
  3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能被强行剥夺。
  4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生

(3)Lock锁

• 从 JDK 5.0开始，Java提供了更强大的线程同步机制–通过显示定义同步锁来实现同步。同步锁使用Lock对象来充当。
• java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
• ReentrantLock(可重入锁)类实现了Lock接口，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock(可重入锁)类，可以显示加锁、释放锁。

代码实现ReentrantLock(可重入锁)类

// 测试ReentrantLock(可重入锁)类
public class TestLock {

    public static void main(String[] args) {
        MyLock lock = new MyLock();

        new Thread(lock).start();
        new Thread(lock).start();
        new Thread(lock).start();
    }

}

class MyLock implements Runnable {

    int ticketNums = 10;

    // 定义ReentrantLock(可重入锁)
    ReentrantLock reentrantLock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            // 显示的加锁与释放锁[释放锁是在try...finally{}中释放锁]
            reentrantLock.lock();// 加锁
            try {
                if (ticketNums > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                } else {
                    break;
                }
            } finally {
                // 解锁
                reentrantLock.unlock();
            }
        }
    }
}

实现模板：

class A{
    // 定义ReentrantLock(可重入锁)
    ReentrantLock reentrantLock = new ReentrantLock();

    public void M() {
        while (true) {
            // 显示的加锁与释放锁[释放锁是在try...finally{}中释放锁]
            reentrantLock.lock();// 加锁
            try {
                // 保证线程安全的代码
            } finally {
                // 解锁
                // 如果同步代码有异常，需要将unlock()写入finally语句块
                reentrantLock.unlock();
            }
        }
    }
}

synchronized 与 Lock的对比

1. Lock是显示锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放；
2. Lock只用代码块锁，synchronized`有代码块锁和方法锁；
3. 使用Lock锁，JVM 将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）；
4. 优先使用顺序：
   -Lock锁 > 同步代码块 （已经进入了方法体，分配了相应的资源）> 同步方法（在方法体之外）