synchronized对象锁与类锁用法&如何用synchronized锁字符串对象，这里面的坑要注意

逃离我推掉我的手 2024-04-21 19:08 56阅读 0赞

#### 文章目录 ####

*   *   *  一、概念
         *   *   *  1. 概念
                 *  2. 特性
             *  二、用法分类
             *   *  1. 按照修饰对象
                 *  2. 按照获取的锁分类
             *  三、代码实战
             *   *  1. 锁住实体中的非静态变量(对象锁)
                 *  2. 锁住实体中的静态变量(类锁)
                 *  3. 锁住无关对象
                 *  4. 锁住this对象(对象锁)
                 *  5. 锁住类对象(类锁)
                 *  6. 锁住非静态方法(对象锁)
                 *  7. 锁住静态方法(类锁)
             *  四、总结
     *  写在前面
     *  synchronized锁对象
     *   *  synchronized锁固定对象
         *  synchronized锁新建对象
         *  synchronized锁对象的业务id
         *   *  id已经存在字符串常量池中
             *  id不存在字符串常量池中
             *  手动将id存在字符串常量池中
     *  总结

#### 一、概念 ####

###### 1. 概念 ######

synchronized是java中的关键字，可以在需要线程安全的业务场景中进行使用，保证线程安全，它是利用锁机制来实现同步的。

###### 2. 特性 ######

*  原子性：同一时间只允许一个线程持有某个对象锁，对需同步的代码块(复合操作)进行访问，是一种排他的机制，因此被synchronized关键字修饰的同步代码块是无法被中途打断的，能保证代码的原子性
 *  可见性：synchronized关键字包括monitor enter和monitor exit两个JVM命令，它能保证在任何时候任何线程执行到monitor enter成功之前都必须从主内存中获取数据，而不是从缓存中，在monitor exit运行成功之后，共享变量被更新后的值必须刷入主内存。
 *  有序性：synchronized的指令严格遵守java happens-before规则，一个monitor exit指令之前必定要有一个monitor enter；这种顺序性是以程序的串行化执行换来的，在synchronized关键字所修饰的代码块中代码指令也会发生指令重排序的情况

##### 二、用法分类 #####

###### 1. 按照修饰对象 ######

*  修饰代码块
    
     *  synchronized(this|object) \{\}
     *  synchronized(类.class) \{\}
 *  修饰方法
    
     *  修饰非静态方法
     *  修饰静态方法

###### 2. 按照获取的锁分类 ######

*  获取对象锁
    
     *  synchronized(this|object) \{\}
     *  修饰非静态方法
 *  获取类锁
    
     *  synchronized(类.class) \{\}
     *  修饰静态方法
 *  对象锁与类锁的区别
    
     *  对象锁：每个实例都会有一个monitor对象，即Java对象的锁，类的对象可以有多个，所以每个对象有其独立的对象锁，互不干扰
     *  类锁：每个类只有一个Class对象，所以每个类只有一个类锁；类锁是加载类上的，而类信息是存在JVM方法区的，并且整个JVM只有一份，方法区又是所有线程共享的，所以类锁是所有线程共享的

##### 三、代码实战 #####

###### 1. 锁住实体中的非静态变量(对象锁) ######

