devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java synchronized类锁，对象锁详解_java synchronized锁对象

作者：2023面试高手 | 2024-03-23 01:10:33

赞

踩

java synchronized锁对象

参考原文链接：Java synchronized类锁，对象锁详解(转载整理)_student100000的博客-CSDN博客_java synchronized 类锁

目录

一、synchronized的用法

1.同步代码块（对象锁）

2、同步方法（对象锁）

3、静态方法（类锁）

 4、同步代码块（类锁）

二、对象锁和类锁

对象锁---synchronized修饰方法和代码块：

类锁---修饰静态方法和代码块

 类锁---对象锁

 

一、synchronized的用法

1.同步代码块（对象锁）

  1. public class Demo implements Runnable{
  2.  
  3.     @Override
  4.     public void run() {
  5.         /**
  6.          * 同步代码块形式--->锁为this，两个线程使用的锁是一样的，
  7.          * 线程1必须要等到线程2释放了该锁后，才能执行
  8.          */
  9.         synchronized (this) {
  10.             System.out.println(Thread.currentThread().getName() + "开始执行");
  11.             try {
  12.                 Thread.sleep(2000);
  13.             } catch (InterruptedException e) {
  14.                 e.printStackTrace();
  15.             }
  16.             System.out.println(Thread.currentThread().getName() + "执行结束");
  17.         }
  18.     }
  19.  
  20.     public static void main(String[] args) {
  21.         Demo demo = new Demo();
  22.         new Thread(demo,"线程1").start();
  23.         new Thread(demo,"线程2").start();
  24.     }
  25. }

 代码块中的synchronized(this)，指获取类Demo创建的实例对象demo中的内置锁（锁定当前代码块执行者），可以看到线程2必须要等到线程1释放了该锁后，才能执行。

2、同步方法（对象锁）

  1. public class Demo2 implements Runnable{
  2.  
  3.     @Override
  4.     public void run() {
  5.         method();
  6.     }
  7.  
  8.     public synchronized void method(){
  9.         System.out.println(Thread.currentThread().getName() + "开始执行");
  10.         try {
  11.             Thread.sleep(2000);
  12.         } catch (InterruptedException e) {
  13.             e.printStackTrace();
  14.         }
  15.         System.out.println(Thread.currentThread().getName() + "执行结束");
  16.     }
  17.  
  18.     public static void main(String[] args) {
  19.         Demo2 demo2 = new Demo2();
  20.         new Thread(demo2,"线程1").start();
  21.         new Thread(demo2,"线程2").start();
  22.     }
  23. }

 synchonized指定类demo2创建的实例对象demo2的内置锁（锁定当前方法调用者），可以看到线程2必须等到线程1释放了该锁后，才能执行。

  1. public class Demo2 implements Runnable{
  2.  
  3.     @Override
  4.     public void run() {
  5.         method();
  6.     }
  7.  
  8.     /**
  9.      * synchronized用在普通方法上，默认的所就是this，当前实例
  10.      */
  11.     public synchronized void method(){
  12.         System.out.println(Thread.currentThread().getName() + "开始执行");
  13.         try {
  14.             Thread.sleep(2000);
  15.         } catch (InterruptedException e) {
  16.             e.printStackTrace();
  17.         }
  18.         System.out.println(Thread.currentThread().getName() + "执行结束");
  19.     }
  20.  
  21.     public static void main(String[] args) {
  22.         Demo2 t1 = new Demo2();
  23.         Demo2 t2 = new Demo2();
  24.         new Thread(t1,"线程1").start();
  25.         new Thread(t2,"线程2").start();
  26.     }
  27. }

    或    

可能还有其他执行结果。

可以看到线程1和线程2的执行顺序不能保证，因为这两个线程获取的Demo2类的不同实例对象的不同内置锁。

3、静态方法（类锁）

  1. public class Demo3 implements Runnable{
  2.  
  3.     @Override
  4.     public void run() {
  5.         method();
  6.     }
  7.  
  8.     /**
  9.      * synchronized用在静态方法上，默认锁的就是当前所在的Class类，
  10.      * 所以无论是哪个线程访问它，需要的锁都只有一把
  11.      */
  12.     public static synchronized void method(){
  13.         System.out.println(Thread.currentThread().getName() + "执行了");
  14.         try {
  15.             Thread.sleep(2000);
  16.         } catch (InterruptedException e) {
  17.             e.printStackTrace();
  18.         }
  19.         System.out.println(Thread.currentThread().getName() + "结束了");
  20.     }
  21.  
  22.     public static void main(String[] args) {
  23.         Demo3 t1 = new Demo3();
  24.         Demo3 t2 = new Demo3();
  25.         new Thread(t1,"线程1").start();
  26.         new Thread(t2,"线程2").start();
  27.  
  28.     }
  29. }
  1. 线程1执行了
  2. 线程1结束了
  3. 线程2执行了
  4. 线程2结束了

