JUC_8锁问题

8锁问题示例与探究（问题后附讲解）

“八锁”的含义：就是八个关于锁的问题

问题一：标准情况下，两个线程先打印发短信 还是打电话？

public class Demo1 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        //锁的存在
        new Thread(()-> {
                phone.sendSms();
            },"A").start();
        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()-> {
            phone.call();
        },"B").start();
    }
}

class Phone{
    //synchronized 锁的对象是方法的调用者！
    //两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms(){
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

答案：1、发短信 2、打电话

这个问题的本质是给 phone 这个对象加了 synchronized 锁 两个方法用的是同一个对象锁，A先执行，拿到了锁，只有A执行完，A解锁了（synchronized是自动释放锁），B才能拿到锁，从而去操作phone这个对象

问题二：sendSms延迟4秒，两个线程先打印 发短信 还是打电话？

public class Demo1 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        //锁的存在
        new Thread(()-> {
                phone.sendSms();

            },"A").start();
        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()-> {
            phone.call();

        },"B").start();

    }
}

class Phone{
    //synchronized 锁的对象是方法的调用者！
    //两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

答案：（4秒后，显示结果）1、发短信 2、打电话

和问题一一样，同样是A拿到了锁，只有等A执行完，释放了锁（synchronized是自动释放锁），B才能拿到锁，从而操作hone对象

问题三：一个同步方法，一个普通方法， 先执行发短信 还是打电话？

public class Demo2 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();
        //锁的存在
        new Thread(() -> {
            phone.sendSms();

        }, "A").start();
        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone.call();

        }, "B").start();


    }
}
class Phone2 {
    //synchronized 锁的对象是方法的调用者！
    //两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
 //这里没有锁！不是同步方法，不受锁的影响！
    public void call() {
        System.out.println("打电话");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

答案：1、打电话 （4秒后，显示） 2、发短信

先执行普通方法（不是同步方法，不受锁的影响），因为他不是同步方法不受锁的影响，并且发短信睡眠了4秒，所以发短信肯定在她后面。

问题四：两个对象，两个同步方法，先执行发短信 还是打电话？

public class Demo2 {
    public static void main(String[] args) {
        //两个对象，两个调用者，两把锁！
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

        //锁的存在
        new Thread(() -> {
            phone1.sendSms();

        }, "A").start();
        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone2.call();

        }, "B").start();


    }
}

class Phone2 {
    //synchronized 锁的对象是方法的调用者！
    //两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

答案：1、打电话（4秒后，显示）2、发短信

他们锁的是不同的两个对象，所以互不受影响，由于发短信睡了4秒中，使用发短信在打电话后面

问题五：增加两个静态的同步方法，只有一个对象，先打印发短信还是打电话？

public class Demo3 {
    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static ,锁的是Class
        Phone3 phone = new Phone3();

        //锁的存在
        new Thread(() -> {
            phone.sendSms();

        }, "A").start();
        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone.call();
        }, "B").start();
    }
}

//Phone3 唯一的一个Class 对象
class Phone3 {
    //synchronized 锁的对象是方法的调用者！
    //static 静态方法
    //类只要加载就有了！ Class 模板
    public static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call() {
        System.out.println("打电话");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

答案：（4秒后，显示）1、发短信 2、打电话

因为静态代码块实在类加载的时候就有了，他锁的是类（Class，类锁）用的是同一个锁，谁先抢到谁先执行，所以发短信先抢到。

问题六：增加两个静态的同步方法，两个对象，先打印发短信还是打电话？

public class Demo3 {
    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static ,锁的是Class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();

        //锁的存在
        new Thread(() -> {
            phone1.sendSms();
        }, "A").start();
        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone2.call();
        }, "B").start();
    }
}
//Phone3 唯一的一个Class 对象
class Phone3 {
    //synchronized 锁的对象是方法的调用者！
    //static 静态方法
    //类只要加载就有了！ Class 模板
    public static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call() {
        System.out.println("打电话");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

答案：（4秒后，显示）1、发短信 2、打电话

类锁锁的是class类，全局唯一，所以谁先抢到锁，谁先执行

问题七：一个静态的同步方法，一个普通的同步方法，一个对象；先打印发短信还是打电话呢？

public class Demo4 {
    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static ,锁的是Class
        Phone4 phone = new Phone4();

        //锁的存在
        new Thread(() -> {
            phone.sendSms();
        }, "A").start();
        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone.call();
        }, "B").start();
    }
}

//Phone3 唯一的一个Class 对象
class Phone4 {
    //静态的同步方法
    public static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    //普通的同步方法
    public synchronized void call() {
        System.out.println("打电话");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

答案：1、打电话（4秒后，显示）2、发短信

因为用的都不是一个锁，一个是类锁，一个是锁的调用者（对象）。所以对象锁与类锁，是两把锁

问题八：一个静态的同步方法，一个普通的同步方法，两个对象；先打印发短信还是打电话呢？

public class Demo4 {
    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static ,锁的是Class
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
        //锁的存在
        new Thread(() -> {
            phone1.sendSms();
        }, "A").start();
        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone2.call();
        }, "B").start();
    }
}

//Phone3 唯一的一个Class 对象
class Phone4 {

    //静态的同步方法
    public static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    //普通的同步方法
    public synchronized void call() {
        System.out.println("打电话");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

答案：1、打电话（4秒后，显示）2、发短信

因为用的都不是一个锁，一个是类锁，一个是锁的调用者（对象）。所以对象锁与类锁，是两把锁