synchronized锁住的范围

傷城~ 2022-11-05 08:52 168阅读 0赞

> **关键词：**synchronized

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

**synchronized**是Java并发并发编程中提供了同步的关键字，可以保证原子性、可见性与有序性。synchronized是对某一具体的对象上锁。synchronized的使用方式包括：

*  在静态方法上使用

public static synchronized void m() {
        ......
    }

*  在实例方法上使用

public synchronized void m() {
        ......
    }

*  在方法代码块中使用

public void m() {
        ......
        synchronized (object) {
            ......
        }
        ......
    }

下面分别看看在上面三种使用方式，synchronized锁住的范围是什么？

**（1）验证：在静态方法上使用**

①如下在类SynObject中，静态同步方法staticSynMethod。在线程中使用Thread.sleep阻塞5秒，用于模拟方法执行的耗时操作，方便观察多个线程是否存在阻塞。

public class SynObject {
    
        public static synchronized void staticSynMethod() {
            System.out.println(Thread.currentThread().getName()+"开始执行，时间戳："+System.currentTimeMillis());
            try {
                Thread.sleep(5000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("staticSynMethod");
        }
    
    }

②编写验证方法：

验证1：

public class Main {
    
        public static void main(String[] args) {
    
            new Thread(()->{
    
                SynObject.staticSynMethod();
    
            }, "threadA").start();
    
            new Thread(()->{
    
                SynObject.staticSynMethod();
    
            }, "threadB").start();
    
        }
    
    }

直接使用SynObject类调用其静态方法，运行结果为下图所示。观察控制台输出以及时间戳，可以发现线程B是等待线程A执行完成staticSynMethod方法释放锁之后再执行的。（线程A与线程B哪个线程先执行，这个是不确定的，由系统的线程调度决定）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70][]

验证2：

public class Main {
    
        public static void main(String[] args) {
    
            new Thread(()->{
    
                SynObject synObject = new SynObject();
                synObject.staticSynMethod();
    
            }, "threadA").start();
    
            new Thread(()->{
    
                SynObject synObject = new SynObject();
                synObject.staticSynMethod();
    
            }, "threadB").start();
    
        }
    
    }

两个线程中分别创建SynObject对象，此时对象不同。观察控制台输出，现象和验证1中相同，线程B仍然是等待线程A执行完成方法staticSynMethod释放锁之后再执行的方法。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 1][]

从验证1和验证2中对比可以发现，对于静态的synchronized方法，对于该类的多个对象，虽然对象不同，但是在并发调用方法的时候，都会进行阻塞。可见当synchronized使用在静态方法上时，其锁住的不是实例对象，而是类对象，即Class对象。对于例子中就是SynObject.class。其效果相当于：

public synchronized void m() {
        synchronized (SynObject.class) {
            ......
        }
    }

**（2）验证：在实例方法上使用**

①在实例方法上使用synchronized：

public class SynObject {
    
        public synchronized void synMethod() {
            System.out.println(Thread.currentThread().getName()+"开始执行，时间戳："+System.currentTimeMillis());
            try {
                Thread.sleep(5000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("synMethod");
        }
        
    }

②编写验证方法：

验证1：

public class Main {
    
        public static void main(String[] args) {
    
            SynObject synObject = new SynObject();
    
            new Thread(()->{
    
                synObject.synMethod();
    
            }, "threadA").start();
    
            new Thread(()->{
    
                synObject.synMethod();
    
            }, "threadB").start();
    
        }
    
    }

线程A与线程B使用的是同一个synObject对象调用的同步方法。观察控制台输出，可以看见也会出现线程等待的现象，一个线程要等先执行方法的线程执行完成之后其才会执行方法。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 2][]

验证2：

public class Main {
    
        public static void main(String[] args) {
            
            new Thread(()->{
    
                SynObject synObject = new SynObject();
                synObject.synMethod();
    
            }, "threadA").start();
    
            new Thread(()->{
    
                SynObject synObject = new SynObject();
                synObject.synMethod();
    
            }, "threadB").start();
    
        }
    
    }

线程A与线程B使用了不同的synObject对象调用方法。此时观察控制台输出现象，不再出现阻塞等待的现象了。两个线程可以同时方法了。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 3][]

