Synchronized详解

什么是Synchronized,有什么用?

Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

使用方式

1. 修饰对象方法(也就是非静态方法)

如果一个线程正在访问这个对象中synchronized修饰的方法时，那么其他试图访问该对象中任何synchronized修饰的方法的线程都将被阻塞.

很抽象,没关系,继续往下.

/**
 * 对象方法加synchronized关键字
 */
class SyncDemo {
    synchronized void exec1() {
        for (int i = 0; i < 5; i++) {
            Thread.sleep(100);//省略try_catch
            System.out.println("exec1-->" + Thread.currentThread().getName() + "-->" + i);
        }
    }

    synchronized void exec2() {
        for (int i = 0; i < 5; i++) {
            Thread.sleep(100);//省略try_catch
            System.out.println("exec2-->" + Thread.currentThread().getName() + "-->" + i);
        }
    }
}

同一个对象,同一个方法

public class SyncDemoTest {
    public static void main(String[] args) {
      //先将对象实例化,两个线程用的是一个对象
        final SyncDemo syncDemo = new SyncDemo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                syncDemo1.exec1();
            }
        }, "thread1").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                syncDemo1.exec1();
            }
        }, "thread2").start();
    }
}

运行结果
exec1-->thread1-->0
exec1-->thread1-->1
exec1-->thread1-->2
exec1-->thread1-->3
exec1-->thread1-->4
exec1-->thread2-->0
exec1-->thread2-->1
exec1-->thread2-->2
exec1-->thread2-->3
exec1-->thread2-->4

同一个对象,不同方法

public class SyncDemoTest {
    public static void main(String[] args) {
      //先将对象实例化,两个线程用的是一个对象
        final SyncDemo syncDemo = new SyncDemo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                syncDemo1.exec1();
            }
        }, "thread1").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                syncDemo1.exec2();
            }
        }, "thread2").start();
    }
}

运行结果
exec1-->thread1-->0
exec1-->thread1-->1
exec1-->thread1-->2
exec1-->thread1-->3
exec1-->thread1-->4
exec2-->thread2-->0
exec2-->thread2-->1
exec2-->thread2-->2
exec2-->thread2-->3
exec2-->thread2-->4

从结果中我们会发现,当exec1()执行的时候,exec2()必须要等待exec1()执行完成后才会执行.

说明: 如果一个对象有多个synchronized方法，某一时刻某个线程已经进入到了某个synchronized方法，那么在该方法没有执行完毕前，其他线程是无法访问该对象的任何synchronized方法的。

结论

当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。
Java中的每个对象都有一个锁（lock），或者叫做监视器（monitor），当一个线程访问某个对象的synchronized方法时，将该对象上锁，其他任何线程都无法再去访问该对象的synchronized方法了（这里是指所有的同步方法，而不仅仅是同一个方法），直到之前的那个线程执行方法完毕后（或者是抛出了异常），才将该对象的锁释放掉，其他线程才有可能再去访问该对象的synchronized方法。

注意这时候是给对象上锁，如果是不同的对象，则各个对象之间没有限制关系。

one more thing

代码中构造两个线程时,分别在run方法里传入不同的SyncDemo1对象，那么两个线程的执行之间将没有什么制约关系。

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                new SyncDemo().exec1();
            }
        }, "thread1").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                new SyncDemo().exec2();
            }
        }, "thread2").start();
    }

2. 修饰静态方法

当一个synchronized关键字修饰的方法同时又被static修饰，之前说过，非静态的同步方法会将对象上锁，但是静态方法不属于对象，而是属于类，它会将这个方法所在的类的Class对象上锁。

一个类不管生成多少个对象，它们所对应的是同一个Class对象。

/**
 * 静态方法加synchronized关键字
 */
class SyncDemo {
  //加入静态修饰
    synchronized static void exec1() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("exec1-->" + Thread.currentThread().getName() + "-->" + i);
        }
    }
    //加入静态修饰
    synchronized static void exec2() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("exec2-->" + Thread.currentThread().getName() + "-->" + i);
        }
    }
}

public class SyncDemoTest {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                SyncDemo.exec1();
            }
        }, "thread1").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                SyncDemo.exec2();
            }
        }, "thread2").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                new SyncDemo().exec1();
            }
        }, "thread3").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                new SyncDemo().exec2();
            }
        }, "thread4").start();
    }
}

运行结果
exec1-->thread1-->0
exec1-->thread1-->1
exec1-->thread1-->2
exec1-->thread1-->3
exec1-->thread1-->4
exec2-->thread4-->0
exec2-->thread4-->1