上面这个例子，虽然类Demo3有两个不同的实例，但结果总是线程1先执行，然后线程2再执行。这是因为静态方法获取的是Demo3的类锁，和实例无关。且类锁只有一个，所以实现了同步。

 4、同步代码块（类锁）

  1. public class Demo implements Runnable{
  2.  
  3.     @Override
  4.     public void run() {
  5.         /**
  6.          * 所有线程需要的锁都是同一把
  7.          */
  8.         synchronized (Demo.class) {
  9.             System.out.println(Thread.currentThread().getName() + "开始执行");
  10.             try {
  11.                 Thread.sleep(1000);
  12.             } catch (InterruptedException e) {
  13.                 e.printStackTrace();
  14.             }
  15.             System.out.println(Thread.currentThread().getName() + "执行结束");
  16.         }
  17.     }
  18.  
  19.     public static void main(String[] args) {
  20.         Demo t1 = new Demo();
  21.         Demo t2 = new Demo();
  22.         new Thread(t1,"线程1").start();
  23.         new Thread(t2,"线程2").start();
  24.     }
  25. }

获取的是类Demo的类锁

二、对象锁和类锁

java的内置锁：每个Java对象都可以用做一个实现同步的锁，这些锁称为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。

java内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，直到线程B 释放这个锁，如果线程B不释放这个锁，那么线程A将永远等待下去。

Java的对象锁和类锁：Java的对象锁和类锁在锁的概念上基本上和内置锁是一致的，但是两个锁实际是有很大区别的，对象锁是用于对象实例方法，或者一个对象实例上的，类锁是用与类的静态方法或者一个类的class对象上的。我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。但是有一点必须注意的是，其实类锁只是一个概念上的东西，并不是真实存在的，它只是用来帮助我们理解锁定实例方法和静态方法的区别的。

对象锁---synchronized修饰方法和代码块：

  1. public class TestSynchronized {
  2.  
  3.     public void test1(){
  4.         /**
  5.          * synchronized修饰同步代码块
  6.          */
  7.         synchronized (this){
  8.             for (int i = 1;i < 6;i++){
  9.                 System.out.println(Thread.currentThread().getName() + " : " + i);
  10.                 try {
  11.                     Thread.sleep(500);
  12.                 } catch (InterruptedException e) {
  13.                     e.printStackTrace();
  14.                 }
  15.             }
  16.         }
  17.     }
  18.  
  19.     /**
  20.      * synchronized修饰非静态方法
  21.      */
  22.     public synchronized void test2(){
  23.         for (int i = 1;i < 6;i++){
  24.             System.out.println(Thread.currentThread().getName() + " : " + i);
  25.             try {
  26.                 Thread.sleep(500);
  27.             } catch (InterruptedException e) {
  28.                 e.printStackTrace();
  29.             }
  30.         }
  31.     }
  32.  
  33.     public static void main(String[] args) {
  34.         TestSynchronized demo = new TestSynchronized();
  35.         Thread test1 = new Thread(new Runnable() {
  36.             @Override
  37.             public void run() {
  38.                 demo.test1();
  39.             }
  40.         },"test1");
  41.         Thread test2 = new Thread(new Runnable() {
  42.             @Override
  43.             public void run() {
  44.                 demo.test2();
  45.             }
  46.         },"test2");
  47.         test1.start();
  48.         test2.start();
  49.     }
  50. }

 

 上述的代码，第一个方法用了同步代码块的方式进行同步，传入的对象实例是this，表明是当前对象；第二个方法是修饰方法的方式进行同步。因为第一个同步代码块传入的this，所以两个同步代码所需要的对象锁都是同一个TestSynchronized对象的锁，下面main方法开启两个线程，分别别调用test1()和test2()方法，那么两个线程都需要获得该对象锁，另一个线程必须等待。上面也给出了运行的结果可以看到：直到test1执行完毕，释放掉锁，test2线程才开始执行。

把test2方法的synchronized关键字去掉，执行结果会如何呢？

  1. test2 : 1
  2. test1 : 1
  3. test2 : 2
  4. test1 : 2
  5. test2 : 3
  6. test1 : 3
  7. test1 : 4
  8. test2 : 4
  9. test1 : 5
  10. test2 : 5

上面是执行结果，可以看到，结果输出是交替着进行输出的，这是因为，某个线程得到了对象锁，但是另一个线程还是可以访问没有进行同步的方法或者代码。进行了同步的方法（加锁方法）和没有进行同步的方法（普通方法）是互不影响的，一个线程进入了同步方法，得到了对象锁，其他线程还是可以访问那些没有同步的方法（普通方法）。原因在于：对象的内置锁和对象的状态之间是没有内在的关联的。当获取到与对象关联的内置锁时，并不能阻止其他线程访问该对象，当某个线程获得对象的锁之后，只能阻止其他线程获得同一个锁。

 总结：synchronized只是一个内置锁的加锁机制，当某个方法加上synchronized关键字后，就表明要获得该内置锁才能执行，但并不能阻止其他线程访问不需要获得该内置锁的方法。

