JUC并发编程学习笔记（四）8锁现象

8锁现象

八锁->就是关于锁的八个问题

锁是什么，如何判断锁的是谁

对象、class模板
深刻理解锁
锁的东西无外乎就两样：1、同步方法的调用者，2、Class模板。
同一个锁中，只有当前线程资源释放后才会被下一个线程所接手。
同步方法的调用者是两个不同的实例时，互不相关。
静态同步方法(static)锁的是整个Class模板，和同步方法的调用者也不是同一个锁；切Class模板在Java程序中唯一。
代码示例
1、浅浅理解锁的作用
同一把锁中根据执行先后释放资源，保证一个资源的使用顺序

1. package org.example.phone;
3. import java.util.concurrent.TimeUnit;
5. public class Test1 {
6.     public static void main(String[] args) {
7. //        标准情况下，打印顺序为 1、发短信，2、打电话
8. //        给sendMsg内部延迟四秒执行，执行顺序依旧是 1、发短信，2、打电话
9. //        可知，并非是我们所想的，A线程在前面就先执行，而是锁的机制导致了这种情况
10. //        phone1只创建了一个对象，所以这个对象的锁只有一把，谁先拿到就是谁先执行
11. //        锁的对象是该方法的调用者，即phone1
12.         Phone1 phone1 = new Phone1();
13.         new Thread(()->{
14.             phone1.sendMsg();
15.         },"A").start();
17.         try {
18.             TimeUnit.SECONDS.sleep(1);
19.         } catch (InterruptedException e) {
20.             throw new RuntimeException(e);
21.         }
23.         new Thread(()->{
24.             phone1.call();
25.         },"B").start();
26.     }
27. }
28. class Phone1{
29. //    synchronized锁的对象是方法的调用者，Phone1只new了一个对象，所以锁的是new出来的整个对象
30.     public synchronized void sendMsg(){
32.         try {
33.             TimeUnit.SECONDS.sleep(4);
34.         } catch (InterruptedException e) {
35.             throw new RuntimeException(e);
36.         }
37.         System.out.println("发短信");
38.     }
39.     public synchronized void call(){
40.         System.out.println("打电话");
41.     }
42. }

复制代码

2、区分锁的对象
不同的实例使用的锁并非同一把，所以也无法同时锁定某个固定的资源、无法对同一资源进行有顺序的操作

1. package org.example.phone;
3. import java.util.concurrent.TimeUnit;
5. public class Test3 {
6.     public static void main(String[] args) {
7. //        标准情况下，打印顺序为 1、发短信，2、打电话
8. //        给sendMsg内部延迟四秒执行，执行顺序依旧是 1、发短信，2、打电话
9. //        可知，并非是我们所想的，A线程在前面就先执行，而是锁的机制导致了这种情况
10. //        phone1只创建了一个对象，所以这个对象的锁只有一把，谁先拿到就是谁先执行
11. //        锁的对象是该方法的调用者，即phone1
13. //        调用两个不同对象的方法，锁的是两个不同的对象，此时先出现打电话，说明不同对象之间的锁互不影响
14.         Phone3 phone3_1 = new Phone3();
15.         Phone3 phone3_2 = new Phone3();
16.         new Thread(()->{
17.             phone3_1.sendMsg();
18.         },"A").start();
20.         try {
21.             TimeUnit.SECONDS.sleep(1);
22.         } catch (InterruptedException e) {
23.             throw new RuntimeException(e);
24.         }
26.         new Thread(()->{
27.             phone3_2.call();
28.         },"B").start();
29.     }
30. }
31. class Phone3{
32.     //    synchronized锁的对象是方法的调用者，Phone1只new了一个对象，所以锁的是new出来的整个对象
33.     public synchronized void sendMsg(){
35.         try {
36.             TimeUnit.SECONDS.sleep(4);
37.         } catch (InterruptedException e) {
38.             throw new RuntimeException(e);
39.         }
40.         System.out.println("发短信");
41.     }
42.     public synchronized void call(){
43.         System.out.println("打电话");
44.     }
45.     //    当在资源类中添加了一个普通方法后，先输出hello
46. //    没有锁，不是同步方法，不受锁的影响
47.     public void hello(){
48.         System.out.println("Hello");
49.     }
50. }

复制代码

3、了解锁的参与者
只有同步方法参与锁，普通方法依旧按照java执行顺序执行

