synchronized

synchronized简介

官方解释

同步方法支持一种简单的策略来防止线程干扰和内存一致性错误：如果一个对象对多个线程可见，则对该对象变量的所有读取或写入都是通过同步方法完成的。
简单来说，就是保证在同一时刻最多只有一个线程执行该段代码，以达到保证并发安全的效果。


public class synchronizedTest implements Runnable {

    static synchronizedTest s = new synchronizedTest();
    static int i = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(s);
        Thread thread2 = new Thread(s);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(i);
    }

    @Override
    public void run() {
        for (int j = 0; j < 10000; j++) {
            i++;
        }
    }

}


分别执行两次之后，发现并没有达到我们期望，两线程相加得到20000这个结果，并且得数也不相同。这就说明，这两个线程有同时操作i这个数据的情况，这样导则结果不同，这就是线程不安全的问题。

synchronized的地位

  • synchronized是Java的关键字，被Java语言原生支持
  • 是最基本的互斥同步手段
  • 是并发编程中的元老级角色，是并发编程中的必学内容

不使用并发手段会有什么后果

多线程在同时处理一个数据的时候，会导致数据错误，这样就是线程不安全的情况。

synchronized的两个用法

对象锁

包括方法锁（默认锁对象为this当前实例对象）和同步代码块锁（自己指定锁对象）

类锁

指synchronized修饰静态的方法或指定锁为Class对象

对象锁

代码块形式：手动指定锁对象


public class synchronizedclass implements Runnable {
    static synchronizedclass instance = new synchronizedclass();

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("finish");
    }

    @Override
    public void run() {
        synchronized (this) {
            System.err.println("我是对象的代码块形式。我叫" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "运行结束");
        }
    }
}

使用synchronized 关键字锁定指定的代码块，实现线程安全。
括号里填写锁对象。但是如果有多段代码都需要同步而彼此之间并不用同步的话，那么选取不同的锁对象就可以实现这个需求。

public class synchronizedclass implements Runnable {
    static synchronizedclass instance = new synchronizedclass();
    Object lock1 = new Object();
    Object lock2 = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("finish");
    }

    @Override
    public void run() {
        synchronized (lock1) {
            System.out.println("我是lock1。我叫" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " lock1部分运行结束");
        }

        synchronized (lock2) {
            System.out.println("我是lock2。我叫" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " lock2部分运行结束");
        }
    }
}

从上面可以看出来，lock1锁住上面的代码的时候，另一个线程是无法执行这段代码的。当第一个线程释放锁的时候，第二个线程才可以拿到这个锁，并且无法获取下一把锁。这样就实现了不同的锁来锁住不同的代码块

方法锁形式：synchronized修饰普通方法，锁对象默认为this

直接用synchronized关键字修饰这个方法，被修饰的方法（不能是静态方法）

public class synchronizedclass implements Runnable {
    static synchronizedclass instance = new synchronizedclass();

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("finish");
    }

    public synchronized void method() {
        System.out.println("我是对象锁的方法修饰符形式，我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }
    @Override
    public void run() {
        method();
    }
}

根据上面的内容可以看出来，当第一个线程的run()方法里面调用了被synchronized修饰的method()方法的时候，另一个线程是无法执行这个方法的代码的，这样就实现了线程安全的操作。

类锁

概念

  • 只有一个Class对象：java类可能有很多个对象，但只能有一个Class对象
  • 本质：所以所谓的类锁，不过是Class对象的锁而已。
  • 用法和效果：类锁只能在同一时刻被一个对象拥有。

synchronized加在static方法上

这么做的作用是可以做到在全局都实现线程同步

public class synchronizedclass implements Runnable {
    static synchronizedclass instance1 = new synchronizedclass();
    static synchronizedclass instance2 = new synchronizedclass();

    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("finish");
    }

    public static synchronized void method() {
        System.out.println("我是类锁的第一种形式：static形式，我叫" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + "运行结束");
    }

    @Override
    public void run() {
        method();
    }
}

从上面可以看出来，两个线程的参数不同并同时调用了method()方法，因为存在着被synchronized修饰的这个静态方法，所以依然可以实现线程同步。如果将synchronized 这个关键字拿掉的话，则线程的安全无法实现。

synchronized（*.class）代码块

public class synchronizedclass implements Runnable {