@Slf4j
    public class SyncThread implements Runnable {
        
    
        private final Object lock = new Object();
    
        @Override
        public void run() {
        
            syncMethod();
        }
    
        private void syncMethod() {
        
            log.info("thread in");
            synchronized (lock) {
        
                try {
        
                    log.info("thread start");
                    TimeUnit.SECONDS.sleep(2);
                    log.info("thread end");
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

测试代码

public class SyncTest {
        
    
        public static void main(String[] args) {
        
            SyncThread syncThread = new SyncThread();
            new Thread(new SyncThread(), "thread-1").start();
            new Thread(new SyncThread(), "thread-2").start();
            new Thread(syncThread, "thread-3").start();
            new Thread(syncThread, "thread-4").start();
        }
    }

运行结果

![在这里插入图片描述][f79f0e5e63354a03a832bc7d5eef18a0.png]

结论：如果是同一个实例，就会按顺序访问，如果是不同实例，就可以同时访问

###### 2. 锁住实体中的静态变量(类锁) ######

@Slf4j
    public class SyncThread implements Runnable {
        
    
        private static final Object lock = new Object();
    
        @Override
        public void run() {
        
            syncMethod();
        }
    
        private void syncMethod() {
        
            log.info("thread in");
            synchronized (lock) {
        
                try {
        
                    log.info("thread start");
                    TimeUnit.SECONDS.sleep(2);
                    log.info("thread end");
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

运行结果

![在这里插入图片描述][5035b63fc65b4ca7b2a791c7652e48c8.png]

结论：所有实例按照顺序访问

###### 3. 锁住无关对象 ######

@Slf4j
    public class SyncThread implements Runnable {
        
    
        @Override
        public void run() {
        
            syncMethod();
        }
    
        private void syncMethod() {
        
            log.info("thread in");
            synchronized (new SyncThread()) {
        
                try {
        
                    log.info("thread start");
                    TimeUnit.SECONDS.sleep(2);
                    log.info("thread end");
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

运行结果

![在这里插入图片描述][7b283361886b4db3b166227bccb113a6.png]

结论：所有实例同时访问

###### 4. 锁住this对象(对象锁) ######

@Slf4j
    public class SyncThread implements Runnable {
        
    
        @Override
        public void run() {
        
            syncMethod();
        }
    
        private void syncMethod() {
        
            log.info("thread in");
            synchronized (this) {
        
                try {
        
                    log.info("thread start");
                    TimeUnit.SECONDS.sleep(2);
                    log.info("thread end");
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

运行结果

![在这里插入图片描述][791b5ffa85eb4e87b946aa5ed6c6cae6.png]

结论：如果是同一个实例，就会按顺序访问，如果是不同实例，就可以同时访问

###### 5. 锁住类对象(类锁) ######

@Slf4j
    public class SyncThread implements Runnable {
        
    
        @Override
        public void run() {
        
            syncMethod();
        }
    
        private void syncMethod() {
        
            log.info("thread in");
            synchronized (SyncThread.class) {
        
                try {
        
                    log.info("thread start");
                    TimeUnit.SECONDS.sleep(2);
                    log.info("thread end");
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

执行结果

![在这里插入图片描述][8403d3f712354d098969e04ff659d56f.png]

结论：所有实例按照顺序访问

###### 6. 锁住非静态方法(对象锁) ######

@Slf4j
    public class SyncThread implements Runnable {
        
    
        @Override
        public void run() {
        
            syncMethod();
        }
    
        private synchronized void syncMethod() {
        
            log.info("thread in");
            try {
        
                log.info("thread start");
                TimeUnit.SECONDS.sleep(2);
                log.info("thread end");
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    }

运行结果

![在这里插入图片描述][f8bbf8c6ed08485fb14621717e6fbfeb.png]

结论：如果是同一个实例，就会按顺序访问，如果是不同实例，就可以同时访问

###### 7. 锁住静态方法(类锁) ######

@Slf4j
    public class SyncThread implements Runnable {
        
    
        @Override
        public void run() {
        
            syncMethod();
        }
    
        private synchronized static void syncMethod() {
        
            log.info("thread in");
            try {
        
                log.info("thread start");
                TimeUnit.SECONDS.sleep(2);
                log.info("thread end");
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    }

运行结果

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-57QwoVPX-1657705165771)(C:\\Users\\y00577086\\AppData\\Roaming\\Typora\\typora-user-images\\image-20220713172345664.png)\]][img-57QwoVPX-1657705165771_C_Users_y00577086_AppData_Roaming_Typora_typora-user-images_image-20220713172345664.png]

结论：所有实例按照顺序访问

##### 四、总结 #####

![在这里插入图片描述][07040c5f2cc74d7690a257452d24002b.png]

--------------------

### 写在前面 ###

我们使用synchronized通常都有这样一个误区：synchronized锁住的代码块一定是所有线程都互斥的。  
其实不然！

首先我们明确一点，**synchronized锁住的是一个对象！如果锁住的这个对象，在多个线程中相同，那么这些线程访问synchronized修饰的代码块时，总是互斥的**。  
但是！**如果锁住的这个对象，在多个线程中是不同的，那么这些线程访问synchronized修饰的代码块，是不会互斥的！**

### synchronized锁对象 ###

固定测试类

class T1{
        
        public T1(String id) {
        
            this.id = id;
        }
    
        private String id;
    
        public String getId() {
        
            return id;
        }
    
        public void setId(String id) {
        
            this.id = id;
        }
    }

#### synchronized锁固定对象 ####

public class SynchronzedStringTest {
        
    
        private static Object lock = new Object();
    
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() ->{
        
                try {
        
                    m1();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }).start();
            m1();
    
            Thread.sleep(10000);
        }
    
        /**
         * 加锁
         */
        public static void m1() throws InterruptedException {
        
            System.out.println(Thread.currentThread().getName() + "进来了" + new Date());
            synchronized (lock) {
        
                System.out.println(Thread.currentThread().getName() + "获取到锁" + new Date());
                Thread.sleep(2000);
            }
            System.out.println(Thread.currentThread().getName() + "结束了" + new Date());
        }
    }

执行结果：

main进来了Mon Aug 15 10:19:47 CST 2022
    main获取到锁Mon Aug 15 10:19:47 CST 2022
    Thread-0进来了Mon Aug 15 10:19:47 CST 2022
    Thread-0获取到锁Mon Aug 15 10:19:49 CST 2022
    main结束了Mon Aug 15 10:19:49 CST 2022
    Thread-0结束了Mon Aug 15 10:19:51 CST 2022

我们可以看到，Thread-0线程和main线程，执行synchronized代码块是互斥的。  
但是，这种加锁方式太笨重，每一个线程执行到synchronized代码块都会互斥。

#### synchronized锁新建对象 ####

public class SynchronzedStringTest {
        
    
        public static void main(String[] args) throws InterruptedException {
        
            T1 t1 = new T1("t1");
            T1 t2 = new T1("t1");
            new Thread(() ->{
        
                try {
        
                    m1(t1);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }).start();
            m1(t2);
    
            Thread.sleep(10000);
        }
    
        /**
         * 加锁
         */
        public static void m1(T1 t1) throws InterruptedException {
        
            System.out.println(Thread.currentThread().getName() + "进来了" + new Date());
            synchronized (t1) {
        
                System.out.println(Thread.currentThread().getName() + "获取到锁" + new Date());
                Thread.sleep(2000);
            }
            System.out.println(Thread.currentThread().getName() + "结束了" + new Date());
        }
    }

执行结果：

main进来了Mon Aug 15 10:45:40 CST 2022
    main获取到锁Mon Aug 15 10:45:40 CST 2022
    Thread-0进来了Mon Aug 15 10:45:40 CST 2022
    Thread-0获取到锁Mon Aug 15 10:45:40 CST 2022
    main结束了Mon Aug 15 10:45:42 CST 2022
    Thread-0结束了Mon Aug 15 10:45:42 CST 2022

我们可以看到，Thread-0线程和main线程，执行synchronized代码块并不互斥。  
因为两个线程传参的T1其实是两个不同的对象（虽然对象中的id值是一样的），所以synchronized虽然加锁了，但是由于两个对象是不一样的，所以两个线程并不会互斥。

#### synchronized锁对象的业务id ####

##### id已经存在字符串常量池中 #####

public class SynchronzedStringTest {
        
    
        public static void main(String[] args) throws InterruptedException {
        
            T1 t1 = new T1("t1");
            T1 t2 = new T1("t1");
            new Thread(() ->{
        
                try {
        
                    m1(t1);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }).start();
            m1(t2);
    
            Thread.sleep(10000);
        }
    
        /**
         * 加锁
         */
        public static void m1(T1 t1) throws InterruptedException {
        
            System.out.println(Thread.currentThread().getName() + "进来了" + new Date());
            synchronized (t1.getId()) {
        
                System.out.println(Thread.currentThread().getName() + "获取到锁" + new Date());
                Thread.sleep(2000);
            }
            System.out.println(Thread.currentThread().getName() + "结束了" + new Date());
        }
    }

执行结果：

Thread-0进来了Mon Aug 15 10:48:11 CST 2022
    Thread-0获取到锁Mon Aug 15 10:48:11 CST 2022
    main进来了Mon Aug 15 10:48:11 CST 2022
    main获取到锁Mon Aug 15 10:48:13 CST 2022
    Thread-0结束了Mon Aug 15 10:48:13 CST 2022
    main结束了Mon Aug 15 10:48:15 CST 2022

我们可以发现，Thread-0线程和main线程，执行synchronized代码块是互斥的。  
因为synchronized锁住的字符串，其实是已经定义在字符串常量池中的。

其中t1和t2中显式定义的id，已经存在了字符串常量池中，而t1和t2的id，在字符串常量池中的指向是一致的，所以synchronized锁住的字符串被认为是同一个对象。

##### id不存在字符串常量池中 #####

public class SynchronzedStringTest {
        
    
        public static void main(String[] args) throws InterruptedException {
        
            String s1 = "a";
            String s2 = "b";
            T1 t1 = new T1(s1 + s2);
            T1 t2 = new T1(s1 + s2);
            new Thread(() ->{
        
                try {
        
                    m1(t1);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }).start();
            m1(t2);
    
            Thread.sleep(10000);
        }
    
        /**
         * 加锁
         */
        public static void m1(T1 t1) throws InterruptedException {
        
            System.out.println(Thread.currentThread().getName() + "进来了" + new Date());
            synchronized (t1.getId()) {
        
                System.out.println(Thread.currentThread().getName() + "获取到锁" + new Date());
                Thread.sleep(2000);
            }
            System.out.println(Thread.currentThread().getName() + "结束了" + new Date());
        }
    }

执行结果：

Thread-0进来了Mon Aug 15 10:52:41 CST 2022
    Thread-0获取到锁Mon Aug 15 10:52:41 CST 2022
    main进来了Mon Aug 15 10:52:41 CST 2022
    main获取到锁Mon Aug 15 10:52:41 CST 2022
    Thread-0结束了Mon Aug 15 10:52:43 CST 2022
    main结束了Mon Aug 15 10:52:43 CST 2022

我们可以发现，Thread-0线程和main线程，执行synchronized代码块不是互斥的。  
这是因为虽然t1和t2的id都是一样的，但是字符串\[a+b\] 最终的结果实际是new 的新的String，并不会存在字符串常量池中，所以synchronized认为其锁住的字符串其实并不是同一个对象。

##### 手动将id存在字符串常量池中 #####

public class SynchronzedStringTest {
        
    
        public static void main(String[] args) throws InterruptedException {
        
            String s1 = "a";
            String s2 = "b";
            T1 t1 = new T1(s1 + s2);
            T1 t2 = new T1(s1 + s2);
            new Thread(() ->{
        
                try {
        
                    m1(t1);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }).start();
            m1(t2);
    
            Thread.sleep(10000);
        }
    
        /**
         * 加锁
         */
        public static void m1(T1 t1) throws InterruptedException {
        
            System.out.println(Thread.currentThread().getName() + "进来了" + new Date());
            synchronized (t1.getId().intern()) {
        
                System.out.println(Thread.currentThread().getName() + "获取到锁" + new Date());
                Thread.sleep(2000);
            }
            System.out.println(Thread.currentThread().getName() + "结束了" + new Date());
        }
    }

执行结果：

Thread-0进来了Mon Aug 15 10:58:48 CST 2022
    Thread-0获取到锁Mon Aug 15 10:58:48 CST 2022
    main进来了Mon Aug 15 10:58:48 CST 2022
    Thread-0结束了Mon Aug 15 10:58:50 CST 2022
    main获取到锁Mon Aug 15 10:58:50 CST 2022
    main结束了Mon Aug 15 10:58:52 CST 2022

我们可以发现，Thread-0线程和main线程，执行synchronized代码块是互斥的。  
因为我们调用了.intern()方法，将字符串统一放到字符串常量池中管理，相同的字符串代表的对象地址是一样的。

### 总结 ###

synchronized是一个对象锁，在单机环境下，我们最好不要使用固定的对象进行加锁，使用业务id对指定业务进行加锁可以提高很多并发量。

**集群环境下还是不要使用synchronized了。**

[f79f0e5e63354a03a832bc7d5eef18a0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/f2d14dcfcdc148cfa3cf519e9606f1ac.png
[5035b63fc65b4ca7b2a791c7652e48c8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/80324df005b14c21953ecee892b36db5.png
[7b283361886b4db3b166227bccb113a6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/6785b2181fee45bfb3198457f5bfe5d8.png
[791b5ffa85eb4e87b946aa5ed6c6cae6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/251f5ae259e64d338cddc019461991e8.png
[8403d3f712354d098969e04ff659d56f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/aa7794a02c694026969a5547dac64d59.png
[f8bbf8c6ed08485fb14621717e6fbfeb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/ae5a4657617b4ebc8f450d91e6fde1eb.png
[img-57QwoVPX-1657705165771_C_Users_y00577086_AppData_Roaming_Typora_typora-user-images_image-20220713172345664.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/fdefa76b358d4487a5b982aed9a8b250.png
[07040c5f2cc74d7690a257452d24002b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/c91efe56c7f14b00b613a0bf9c9f6d86.png