1. package org.example.phone;
3. import java.util.concurrent.TimeUnit;
5. public class Test2 {
6.     public static void main(String[] args) {
7. //        标准情况下，打印顺序为 1、发短信，2、打电话
8. //        给sendMsg内部延迟四秒执行，执行顺序依旧是 1、发短信，2、打电话
9. //        可知，并非是我们所想的，A线程在前面就先执行，而是锁的机制导致了这种情况
10. //        phone1只创建了一个对象，所以这个对象的锁只有一把，谁先拿到就是谁先执行
11. //        锁的对象是该方法的调用者，即phone1
12.         Phone2 phone2 = new Phone2();
13.         new Thread(()->{
14.             phone2.sendMsg();
15.         },"A").start();
17.         try {
18.             TimeUnit.SECONDS.sleep(1);
19.         } catch (InterruptedException e) {
20.             throw new RuntimeException(e);
21.         }
23.         new Thread(()->{
24.             phone2.hello();
25.         },"B").start();
26.     }
27. }
28. class Phone2{
29.     //    synchronized锁的对象是方法的调用者，Phone1只new了一个对象，所以锁的是new出来的整个对象
30.     public synchronized void sendMsg(){
32.         try {
33.             TimeUnit.SECONDS.sleep(4);
34.         } catch (InterruptedException e) {
35.             throw new RuntimeException(e);
36.         }
37.         System.out.println("发短信");
38.     }
39.     public synchronized void call(){
40.         System.out.println("打电话");
41.     }
42. //    当在资源类中添加了一个普通方法后，先输出hello
43. //    没有锁，不是同步方法，不受锁的影响
44.     public void hello(){
45.         System.out.println("Hello");
46.     }
47. }

复制代码

4、明白锁能锁谁
锁只能锁两个东西，一个是同步方法的调用者，一个是整个Class模板（全局唯一），一旦使用static创建静态同步方法，那么该方法的锁锁的就是全局唯一的Class模板，并且在反射时就已经被创建了

1. package org.example.phone;
3. import java.util.concurrent.TimeUnit;
5. public class Test4 {
6.     public static void main(String[] args) {
7. //        两个对象的Class类模板只有一个;static，锁的是Class
8.         Phone4 phone4_1 = new Phone4();
9.         Phone4 phone4_2 = new Phone4();
10.         new Thread(()->{
11.             phone4_1.sendMsg();
12.         },"A").start();
14.         try {
15.             TimeUnit.SECONDS.sleep(1);
16.         } catch (InterruptedException e) {
17.             throw new RuntimeException(e);
18.         }
20.         new Thread(()->{
21.             phone4_2.call();
22.         },"B").start();
23.     }
24. }
25. class Phone4{
26. //    synchronized锁的对象是方法的调用者
27. //    注:增加了static静态方法 此时调用该方法的就变成了Phone4的反射对象，全局唯一
28. //    此时锁的就是Class模板了，即不管你有几个调用者，都在同一个锁
29. //    static方法类一加载就有了！锁的是Class
30.     public static synchronized void sendMsg(){
32.         try {
33.             TimeUnit.SECONDS.sleep(4);
34.         } catch (InterruptedException e) {
35.             throw new RuntimeException(e);
36.         }
37.         System.out.println("发短信");
38.     }
39.     public static synchronized void call(){
40.         System.out.println("打电话");
41.     }
42. }

复制代码

5、深入理解锁的是谁
静态同步方法和普通同步方法在一起使用时，锁的并非同一对象，所以打印顺序也时按java的执行顺序来，并不存在锁定资源的情况

1. package org.example.phone;
3. import java.util.concurrent.TimeUnit;
4. /*
5. * 1、一个静态同步方法，一个普通同步方法，先打印发短信还是打电话
6. *   两个方法一个锁的是Class模板，一个锁的是调用者，锁的不是同一对象，所以延迟四秒的静态同步方法后打印，延迟一秒的普通同步方法先打印
7. *
8. * */
9. public class Test5 {
10.     public static void main(String[] args) {
12.         Phone5 phone5_1 = new Phone5();
13. //        Phone5 phone5_2 = new Phone5();
14.         new Thread(()->{
15.             phone5_1.sendMsg();
16.         },"A").start();
18.         try {
19.             TimeUnit.SECONDS.sleep(1);
20.         } catch (InterruptedException e) {
21.             throw new RuntimeException(e);
22.         }
24.         new Thread(()->{
25.             phone5_1.call();
26.         },"B").start();
27.     }
28. }
29. class Phone5{
30. //    锁的是Class模板
31.     public static synchronized void sendMsg(){
33.         try {
34.             TimeUnit.SECONDS.sleep(4);
35.         } catch (InterruptedException e) {
36.             throw new RuntimeException(e);
37.         }
38.         System.out.println("发短信");
39.     }
40. //    锁的是调用者
41.     public synchronized void call(){
42.         System.out.println("打电话");
43.     }
44. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！