从验证1与验证2对比发现，在实例方法上使用synchronized，同一个对象调用方法会出现锁竞争，阻塞等待的现象。使用不同的对象就不会。此时synchronized锁住的就是当前对象了。其效果相当于：

public synchronized void m() {
        synchronized (this) {
            ......
        }
    }

**（3）验证：在方法代码块中使用**

在方法代码块中使用synchronized，对于synchronized(xx)，xx可以是任意对象，可以是Class对象，可以是this对象。若Class对象是当前类的Class对象，此时作用相当于在当前类的静态方法上使用synchronized。this对象作用相当于在当前类的实例方法上使用synchronized。对于这两种情况就不做验证了。此时验证使用成员变量。

①在方法代码块中使用synchronized(xx)，xx为类中的成员变量对象：

public class SynObject {
    
        private Object object = new Object();
    
        private Object object2 = new Object();
    
        public void method() {
            synchronized (object) {
                System.out.println(Thread.currentThread().getName()+"开始执行，时间戳："+System.currentTimeMillis());
                try {
                    Thread.sleep(5000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("method object");
            }
        }
    
        public void method2() {
            synchronized (object2) {
                System.out.println(Thread.currentThread().getName()+"开始执行，时间戳："+System.currentTimeMillis());
                try {
                    Thread.sleep(5000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("method2 object2");
            }
        }
    
    
    }

②编写验证方法。

验证1：

public class Main {
    
        public static void main(String[] args) {
    
            SynObject synObject = new SynObject();
    
            new Thread(()->{
    
                synObject.method();
    
            }, "threadA").start();
    
            new Thread(()->{
    
                synObject.method();
    
            }, "threadB").start();
    
        }
    
    }

线程A和线程B，使用同一个synObject对象，调用同一个方法。观察控制台输出现象，出现阻塞等待。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 4][]

验证2：

public class Main {
    
        public static void main(String[] args) {
    
            SynObject synObject = new SynObject();
    
            new Thread(()->{
    
                synObject.method();
    
            }, "threadA").start();
    
            new Thread(()->{
    
                synObject.method2();
    
            }, "threadB").start();
    
        }
    
    }

线程A与线程B使用同一个synObject对象，调用不同的方法。观察控制台输出现象，不会出现阻塞等待现象，方法可以同时被调用。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 5][]

验证3：

public class Main {
    
        public static void main(String[] args) {
    
    
    
            new Thread(()->{
    
                SynObject synObject = new SynObject();
                synObject.method();
    
            }, "threadA").start();
    
            new Thread(()->{
    
                SynObject synObject = new SynObject();
                synObject.method();
    
            }, "threadB").start();
    
        }
    
    }

线程A与线程B使用不同的synObject对象，调用同样的方法。观察控制台输出，没有出现阻塞等待现象。因为对于不同的synObject对象，成员变量object对象也是不同的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 6][]

从验证1,2,3中可以发现，synchronized使用在代码块中，锁住的是()中的对象本身。当进行方法调用时，多个线程竞争的是同一个对象就会出现阻塞等待的现象。

**总结：**

synchronized锁住的是对象。在静态方法上使用synchronized，锁住的是当前类的Class对象。在实例方法上使用synchronized，锁住的是对象，即this本身。在代码块中使用synchronized，锁住的就是()中的对象。当多个线程出现竞争的情况时，是对对象进行竞争，如果竞争的是同一个对象，就会阻塞等待。如果竞争的不是同一个对象，则不会阻塞等待，可以正常执行代码。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70]: /images/20221023/392af398c351486680b1346becd23d78.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 1]: /images/20221023/4eb8706e6d314d8fb8f3d9104f1896fe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 2]: /images/20221023/9f8ae7d59ab24217a182555b415a6a17.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 3]: /images/20221023/f5225a6f3b204a899ca711dc0c62492f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 4]: /images/20221023/1a7cd9b451e840a39a8f8a88e6bb17c2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 5]: /images/20221023/2472e975076b4946b73929b05b227d35.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 6]: /images/20221023/11de4d16211646b79f5a481d7a944774.png