Java中synchronized关键字的使用

对于关键字synchronized，研究起来，发现还是有许多让自己模糊的地方，网上也有很多篇博客对synchronized关键字的使用讲解的相当好，自己也受益匪浅。自己之所以还写一篇博客来介绍synchronized的目的只有一个：加深自己对synchronized的理解。

写博客有时候确实是一个好的东西，往往研究某个知识点的时候，自己觉得弄懂了，但是过几天查不多就忘了模糊了，而写博客可以增加对知识点的理解和加深知识的记忆。

synchronized关键字是解决多线程并发同步的方法之一。

synchronized可以修饰如下几个方面。

1、修饰一个代码块，作用的对象是调用这个代码块的对象

2、修饰一个方法，作用的对象是调用这个方法的对象

3、修饰一个静态方法，作用的对象是静态方法所属的类的所有对象

4、修饰一个类，作用的对象是该类的所用对象。

下面一一进行介绍

1、synchronized修饰一个代码块

1.1 一个线程访问一个对象obj中的synchronize(this)同步代码块时，其它线程试图访问该对象obj的synchronize(this)同步块时将会被阻塞。

看下面这个例子

Demo1

        class MyThread implements Runnable{
            private static final int NUM = 3;
            @Override
            public void run() {
                synchronized(this){
                    for(int i =0;i<NUM;i++){
                        System.out.println(Thread.currentThread().getName()+"  running .....");
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
    
                }
            }
    
        }

测试代码如下：

        public class SyncCodeBlock {
    
            public static void main(String[] args) {
                MyThread mt = new MyThread();
                new Thread(mt,"Thread1").start();
                new Thread(mt,"Thread2").start();
            }
    
        }

运行结果：

    Thread2  running .....
    Thread2  running .....
    Thread2  running .....
    Thread1  running .....
    Thread1  running .....
    Thread1  running .....

这里，名字为Thread1、Thread2的两个线程都想访问对象mt的同步块synchronized(this),由于只有一个锁，谁拿到的这个锁就该谁访问，也就是说，在任一时刻只能有一个线程访问这一同步代码块。例如，当Thread1线程拿到锁正在执行run里面的代码时，名字为Thread2的线程也想访问同一对象mt的同步块synchroized(this)的同步块将会被阻塞，只有等Thread1访问结束之后释放该对象锁Thread2拿到该对象锁才能访问。

如果我们将测试代码该为如下：

        public static void main(String[] args){
            MyThread mt = new MyThread();
            MyThread mt2 = new MyThread();
            new Thread(mt,"Thread1").start();
            new Thread(mt2,"Thread2").start();
        }

结果如下：

    Thread2  running .....
    Thread1  running .....
    Thread2  running .....
    Thread1  running .....
    Thread2  running .....
    Thread1  running .....

这里，和上面的第一种测试代码不同，这里有两个不同的MyThread对象，分别对应着两把锁，因此线程Thread1访问同步块是去拿对象mt的锁，而线程Thread2访问同步块是去拿对象mt2的锁，而这两个锁是没有任何关系的，即线程Thread1执行的是对象mt的中的synchronized代码块，而线程Thread2执行的是对象mt2中的synchronized代码块，两者互不相关，因此这两个线程就可以同时进行。

小结：当一个线程访问一个对象obj中的synchronized(this)同步块时，其它线程访问这个对象obj的synchronize(this)就会阻塞

1.2 当一个线程访问一个对象obj中的synchronized(this)同步代码块时，其它的线程可以同时访问该对象obj中的非synchronize(this)代码块

看一个例子

Demo2：多个线程访问synchronized和非synchronized代码块

        class MyThread implements Runnable{
            private static final int NUM = 3;
            @Override
            public void run() {
                String name = Thread.currentThread().getName();
                if(name.equals("Thread1")){
                    synMethod();
                }
                else if(name.equals("Thread2")){
                    notSynMethod();
                }
            }
            public void synMethod(){
                synchronized(this){
                    for(int i=0;i<NUM;i++){
                        System.out.println(Thread.currentThread().getName()+"running ....");
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
            public void notSynMethod(){
                for(int i=0;i<NUM;i++){
                    System.out.println(Thread.currentThread().getName()+"running ....");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }

测试代码：

    
        public static void main(String[] args) {
            MyThread mt = new MyThread();
            new Thread(mt,"Thread1").start();
            new Thread(mt,"Thread2").start();
        }

运行结果：

    Thread1 running ....
    Thread2 running ....
    Thread1 running ....
    Thread2 running ....
    Thread1 running ....
    Thread2 running ....

分析：

上面的代码中，有一个使用synchronize(this)同步的方法synMethod，有一个没有使用关键字synchronize(this)同步的方法notSynMethod.

由于线程Thread1和Thread2没有同时访问对象mt的synchronized(this)同步代码块，而是只有Thread1访问，Thread2访问的是对象mt非synchronized(this)代码块。因此这两个线程是可以同时进行的。

注意：这里的“访问对象mt的非synchronized(this)代码块”并不是单单指对象mt中没有用关键字synchronized修饰的代码块，而是还包括对象mt中其它使用类似synchronized(otherRef)修饰的代码块,其中otherRef为不等于this的其它引用对象。

看下面的例子，将上例Demo2中的notSynMethod方法用synchronized(otherRefe)来同步

        private int [] value = new int[0];
        public void notSynMethod(){
            synchronized(value){
                for(int i=0;i<NUM;i++){
                    System.out.println(Thread.currentThread().getName()+" running ....");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }

改成这样，线程Thread1、Thead2依然可以同时工作，这是因为他们所需要的锁不一样。

小结：当一个线程访问对象obj的synchronized(this)代码块时，其它线程是可以同时访问该对象obj的非synchronized(this)的代码块

1.3、当多线程并发时，一个线程访问对象obj的synchronized(this)代码块时，其它线程对对象obj中所有其他synchronized(this)同步代码块的访问将被阻塞

看一个例子：MyThread5类中的两个方法都使用了synchronized(this)来进行修饰.

        class MyThread5 implements Runnable{
            private static final int NUM = 3;
            @Override
            public void run() {
                String name = Thread.currentThread().getName();
                if(name.equals("Thread1")){
                    synMethod();
                }
                else if(name.equals("Thread2")){
                    synMethod2();
                }
            }
            public void synMethod(){
                synchronized(this){
                    for(int i=0;i<NUM;i++){
                        System.out.println(Thread.currentThread().getName()+" running ....");
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
            public void synMethod2(){
                synchronized(this){
                    for(int i=0;i<NUM;i++){
                        System.out.println(Thread.currentThread().getName()+" running ...." + i);
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
    
            }
    
        }

测试方法为：

        public static void main(String[] args) {
            MyThread5 mt = new MyThread5();
            new Thread(mt,"Thread1").start();
            new Thread(mt,"Thread2").start();
        }

运行结果：

    Thread2 running ....0
    Thread2 running ....1
    Thread2 running ....2
    Thread1 running ....
    Thread1 running ....
    Thread1 running ....

分析：

当线程Thread1访问对象mt的方法synMethod中的synchronized(this)同步代码块时，线程Thread2访问对象mt中另一个方法synMethod2中synchronized(this)同步代码块的访问将被阻塞。这是因为，线程Thread1访问mt的一个synchronized(this)同步代码块时，它就获得了这个mt的对象锁。结果，线程Thread2对该mt对象所有使用synchronized(this)的同步代码部分的访问都被暂时阻塞。

2、synchronized修饰某个方法

synchronized修饰某个方法，作用的对象为调用该方法的对象。

其实，

        public synchronized void method(){
            //to do something ....
        }

效果等同于：

        public void method(){
            synchronized(this){
                //to do something ....
            }
        }

因此，这里不再进行介绍。

不过，有两点需要注意的是

1、一般我们不建议同步整个方法，能同步方法中的某个代码块就同步代码块。同步安全往往是以性能为代价的。

2、synchronized关键字同步的方法不能继承。虽然可以使用synchronized来修饰某个方法，但是synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。

3.synchronized关键字修饰静态代码块

synchronized关键字修饰静态代码块，作用的是该类的所用对象。

Demo3:synchronized关键字修饰静态代码块

        class MyThread2 implements Runnable{
    
            private static final int NUM = 3;
            @Override
            public void run() {
                print();
            }
    
            public synchronized static void print() {
                for(int i=0;i<NUM;i++){
                    System.out.println(Thread.currentThread().getName()+" running... "+i);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }

测试代码：

        public static void main(String[] args) {
            MyThread2 mt = new MyThread2();
            MyThread2 mt2 = new MyThread2();
            new Thread(mt,"Thread1").start();
            new Thread(mt2,"Thread2").start();
    
        }

分析：

我们都知道静态方法是属于类的，不是属于对象的。

MyThread2类中的静态方法print使用了synchronized修饰，尽管在测试代码中使用了两个不同的对象mt/mt2,但是这里的锁不再是锁对象mt/mt2.而是锁”类MyThread2”这个对象，mt/mt2都是属性类MyThread的，因此mt/mt2就相当于同一把锁。，因此，这两个线程在访问此静态方法print时就需要取得锁之后才能访问，访问完之后释放锁。

4、synchronized修饰一个类

synchronized修饰一个类，作用为该类的所用对象

        class MyThread3 implements Runnable{
    
            private static final int NUM = 3;
            @Override
            public void run() {
                synchronized(MyThread3.class){
                    for(int i=0;i<NUM;i++){
                        System.out.println(Thread.currentThread().getName()+" running... "+i);
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
    
        }

测试代码如下：

        public static void main(String[] args) {
            MyThread3 mt = new MyThread3();
            MyThread3 mt2 = new MyThread3();
            new Thread(mt,"Thread1").start();
            new Thread(mt2,"Thread2").start();
        }

运行结果如下：

    Thread2 running... 0
    Thread2 running... 1
    Thread2 running... 2
    Thread1 running... 0
    Thread1 running... 1
    Thread1 running... 2

由于mt/mt2都是属于类MyThread3的，而synchronized修饰的是MyThread3这整个类，因此所有的MyThread访问此代码块都是互斥的，任一时刻都只能有一个线程能够访问。

不知道大家有没有这样的疑问，反正我是有的，既然synchronized修饰的静态方法和修饰的整个类都是作用与该类的全部对象，那么这两者是不是互斥的呢？？

上面的问题具体一点来描述：有一个MyThread类，MyThread类中的一个方法中的代码块Block1用synchronize(MyThread.class)同步，MyThread类中一个静态方法method用synchronized同步，有两个线程Thread1、Thread2，Thread1访问Block1，Thread2访问method是否可以同时进行？？？

答案是：可以的，这是因为虽然都作用与该类的所用对象，但是锁却不是同一个锁，因此不是互斥的，可以同时访问

看如下的例子

        class MyThread4 implements Runnable{
    
            private static final int NUM = 3;
            @Override
            public void run() {
                String name = Thread.currentThread().getName();
                if(name.equals("Thread1")){
                    synClassMethod();
                }
                else if(name.equals("Thread2")){
                    synStaticCodeBlock();
                }
            }
    
            public void synClassMethod(){
                synchronized(MyThread4.class){
                    for(int i=0;i<NUM;i++){
                        System.out.println(Thread.currentThread().getName()+" running... "+i);
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
            public static void synStaticCodeBlock(){    
                for(int i=0;i<NUM;i++){
                    System.out.println(Thread.currentThread().getName()+" running... "+i);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
    
            }
    
        }

测试代码如下：

        public static void main(String[] args) {
            MyThread4 mt = new MyThread4();
            MyThread4 mt2 = new MyThread4();
            new Thread(mt,"Thread1").start();
            new Thread(mt2,"Thread2").start();
        }

运行结果为：

    Thread2 running... 0
    Thread1 running... 0
    Thread2 running... 1
    Thread1 running... 1
    Thread2 running... 2
    Thread1 running... 2

总结

1、当两个线程Thread1、Thread2访问一个对象obj的synchronized(this)代码块时，每个时刻都只能有一个访问此代码块，当Thread1访问时，Thread2只有在Thread1线程执行完这段代码块并释放锁后取得锁才能访问。

2、当两个线程并发时，一个线程访问对象obj的synchronized(this)代码块时，其它的线程可以访问对象obj的非synchronized(this)代码块。

3、当多线程并发时，一个线程访问对象obj的synchronized(this)代码块时，其它线程对对象obj中所有其他synchronized(this)同步代码块的访问将被阻塞。这是因为，当一个线程访问obj的一个synchronized(this)同步代码块时，它就获得了这个obj的对象锁。结果，其它线程对该obj对象所有同步代码部分的访问都被暂时阻塞。

4、第3个结论同样适用其它同步代码块。例如，如果一个线程访问对象lock的synchronized(lock)的同步代码块，其中private int[] lock = new int[0]，则其它线程在在其它方法中出现的
synchronized(lock)的同步代码块的访问将被阻塞。

5、上面所有的结论都适用于其它对象锁。

参考资料

1、http://blog.csdn.net/luoweifu/article/details/46613015

2、http://www.cnblogs.com/GnagWang/archive/2011/02/27/1966606.html

Java 面试宝典是大明哥全力打造的 Java 精品面试题，它是一份靠谱、强大、详细、经典的 Java 后端面试宝典。它不仅仅只是一道道面试题，而是一套完整的 Java 知识体系，一套你 Java 知识点的扫盲贴。

它的内容包括：

大厂真题：Java 面试宝典里面的题目都是最近几年的高频的大厂面试真题。
原创内容：Java 面试宝典内容全部都是大明哥原创，内容全面且通俗易懂，回答部分可以直接作为面试回答内容。
持续更新：一次购买，永久有效。大明哥会持续更新 3+ 年，累计更新 1000+，宝典会不断迭代更新，保证最新、最全面。
覆盖全面：本宝典累计更新 1000+，从 Java 入门到 Java 架构的高频面试题，实现 360° 全覆盖。
不止面试：内容包含面试题解析、内容详解、知识扩展，它不仅仅只是一份面试题，更是一套完整的 Java 知识体系。
宝典详情：https://www.yuque.com/chenssy/sike-java/xvlo920axlp7sf4k
宝典总览：https://www.yuque.com/chenssy/sike-java/yogsehzntzgp4ly1
宝典进展：https://www.yuque.com/chenssy/sike-java/en9ned7loo47z5aw

目前 Java 面试宝典累计更新 400+ 道，总字数 42w+。大明哥还在持续更新中，下图是大明哥在 2024-12 月份的更新情况：

想了解详情的小伙伴，扫描下面二维码加大明哥微信【daming091】咨询

同时，大明哥也整理一套目前市面最常见的热点面试题。微信搜[大明哥聊 Java]或扫描下方二维码关注大明哥的原创公众号[大明哥聊 Java] ，回复【面试题】即可免费领取。

阅读全文

Java 源码分析

《Java源码分析》：Java中synchronized关键字的使用

Java中synchronized关键字的使用

1、synchronized修饰一个代码块

2、synchronized修饰某个方法

3.synchronized关键字修饰静态代码块

4、synchronized修饰一个类

总结

参考资料