深入理解Synchronized--对象锁、类锁（看完这篇就够了）

ゞ浴缸里的玫瑰 2021-11-22 09:16 274阅读 0赞

# Synchronized一般用来修饰同步方法和同步代码块，锁的是对象实例（对象锁）；在代码块中修饰类.Class或者静态方法时，锁的是Class对象，所以存在着对象锁、类锁区别。 #

## 一.Synchronized方法锁（也叫对象锁） ##

1.修饰在方法上，多个线程调用同一个对象的同步方法会阻塞，调用不同对象的同步方法不会阻塞。

public synchronized void test1() {
               int i = 3;
               while (i-- > 0) {
                   System.out.println(Thread.currentThread().getName() + " : " + i);
                   try {
                       Thread.sleep(500);
                   } catch (InterruptedException ie) {
                   }
               }
       }

2.修饰代码块，这个this就是指当前对象，多个线程调用同一个对象的同步方法会阻塞，调用不同对象的同步方法不会阻塞。

public void test2() {
           synchronized (this) {
               int i = 3;
               while (i-- > 0) {
                   System.out.println(Thread.currentThread().getName() + " : " + i);
                   try {
                       Thread.sleep(500);
                   } catch (InterruptedException ie) {
                   }
               }
           }
       }

3 测试：

（1）多个线程调用同一对象的同步方法

import lombok.extern.slf4j.Slf4j;
    @Slf4j
    public class Test {
        public static void main(String[] args) {
            Test t1 = new Test();
            Test t2 = new Test();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    t1.test2();
                }
            }).start();
    
            new Thread((new Runnable() {
                @Override
                public void run() {
                    t1.test1();
                    //test1.test2(); 运行结果都一样 
                }
            })).start();
        }
    }
    
    //结果依次执行
    2020-12-21 18:08:41.973  INFO 60634 --- [       Thread-9] com.test                : Thread-9:2
    2020-12-21 18:08:42.974  INFO 60634 --- [       Thread-9] com.test                : Thread-9:1
    2020-12-21 18:08:43.975  INFO 60634 --- [       Thread-9] com.test                : Thread-9:0
    2020-12-21 18:08:44.975  INFO 60634 --- [      Thread-10] com.test                : Thread-10:2
    2020-12-21 18:08:45.976  INFO 60634 --- [      Thread-10] com.test                : Thread-10:1
    2020-12-21 18:08:46.976  INFO 60634 --- [      Thread-10] com.test                : Thread-10:0

（2）多个线程调用不同对象的同步方法

import lombok.extern.slf4j.Slf4j;
    @Slf4j
    public class Test {
        public static void main(String[] args) {
            Test t1 = new Test();
            Test t2 = new Test();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    t1.test2();
                }
            }).start();
    
            new Thread((new Runnable() {
                @Override
                public void run() {
                    t2.test1();
                    //test2.test2(); 运行结果都一样 
                }
            })).start();
        }
    }
    
    //结果是交替执行
    2020-12-21 18:10:54.052  INFO 62547 --- [       Thread-8] com.test                : Thread-8:2
    2020-12-21 18:10:54.052  INFO 62547 --- [       Thread-9] com.test                : Thread-9:2
    2020-12-21 18:10:55.053  INFO 62547 --- [       Thread-8] com.test                : Thread-8:1
    2020-12-21 18:10:55.054  INFO 62547 --- [       Thread-9] com.test                : Thread-9:1
    2020-12-21 18:10:56.053  INFO 62547 --- [       Thread-8] com.test                : Thread-8:0
    2020-12-21 18:10:56.055  INFO 62547 --- [       Thread-9] com.test                : Thread-9:0

## 结论：Synchronized修饰同步代码块、普通方法时，多个线程调用同一对象的同步方法会阻塞，调用不同对象的同步方法不会阻塞。 ##

## 二.Synchronized类锁 ##

//修饰静态方法
        public synchronized static void test1(){
            int i = 3;
            while (i-- >0){
                log.info(Thread.currentThread().getName()+":"+i);
                try{
                    Thread.sleep(1000);
                }catch (Exception e){
    
                }
            }
        }
        //修饰Class
        public void test2(){
            synchronized (Test.class){
                int i=3;
                while (i-- >0){
                    log.info(Thread.currentThread().getName()+":"+i);
                    try{
                        Thread.sleep(1000);
                    }catch (Exception e){
    
                    }
                }
            }
        }
        //普通方法
        public void test3(){
            int i=3;
            while (i-- >0){
                log.info(Thread.currentThread().getName()+":"+i);
                try{
                    Thread.sleep(1000);
                }catch (Exception e){
    
                }
            }
        }

测试：

（1）多个线程，同时类的静态方法