    static synchronizedclass s1 = new synchronizedclass();
    static synchronizedclass s2 = new synchronizedclass();

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(s1);
        Thread thread2 = new Thread(s2);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
    }

    @Override
    public void run() {
        try {
            method();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void method() throws InterruptedException {
        synchronized (synchronizedclass.class) {
            System.out.println("我是类锁的第二种形式：synchronized（*.class）。我叫" + Thread.currentThread().getName());
            Thread.sleep(3000);
            System.out.println(Thread.currentThread().getName() + "运行结束");
        }
    }

}

这就说明了，无论是哪条线程，只要同步代码块种放了这个类的对象，最终大家共用对象，即使是不同的实例，也要逐个的执行代码，实现线程安全。

多线程访问同步方法的7种情况

1. 两个线程同时访问一个对象的同步方法

先执行的线程至执行完代码之前，另一个线程无法执行

2. 两个线程同时访问两个对象的同步方法

synchronized是不起作用的，因为锁的是各自不同的实例，所以互相不干扰

3. 两个线程访问的是synchronized的静态方法

synchronized起作用，先执行的线程至执行完代码之前，另一个线程无法执行

4. 同时访问同步方法与非同步方法

synchronized关键字它只作用于指定的那个方法中，对于其他的没有加这个修饰符的方法，不会受到影响


public class SynchronizedYesAndNo implements Runnable {
    static SynchronizedYesAndNo s1 = new SynchronizedYesAndNo();
    
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(s1);
        Thread thread2 = new Thread(s1);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
    }
    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("Thread-0")) {
            method1();
        }else {
            method2();
        }
    }

    private synchronized void method1() {
        System.out.println("我是加锁的方法。我叫" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束");
    }

    private void method2() {
        System.out.println("我是没加锁的方法。我叫" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束");
    }
}

5. 访问同一个对象的不同的普通方法

虽说代码中synchronized并没有指定使用的锁对象，但是本质上它背后的原理是指定了this这个对象作为它的锁。所以说对于同一个实例来说，他们所拿到的锁对象是一样的，所以这两个方法不会同时运行


public class Synchronized1 implements Runnable{
    static Synchronized1 s1 = new Synchronized1();
    
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(s1);
        Thread thread2 = new Thread(s1);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
    }
    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("Thread-0")) {
            method1();
        }else {
            method2();
        }
    }
    private synchronized void method1() {
        System.out.println("我是加锁的方法method1。我叫" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束");
    }

    private synchronized void method2() {
        System.out.println("我是加锁的方法method2。我叫" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束");
    }
}
1

6. 同时访问静态synchronized和非静态synchronized方法

静态synchronized方法加的锁是（*.class），而非静态synchronized方法加的锁是这个实例this。所以看似是一个类里的两个synchronized方法，但是却可以同时运行。


public class Synchronized2 implements Runnable{
    static Synchronized2 s1 = new Synchronized2();
    
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(s1);
        Thread thread2 = new Thread(s1);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
    }
    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("Thread-0")) {
            method1();
        }else {
            method2();
        }
    }
    private static synchronized void method1() {
        System.out.println("我是静态加锁的方法method1。我叫" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束");
    }

    private synchronized void method2() {
        System.out.println("我是非静态加锁的方法method2。我叫" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束");
    }
}

7. 方法抛异常后，会释放锁

抛出异常之后，jvm会帮助代码释放锁，不需要手动释放锁。

总结

  • 一把锁同时只能被一个线程获取，没有拿到锁的线程必须等待（对应第1,5种情况）；
  • 每个实例都对应有自己的一把锁，不同实例之间互不影响；例外：锁对象是*.class以及synchronized修饰的静态方法的时候，所有对象共用同一把类锁（对应第2,3,4,6种情况）；
  • 无论是方法正常执行完毕或者方法抛出异常，都会释放锁（对应第7种情况）

如果进入一个被synchronized修饰的方法，而在这个方法里面调用另外一个没有被synchronized修饰的方法，那它还是线程安全的吗？

不是线程安全的，一旦出了本方法去了另一个方法，由于另一个方法没有被synchronized修饰，那么这个方法是可以被多个方法访问的。所以线程是不安全的；

性质

可重入

什么是可重入：指的是同一线程的外层函数获得锁之后，内层函数可以直接再次获取该锁
好处：避免死锁，提升封装性
粒度：线程而非调用（用3种情况来说明和pthread的区别）

粒度

  • 情况1：证明同一个方法是可重入的
public class Synchronized4 {

    private int a = 0;
    public static void main(String[] args) {
        Synchronized4 s4 = new Synchronized4();
        s4.method();
    }

    private synchronized void method() {
        System.out.println("这是method，a = "+a);
        if(a == 0) {
            a++;
            method();
        }
        
    }
}

根据上面的代码可以看出，调用同一个被synchronized关键字修饰的方法是可以完成的

  • 情况2：证明可重入不要求是同一个方法
public class Synchronized5 {
    
    public static void main(String[] args) {
        Synchronized5 s5 = new Synchronized5();
        s5.method1();
    }
    public synchronized void method1() {
        System.out.println("我是method1");
        method2();
    }
    
    public synchronized void method2() {
        System.out.println("我是method2");
    }
}

根据上面的代码，可以知道不是同一个方法也是可以重入的

  • 情况3：证明可重入不要求是同一个类中的
public class Synchronized6 {

    public synchronized void method() {
        System.out.println("我是父类方法");
    }
}
class TestClass extends Synchronized6{
    public synchronized void method() {
        System.out.println("我是子类方法");
        super.method();
    }
    
    public static void main(String[] args) {
        TestClass t = new  TestClass();
        t.method();
    }
}

根据上面的代码可以知道，在子类继承父类的过程中，调用的main（）函数已经和之前的不是同一个类了，但是依然实现了可重入，说明这个性质在不同的类中也是可以实现的

根据上面的几个验证，说明了粒度范围是线程范围而非调用

不可中断

一旦这个锁已经被别的线程获得了，如果这个线程还想获得，那只能选择等待或者阻塞，知道别的线程释放这个锁。如果别的线程永远不释放锁，那么这个线程只能永远地等下去。
相比之下，Lock类，可以拥有中断的能力，第一点，如果觉得等的时间太长了，有权中断现在已经获取锁的线程执行；第二点，如果觉得等待的时间太长了不想等了，也可以退出。

原理

  1. 加锁和释放锁的原理：现象，时机，深入JVM看字节码

加锁和释放锁的原理

  • 现象
    方法获取锁的时候其他方法无法获取这把锁，这有当这个方法执行完成或者抛出异常之后，其他方法才能获取锁
  • 获取和释放锁的时机：内置锁
  • 等价代码
public class Synchronized7 {

    Lock lock = new ReentrantLock();
    public static void main(String[] args) {
        Synchronized7 s7 = new Synchronized7();
        s7.method1();
        s7.method2();
    }
    public synchronized void method1() {
        System.out.println("我是synchronized形式的锁");
    }
    
    public void method2() {
        lock.lock();
        try {
            System.out.println("我是Lock形式的锁");
        } finally {
            lock.unlock();
        }
    }
}
  • 深入JVM看字节码：反编译，monitor指令
    概况：synchronized用的这把锁，是在java对象头里的一个字段，表明这个是被锁住了还是没锁住。它的进入锁和释放锁是基于monitor对象来实现同步方法和同步代码块的，
  1. 可重入原理：加锁次数计数器

  2. 保证可见性的原理：内存模型




    一旦代码块被synchronized关键字所修饰，那么他在执行完毕之后，被锁住的对象所做的任何修改都要在释放锁之前从线程内存写回到主内存中。在进入代码块得到锁之后，被锁定的对象的数据也是直接从主内存读取出来。因为之前的线程最后将数据写回到主内存中，所以这次从主内存中读取的数据一定是最新的。

缺陷

  1. 效率低：锁的释放情况少，试图获得锁时不能设定超时，不能中断一个正在试图获得锁的线程
    线程在获得synchronized锁并在执行这段代码的时候，其他线程无法得到这把锁，只能等待。也就只有两种情况才会释放锁：执行完毕代码和发生异常。其他情况都不会释放锁。如果这获得这把锁的线程中出现了耗时操作（io，sleep方法），其他线程只能等待，这样就非常影响执行效率。
    synchronized是不能设置超时的，也就是说出现了阻塞情况就会一直等待，这样也会影响效率。
    synchronized不能中断，这样也会影响代码的执行效率。
  2. 不够灵活（读写锁更灵活）：加锁和释放的时机单一，每个锁仅有单一的条件（某个对象），可能是不够的
  3. 无法知道是否成果获取到锁

synchronized相比于Lock类，可以对比它的不足

public class LockExample {

    public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock(); 
        //加锁
        lock.lock();
        //解锁
        lock.unlock();
        //尝试获取到锁
        boolean tryLock = lock.tryLock();
        //尝试获取到锁，参数是超时时间
        boolean tryLock2 = lock.tryLock(10000, TimeUnit.SECONDS);
    }
}

