搞定Java并发-synchronized原理

  • 内容
  • 评论
  • 相关

前言

线程安全是并发编程中的重要关注点,应该注意到的是,造成线程安全问题的主要诱因有两点,一是存在共享数据(也称临界资源),二是存在多条线程共同操作共享数据。因此为了解决这个问题,我们可能需要这样一个方案,当存在多个线程操作共享数据时,需要保证同一时刻有且只有一个线程在操作共享数据,其他线程必须等到该线程处理完数据后再进行,这种方式有个高尚的名称叫互斥锁,即能达到互斥访问目的的锁,也就是说当一个共享数据被当前正在访问的线程加上互斥锁后,在同一个时刻,其他线程只能处于等待的状态,直到当前线程处理完毕释放该锁。在 Java 中,关键字 synchronized可以保证在同一个时刻,只有一个线程可以执行某个方法或者某个代码块(主要是对方法或者代码块中存在共享数据的操作),同时我们还应该注意到synchronized另外一个重要的作用,synchronized可保证一个线程的变化(主要是共享数据的变化)被其他线程所看到(保证可见性,完全可以替代Volatile功能),这点确实也是很重要的。
我们知道在JDK1.6之前synchronized是一个重量级锁,相对于Lock,它会显得那么笨重,以至于我们认为它不是那么的高效而慢慢摒弃它。 诚然,随着Java JDK1.6对synchronized进行的各种优化后,synchronized并不会显得那么重了。
下面跟随北哥一起来了解一下线程安全及探索synchronized的实现机制、Java是如何对它进行了优化、锁优化机制、锁的存储结构和升级过程。
我从基本使用讲起,如果就是为了项目开发只需看1、2接就可以了。如果想了解其原理那就看到最后。

1. 线程安全

当多线程访问一个对象时,如果不需要考虑多线程的调度和交替执行,也不需要进行额外的同步,或者在调用方进行额外的协调操作,调用这个对象的行为都可以获得正确的结果,就可以说这个对象是线程安全的。
线程安全原则:
1). 原子性
java内存模型直接保证的原子性包括:read load use assign store write这6个,另外synchronized之间的操作也具备原子性。
2). 可见性
可见性指一个线程修改了共享变量的值,另外一个线程立即能够获得这个修改。
volatile通过修改后能够立即同步回主内存,使用之前必须从主内存刷新,保证了可见性。
synchronized和final变量也保证了可见性。
3). 有序性
同一个线程内,所有操作都是有序的,从一个线程观察另外一个线程,都是无序的。
synchronized 可以保证同一个锁的同步块只能串行进入。

2. Synchronized的基本使用

Synchronized是Java中解决并发问题的一种最常用的方法,也是最简单的一种方法。Synchronized的作用主要有三个:(1)确保线程互斥的访问同步代码(2)保证共享变量的修改能够及时可见(3)有效解决重排序问题。从语法上讲,Synchronized总共有三种用法:
1)修饰实例方法,作用于当前实例加锁,进入同步代码前要获得当前实例的锁.
2)修饰静态方法,作用于当前类对象加锁,进入同步代码前要获得当前类对象的锁.
3)修饰代码块,指定加锁对象,对给定对象加锁,进入同步代码库前要获得给定对象的锁。

2.1 synchronized作用于实例方法

所谓的实例对象锁就是用synchronized修饰实例对象中的实例方法,注意是实例方法不包括静态方法,如下
public class SyncMethod implements Runnable{
 
    /** 共享资源(临界资源) */
    public static int i = 0;
 
    /**
     * synchronized 修饰实例方法
     */
    private synchronized void increase(){
        i++;
    }
 
    @Override
    public void run() {
        for(int j = 0; j < 1000000; j++){
            increase();
        }
    }
}
 
public class SyncVerify {
    public static void main(String[] args){
        verifySyncMethod();
    }
 