public static void main(String[] args) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Test.test1();
                }
            }).start();
    
            new Thread((new Runnable() {
                @Override
                public void run() {
                    Test.test1();
                }
            })).start();
        }
    
    
    //结果依次执行
    2020-12-21 18:28:05.312  INFO 77231 --- [       Thread-9] com.Test                : Thread-9:2
    2020-12-21 18:28:06.312  INFO 77231 --- [       Thread-9] com.Test                : Thread-9:1
    2020-12-21 18:28:07.312  INFO 77231 --- [       Thread-9] com.Test                : Thread-9:0
    2020-12-21 18:28:08.313  INFO 77231 --- [      Thread-10] com.Test                : Thread-10:2
    2020-12-21 18:28:09.314  INFO 77231 --- [      Thread-10] com.Test                : Thread-10:1
    2020-12-21 18:28:10.314  INFO 77231 --- [      Thread-10] com.Test                : Thread-10:0

（2）多个线程，先调用锁的Test.class方法，再调用锁的静态方法。

public static void main(String[] args) {
            Test t1 = new Test();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    t1.test1();
                    //t1.test2();结果都一样
                }
            }).start();
    
            new Thread((new Runnable() {
                @Override
                public void run() {
                    Test.test1();
                }
            })).start();
        }
    
    //结果依次执行
    2020-12-21 18:36:55.316  INFO 84279 --- [       Thread-9] com.Test                : Thread-9:2
    2020-12-21 18:36:56.317  INFO 84279 --- [       Thread-9] com.Test                : Thread-9:1
    2020-12-21 18:36:57.317  INFO 84279 --- [       Thread-9] com.Test                : Thread-9:0
    2020-12-21 18:36:58.318  INFO 84279 --- [      Thread-10] com.Test                : Thread-10:2
    2020-12-21 18:36:59.319  INFO 84279 --- [      Thread-10] com.Test                : Thread-10:1
    2020-12-21 18:37:00.319  INFO 84279 --- [      Thread-10] com.Test                : Thread-10:0

（3）多个线程调用不同对象实例的同步方法

public static void main(String[] args) {
            Test t1 = new Test();
            Test t2 = new Test();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    t1.test1();
                }
            }).start();
    
            new Thread((new Runnable() {
                @Override
                public void run() {
                    t2.test1();
                    //t2.test2();结果都一样
                }
            })).start();
        }
    
    //结果依次执行
    2020-12-21 18:36:55.316  INFO 84279 --- [       Thread-9] com.Test                : Thread-9:2
    2020-12-21 18:36:56.317  INFO 84279 --- [       Thread-9] com.Test                : Thread-9:1
    2020-12-21 18:36:57.317  INFO 84279 --- [       Thread-9] com.Test                : Thread-9:0
    2020-12-21 18:36:58.318  INFO 84279 --- [      Thread-10] com.Test                : Thread-10:2
    2020-12-21 18:36:59.319  INFO 84279 --- [      Thread-10] com.Test                : Thread-10:1
    2020-12-21 18:37:00.319  INFO 84279 --- [      Thread-10] com.Test                : Thread-10:0

（4）多个线程，一类调用普通方法，一类调用同步方法

public static void main(String[] args) {
            Test t1 = new Test();
            Test t2 = new Test();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Test.test3();
                }
            }).start();
    
            new Thread((new Runnable() {
                @Override
                public void run() {
                    t1.test1();
                    //t1.test2(),t2.test1(),t2.test2() 结果都一样
                }
            })).start();
        }
    
    //结果时交替执行
    2020-12-21 18:47:13.940  INFO 92788 --- [       Thread-8] com.Test                : Thread-8:2
    2020-12-21 18:47:13.940  INFO 92788 --- [       Thread-9] com.Test                : Thread-9:2
    2020-12-21 18:47:14.940  INFO 92788 --- [       Thread-8] com.Test                : Thread-8:1
    2020-12-21 18:47:14.941  INFO 92788 --- [       Thread-9] com.Test                : Thread-9:1
    2020-12-21 18:47:15.941  INFO 92788 --- [       Thread-8] com.Test                : Thread-8:0
    2020-12-21 18:47:15.942  INFO 92788 --- [       Thread-9] com.Test                : Thread-9:0

## 结论：在代码块中修饰类.Class时或者修饰静态方法时，多个线程，调用类的同步静态方法或对象实例的同步方法，都会阻塞；除非其他线程调用类的普通方法，才不会阻塞。 ##

## 总结  ##

1，对于对象锁，不同对象实例调用同步方法不会阻塞，而类锁，除非调用普通方法才不会阻塞。

2，对象锁比类锁范围更小一些，类锁注意使用。

\-------------------------------------------------------------------------------------------------