exec2-->thread4-->2
exec2-->thread4-->3
exec2-->thread4-->4
exec1-->thread3-->0
exec1-->thread3-->1
exec1-->thread3-->2
exec1-->thread3-->3
exec1-->thread3-->4
exec2-->thread2-->0
exec2-->thread2-->1
exec2-->thread2-->2
exec2-->thread2-->3
exec2-->thread2-->4

从结果中我们会发现,4个线程的调用时依次执行的

如果某个synchronized方法是static的，那么当线程访问该方法时，它锁的并不是synchronized方法所在的对象，而是synchronized方法所在的类所对应的Class对象。Java中，无论一个类有多少个对象，这些对象会对应唯一一个Class对象，因此当线程分别访问同一个类的两个对象的两个static，synchronized方法时，它们的执行顺序也是顺序的，也就是说一个线程先去执行方法，执行完毕后另一个线程才开始

3. 修饰代码块

如下,

对象锁

    void exec() {
        synchronized (this) {
            for (int i = 0; i < 5; i++) {
                Thread.sleep(100);
                System.out.println("exec-->" + Thread.currentThread().getName() + "-->" + i);
            }
        }
    }

其效果等同于修饰对象方法.this作为对象锁.

类锁

    static void exec() {
        synchronized (SyncDemo.class) {
            for (int i = 0; i < 5; i++) {
                Thread.sleep(100);
                System.out.println("exec-->" + Thread.currentThread().getName() + "-->" + i);
            }
        }
    }

其效果等同于修饰静态方法.

4. 混合修饰

class SyncDemo {
    synchronized void exec() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("exec -->" + Thread.currentThread().getName() + "-->" + i);
        }
    }

    synchronized static void exec1() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("exec1-->" + Thread.currentThread().getName() + "-->" + i);
        }
    }

    synchronized static void exec2() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("exec2-->" + Thread.currentThread().getName() + "-->" + i);
        }
    }
}

public class SyncDemoTest {
    public static void main(String[] args) {
        final SyncDemo syncDemo = new SyncDemo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                syncDemo.exec();
            }
        }, "thread ").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                syncDemo.exec1();
            }
        }, "thread1").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                syncDemo.exec2();
            }
        }, "thread2").start();
    }
}

运行结果

exec -->thread -->0
exec1-->thread1-->0
exec -->thread -->1
exec1-->thread1-->1
exec -->thread -->2
exec1-->thread1-->2
exec -->thread -->3
exec1-->thread1-->3
exec -->thread -->4
exec1-->thread1-->4
exec2-->thread2-->0
exec2-->thread2-->1
exec2-->thread2-->2
exec2-->thread2-->3
exec2-->thread2-->4

从结果来看,对象锁的thread和类锁的thread1 两个线程交替进行.

说明对象锁跟类的锁之间没有相互制约关系

Tips

  1. synchronized方法与synchronized代码块的区别

synchronized methods(){} 与synchronized（this）{}之间没有什么区别，只是 synchronized methods(){} 便于阅读理解，而synchronized（this）{}可以更精确的控制冲突限制访问区域，有时候表现更高效率

  1. synchronized关键字是不能继承的

  2. 使用synchronized关键字解决线程的同步问题会带来一些执行效率上的问题。

JDK 5.0引入了这样一个包：java.util.concurrent：

简述

  1. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是类.

  2. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。

  3. 类的锁跟对象的锁之间没有制约关系.

参考

  1. synchronized关键字详解
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,454评论 6赞 493
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,553评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,921评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,648评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,770评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,950评论 1赞 291
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,090评论 3赞 410
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,817评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,275评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,592评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,724评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,409评论 4赞 333
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,052评论 3赞 316
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,815评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,043评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,503评论 2赞 361
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,627评论 2赞 350

推荐阅读更多精彩内容

  • Java 之 synchronized 详解
    一、概念 synchronized 是 Java 中的关键字，是利用锁的机制来实现同步的。 锁机制有如下两种特性：...
    zly394阅读 11,424评论 1赞 6
  • （二）synchronized详解
    1、了解synchronized synchronized是Java中的关键字，是一种同步锁。当多个并发线程访问同...
    黒猫阅读 1,615评论 0赞 2
  • 面试知识点1
    Java8张图 11、字符串不变性 12、equals()方法、hashCode()方法的区别 13、...
    Miley_MOJIE阅读 3,697评论 0赞 11
  • 线程同步volatile与synchronized详解
    在之前的文章java面试 synchronized关键字中，已经详细的介绍了synchronized关键字的用法和...
    步积阅读 2,500评论 1赞 4
  • java多线程
    本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。 首先讲...
    李欣阳阅读 2,444评论 1赞 15