    /**
     * synchronized修饰实例对象中的实例方法
     */
    private static void verifySyncMethod(){
        try {
            SyncMethod instance = new SyncMethod();
            Thread t1 = new Thread(instance);
            Thread t2 = new Thread(instance);
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println(instance.i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}    
    /**
     * 输出结果:
     * 2000000
     */
上述代码中,我们开启两个线程操作同一个共享资源即变量i,由于i++;操作并不具备原子性,该操作是先读取值,然后写回一个新值,相当于原来的值加上1,分两步完成,如果第二个线程在第一个线程读取旧值和写回新值期间读取i的域值,那么第二个线程就会与第一个线程一起看到同一个值,并执行相同值的加1操作,这也就造成了线程安全失败,因此对于increase方法必须使用synchronized修饰,以便保证线程安全。此时我们应该注意到synchronized修饰的是实例方法increase,在这样的情况下,当前线程的锁便是实例对象instance,注意Java中的线程同步锁可以是任意对象。从代码执行结果来看确实是正确的,倘若我们没有使用synchronized关键字,其最终输出结果就很可能小于2000000,这便是synchronized关键字的作用。这里我们还需要意识到,当一个线程正在访问一个对象的 synchronized 实例方法,那么其他线程不能访问该对象的其他 synchronized 方法,毕竟一个对象只有一把锁,当一个线程获取了该对象的锁之后,其他线程无法获取该对象的锁,所以无法访问该对象的其他synchronized实例方法,但是其他线程还是可以访问该实例对象的其他非synchronized方法,当然如果是一个线程 A 需要访问实例对象 obj1 的 synchronized 方法 f1(当前对象锁是obj1),另一个线程 B 需要访问实例对象 obj2 的 synchronized 方法 f2(当前对象锁是obj2),这样是允许的,因为两个实例对象锁并不同相同,此时如果两个线程操作数据并非共享的,线程安全是有保障的,遗憾的是如果两个线程操作的是共享数据,那么线程安全就有可能无法保证了,如下代码将演示出该现象
public class SyncMethod implements Runnable{
 
    /** 共享资源(临界资源) */
    public static int i = 0;
 
    /**
     * synchronized 修饰实例方法
     */
    private synchronized void increase(){
        i++;
    }
 
    @Override
    public void run() {
        for(int j = 0; j < 1000000; j++){
            increase();
        }
    }
}
 
public static void main(String[] args){
        verifySyncMethodBad();
    }
 
    /**
     * 两个实例对象锁
     */
    private static void verifySyncMethodBad(){
        try {
            SyncMethod instance1 = new SyncMethod();
            SyncMethod instance2 = new SyncMethod();
            Thread t1 = new Thread(instance1);
            Thread t2 = new Thread(instance2);
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println(instance1.i);
            System.out.println(instance2.i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
    /**
     * 输出结果:
     * < 2000000的一个数
     */
上述代码与前面不同的是我们同时创建了两个新实例SyncMethod,然后启动两个不同的线程对共享变量i进行操作,但很遗憾操作结果不是期望结果2000000,而是小于2000000的一个数。因为上述代码犯了严重的错误,虽然我们使用synchronized修饰了increase方法,但却new了两个不同的实例对象,这也就意味着存在着两个不同的实例对象锁,因此t1和t2都会进入各自的对象锁,也就是说t1和t2线程使用的是不同的锁,因此线程安全是无法保证的。解决这种困境的的方式是将synchronized作用于静态的increase方法,这样的话,对象锁就当前类对象,由于无论创建多少个实例对象,但对于的类对象拥有只有一个,所有在这样的情况下对象锁就是唯一的。下面我们看看如何使用将synchronized作用于静态的increase方法

2.2 synchronized作用于静态方法

当synchronized作用于静态方法时,其锁就是当前类的class对象锁。由于静态成员不专属于任何一个实例对象,是类成员,因此通过class对象锁可以控制静态 成员的并发操作。需要注意的是如果一个线程A调用一个实例对象的非static synchronized方法,而线程B需要调用这个实例对象所属类的静态 synchronized方法,是允许的,不会发生互斥现象,因为访问静态 synchronized 方法占用的锁是当前类的class对象,而访问非静态 synchronized 方法占用的锁是当前实例对象锁,看如下代码
public class SyncClass implements Runnable {
 
    public static int i = 0;
 
    /**
     * 作用于静态方法,锁是当前class对象,也就是
     * SyncClass类对应的class对象
     */
    public static synchronized void increase(){
        i++;
    }
 
    @Override
    public void run() {
        for(int j = 0; j < 1000000; j++){
            increase();
        }
    }
 
}
 
public class SyncVerify {
    public static void main(String[] args){
        verifySyncClass();
    }
 
    /**
     * 当synchronized作用于静态方法时,其锁就是当前类的class对象锁
     */
    private static void verifySyncClass(){
        try {
            SyncClass instance1 = new SyncClass();
            SyncClass instance2 = new SyncClass();
            Thread t1 = new Thread(instance1);
            Thread t2 = new Thread(instance2);
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println(instance1.i);
            System.out.println(instance2.i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
    /**
     * 输出结果:
     * 2000000
     */
由于synchronized关键字修饰的是静态increase方法,与修饰实例方法不同的是,其锁对象是当前类的class对象

2.3 synchronized作用于代码块

除了使用关键字修饰实例方法和静态方法外,还可以使用同步代码块,在某些情况下,我们编写的方法体可能比较大,同时存在一些比较耗时的操作,而需要同步的代码又只有一小部分,如果直接对整个方法进行同步操作,可能会得不偿失,此时我们可以使用同步代码块的方式对需要同步的代码进行包裹,这样就无需对整个方法进行同步操作了,同步代码块的使用示例如下:
public class SyncCodeBlock implements Runnable{
    public static int i = 0;
    private static final byte[] sLock = new byte[0];
    @Override
    public void run() {
        //其他逻辑
        //……
        //synchronized(SyncCodeBlock.class){
        //synchronized(this){
        //使用同步代码块对变量i进行同步操作,锁对象为当前对象
        synchronized(sLock){
            for(int j=0;j<1000000;j++){
                i++;
            }
        }
    }
}
 
public class SyncVerify {
    public static void main(String[] args){
        verifySyncCodeBlock();
    }
private static void verifySyncCodeBlock(){
        try {
            SyncCodeBlock instance1 = new SyncCodeBlock();
            SyncCodeBlock instance2 = new SyncCodeBlock();
            Thread t1 = new Thread(instance1);
            Thread t2 = new Thread(instance2);
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println(instance1.i);
            System.out.println(instance2.i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
从代码看出,将synchronized作用于一个给定的实例对象instance,即当前实例对象就是锁对象,每次当线程进入synchronized包裹的代码块时就会要求当前线程持有instance实例对象锁,如果当前有其他线程正持有该对象锁,那么新到的线程就必须等待,这样也就保证了每次只有一个线程执行i++;操作

3. synchronized原理

Java 虚拟机中的同步(Synchronization)基于进入和退出管程(Monitor)对象实现, 无论是显式同步(有明确的 monitorenter 和 monitorexit 指令,即同步代码块)还是隐式同步都是如此。在 Java 语言中,同步用的最多的地方可能是被 synchronized 修饰的同步方法。同步方法 并不是由 monitorenter 和 monitorexit 指令来实现同步的,而是由方法调用指令读取运行时常量池中方法的 ACC_SYNCHRONIZED 标志来隐式实现的。

3.1 synchronized代码块底层原理

我们再来看一下上面的例子代码中的修饰代码块的方法:
public class SyncCodeBlock implements Runnable{
    public static int i = 0;
    private static final byte[] sLock = new byte[0];
    @Override
    public void run() {
        //其他逻辑
        //……
        //synchronized(SyncCodeBlock.class){
        //synchronized(this){
        //使用同步代码块对变量i进行同步操作,锁对象为当前对象
        synchronized(sLock){
            for(int j=