一些问题

  1. synchronized关键字使用注意点：锁对象不能为空，作用域不宜过大，避免死锁
    锁对象不能为空就是说指定了一个对象作为我们得锁对象，它必须是一个实例对象，不能是一个空对象。因为锁的信息是保存在对象头中的。如果是一个空对象，也就没有对象头，所以这个锁是不能工作的。
    作用域不宜过大，它的作用域是指这个synchronized关键字所包裹的范围，如果包裹范围过大的话，很有可能将大部分线程变成串行，会降低出并发问题的可能性，这样就没法达到多线程编程的目的，这样会影响代码的执行效率。
    避免死锁，如果方法1用a锁修饰后，里面又调用了b锁，另一个方法2用b锁修饰后又调用了a锁，那么在执行过程中就容易出现死锁情况。
  2. 如何选择Lock和synchronized关键字？
    如果synchronized关键字在程序中适用，就优先使用这个，这样会减少编写的代码，也就减少了出错的几率；
    如果特别需要Lock独有的特性的时候（随时释放锁，设置等待时长等）。
  3. 多线程访问同步方法的各种具体情况
    上面的笔记有具体的7种情况，看懂熟记，明白原理。
  4. 多个线程等待同一个synchronized锁的时候，JVM如何选择下一个获取锁的是哪个线程？什么算法？
  5. synchronized使得同时只有一个线程可以执行，性能较差，有什么办法可以提升性能？
    是优化使用范围，类似第一题的作用域不宜过大的原理。在符合要求的情况下尽可能的小。
    使用其他类型的Lock。
  6. 想更灵活地控制锁的获取和释放（现在释放锁的时机都被规定死了），怎么办？
    自己实现一个Lock接口，这样就能代码控制这些操作了。
  7. 什么是锁的升级，降级？什么是JVM里的偏科锁，轻量级锁，重量级锁？

总结

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

推荐阅读更多精彩内容