类锁---修饰静态方法和代码块

  1. public class TestSynchronized {
  2.  
  3.     public void test1(){
  4.         /**
  5.          * synchronized修饰同步代码块,
  6.          * 传的是一个class对象
  7.          */
  8.         synchronized (TestSynchronized.class){
  9.             for (int i = 1;i < 6;i++){
  10.                 System.out.println(Thread.currentThread().getName() + " : " + i);
  11.                 try {
  12.                     Thread.sleep(500);
  13.                 } catch (InterruptedException e) {
  14.                     e.printStackTrace();
  15.                 }
  16.             }
  17.         }
  18.     }
  19.  
  20.     /**
  21.      * synchronized修饰静态方法
  22.      */
  23.     public static synchronized void test2(){
  24.         for (int i = 1;i < 6;i++){
  25.             System.out.println(Thread.currentThread().getName() + " : " + i);
  26.             try {
  27.                 Thread.sleep(500);
  28.             } catch (InterruptedException e) {
  29.                 e.printStackTrace();
  30.             }
  31.         }
  32.     }
  33.  
  34.     public static void main(String[] args) {
  35.         TestSynchronized demo = new TestSynchronized();
  36.         Thread test1 = new Thread(new Runnable() {
  37.             @Override
  38.             public void run() {
  39.                 demo.test1();
  40.             }
  41.         },"test1");
  42.         Thread test2 = new Thread(new Runnable() {
  43.             @Override
  44.             public void run() {
  45.                 TestSynchronized.test2();
  46.             }
  47.         },"test2");
  48.         test1.start();
  49.         test2.start();
  50.     }
  51. }
  1. test1 : 1
  2. test1 : 2
  3. test1 : 3
  4. test1 : 4
  5. test1 : 5
  6. test2 : 1
  7. test2 : 2
  8. test2 : 3
  9. test2 : 4
  10. test2 : 5

可以看到线程2要在线程1执行完之后，才开始执行，这是因为两个synchronized加的都是类锁，而且是同一个类的锁，一个类只有一把锁，所以加的是同一个类的同一把锁，所以要等待

 类锁---对象锁

  1. public class TestSynchronized {
  2.  
  3.     /**
  4.      * synchronized修饰非静态方法
  5.      */
  6.     public synchronized void test1(){
  7.         for (int i = 1;i < 6;i++){
  8.             System.out.println(Thread.currentThread().getName() + " : " + i);
  9.             try {
  10.                 Thread.sleep(500);
  11.             } catch (InterruptedException e) {
  12.                 e.printStackTrace();
  13.             }
  14.         }
  15.     }
  16.  
  17.     /**
  18.      * synchronized修饰静态方法
  19.      */
  20.     public static synchronized void test2(){
  21.         for (int i = 1;i < 6;i++){
  22.             System.out.println(Thread.currentThread().getName() + " : " + i);
  23.             try {
  24.                 Thread.sleep(500);
  25.             } catch (InterruptedException e) {
  26.                 e.printStackTrace();
  27.             }
  28.         }
  29.     }
  30.  
  31.     public static void main(String[] args) {
  32.         TestSynchronized demo = new TestSynchronized();
  33.         Thread test1 = new Thread(new Runnable() {
  34.             @Override
  35.             public void run() {
  36.                 demo.test1();
  37.             }
  38.         },"test1");
  39.         Thread test2 = new Thread(new Runnable() {
  40.             @Override
  41.             public void run() {
  42.                 TestSynchronized.test2();
  43.             }
  44.         },"test2");
  45.         test1.start();
  46.         test2.start();
  47.     }
  48. }
  1. test1 : 1
  2. test2 : 1
  3. test2 : 2
  4. test1 : 2
  5. test2 : 3
  6. test1 : 3
  7. test2 : 4
  8. test1 : 4
  9. test1 : 5
  10. test2 : 5

上面代码synchronized同时修饰静态方法和实例方法，但是运行结果是交替进行的，这证明了类锁和对象锁是两个不一样的锁，控制着不同的区域，它们是互不干扰的。同样，线程获得对象锁的同时，也可以获得该类锁，即同时获得两个锁，这是允许的。 

既然有了synchronized修饰方法的同步方式，为什么还需要synchronized修饰同步代码块的方式呢？

synchronized的缺陷：当某个线程进入同步方法获得对象锁，那么其他线程访问这里对象的同步方法时，必须等待或者阻塞，如果这个方法代码比较多，那等待线程的时间就会比较长，直到当前执行方法的线程执行完方法，释放锁，等待线程才可以获得锁去执行。如果使用同步代码块，它可以灵活的选择要同步的代码，而不用整个方法都加锁，这样可以提高代码执行效率，类似于Lock的lock()方法和unLock()方法优点。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/292140
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号