多线程（5）——死锁、Lock锁、synchronized和Lock的对比

多线程（5）——死锁、Lock锁、synchronized和Lock的对比

死锁

• 多个线程各自占有一个共享资源（同步监视器），并且都在等待对方释放，会导致死锁问题
• 比如线程A拿到了锁1，线程B拿到了锁2，但是A需要再拿到锁2，B需要再拿到锁1，才能完成各自的线程，这样就导致了死锁
• 所以最直观避免死锁的方法是，一个线程一次只能拿到一个共享资源，并且执行完该部分的方法后立即释放锁

案例中

package 多线程;

public class Test3 {
    public static void main(String[] args) {
        Makeup xiaohong = new Makeup("小红", 0);
        Makeup xiaoming = new Makeup("小明", 1);

        xiaohong.start();
        xiaoming.start();
    }
}

class LipStick {

}

class Mirror {

}

class Makeup extends Thread {

    //    通过extends Thread创建线程对象，共享资源需要用static修饰
    static LipStick lipStick = new LipStick();
    static Mirror mirror = new Mirror();

    private String name;
    private Integer choice;

    Makeup(String name, Integer choice) {
        this.name = name;
        this.choice = choice;

    }


    @Override
    public void run() {
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    public void makeup() throws InterruptedException {
        if (choice == 0) {
            // 小红拿了lipStick的锁，但是一秒后准备拿mirror锁的时候发现被占用了，就卡死了
            synchronized (lipStick) {
                System.out.println(this.name + "在使用口红");
                Thread.sleep(1000);
                synchronized (mirror) {
                    System.out.println(this.name + "在使用镜子");
                }
            }
        } else {
            // 小明拿了mirror的锁，但是一秒后准备拿lipStick锁的时候发现被占用了，就卡死了
            synchronized (mirror) {
                System.out.println(this.name + "在使用镜子");
                Thread.sleep(2000);
                synchronized (lipStick) {
                    System.out.println(this.name + "在使用口红");
                }
            }
        }
    }
}

结果

解决死锁问题：每个线程每次只能拥有一个共享资源锁对象，一旦用完共享资源，立即释放

注意：同步代码块必须执行完成才能释放锁对象

public void makeup() throws InterruptedException {
        if (choice == 0) {
            // 使用完锁立即释放
            synchronized (lipStick) {
                System.out.println(this.name + "在使用口红");
                Thread.sleep(1000);
                }
            synchronized (mirror) {
                System.out.println(this.name + "在使用镜子");
            }
        } else {
            // 使用完锁立即释放
            synchronized (mirror) {
                System.out.println(this.name + "在使用镜子");
                Thread.sleep(2000);
                }
            synchronized (lipStick) {
                System.out.println(this.name + "在使用口红");
            }
        }
    }

Lock锁

• 通过显式定义同步锁对象来实现同步，Lock对象
• java.util.concurrent.locks.Lock接口，每次只能由一个线程对Lock对象加锁，线程开始访问共享资源前应先获得Lock对象
• ReentrantLock类实现了Lock，拥有与synchronized相同的并发性和内存语义，可以显式加锁、释放锁

public class TestLock {
    public static void main(String[] args) {
        Ticket1 t = new Ticket1();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
    }
}

class Ticket1 implements Runnable {
    int ticket = 10;
    //定义Lock锁
    private final ReentrantLock lock = new ReentrantLock();

    public void run() {
        while (true) {
            lock.lock();
            try {
                if (ticket > 0) {
                    Thread.sleep(100);
                    System.out.println(ticket--);
                } else {
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}