深入理解JAVA多线程---对象及变量的并发访问(synchronized和volatile关键字)

前言

在多线程开发过程中,难免遇到很多线程不安全的问题,例如多个线程对一个变量进行访问和修改,就会产生"脏读".因此利用好synchronized和volatile关键字是多线程的关键一步.

线程不安全问题

首先我们来看一段线程不安全的代码:

public class synchronizedAndVolatile {
    public static int i = 0;

    static class MyThread implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 10000; i++) {
                numSum();
            }
        }
    }

    public static void numSum(){
        i++;
    }

    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();

        Thread t1 = new Thread(myThread);
        t1.start();

        Thread t2 = new Thread(myThread);
        t2.start();

        Thread.sleep(3000);

        System.out.println(i);
    }
}

代码中开启了两个线程去进行i++操作,如果线程安全的情况下,输出的i应该等于两个进程循环的次数也就是20000,但是多次测试结果都是小于20000,这就是由于线程在对i进行修改之后,还没有写入更改之前有另一个线程获取了i值,出现了脏读,导致了线程不安全问题.

如何解决线程不安全问题,这就需要引入synchronized和volatile关键字了.

解决线程不安全问题

synchronized实现原理

我们先看这段代码,在上面代码的numSum()方法加上synchronized关键字:

public class synchronizedAndVolatile {
    public static int i = 0;

    static class MyThread implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 10000; i++) {
                numSum();
            }
        }
    }

    public synchronized static void numSum(){
        i++;
    }

    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();

        Thread t1 = new Thread(myThread);
        t1.start();

        Thread t2 = new Thread(myThread);
        t2.start();

        Thread.sleep(3000);

        System.out.println(i);
    }
}

我们发现这时运行结果就正确了,可见synchronized关键字起到了线程同步的作用,那究竟是怎样实现的呢?

根据底层我们会发现synchronized实现是通过对象锁（monitor）机制

对象锁（monitor）机制

那我们来看看synchronized具体的底层实现原理:
根据程序的字节码文件来分析一下对象锁机制:

public class SynchronizedDemo {
    public static void main(String[] args) {
        synchronized (SynchronizedDemo.class) {
        }
        method();
    }
 
    private static void method() {
    }
}

如图，上面用黄色高亮的部分就是需要注意的部分了，这也是添Synchronized关键字之后独有的。执行同步代码块后首先要先执行monitorenter指令，退出的时候monitorexit指令。通过分析之后可以看出，使用Synchronized进行同步，其关键就是必须要对对象的监视器monitor进行获取，当线程获取monitor后才能继续往下执行，否则就只能等待。而这个获取的过程是互斥的，即同一时刻只有一个线程能够获取到monitor。上面的demo中在执行完同步代码块之后紧接着再会去执行一个静态同步方法，而这个方法锁的对象依然就这个类对象，那么这个正在执行的线程还需要获取该锁吗？答案是不必的，从上图中就可以看出来，执行静态同步方法的时候就只有一条monitorexit指令，并没有monitorenter获取锁的指令。这就是锁的重入性，即在同一锁程中，线程不需要再次获取同一把锁。Synchronized先天具有重入性。每个对象拥有一个计数器，当线程获取该对象锁后，计数器就会加一，释放锁后就会将计数器减一。

任意一个对象都拥有自己的监视器，当这个对象由同步块或者这个对象的同步方法调用时，执行方法的线程必须先获取该对象的监视器才能进入同步块和同步方法，如果没有获取到监视器的线程将会被阻塞在同步块和同步方法的入口处，进入到BLOCKED状态.

在java代码中使用synchronized可是使用在代码块和方法中，根据Synchronized用的位置可以有这些使用场景：

volatile

在认识volatile关键字的作用之前我们先来补充一下三个概念:

1. 可见性:

可见性，是指线程之间的可见性，一个线程修改的状态对另一个线程是可见的。也就是一个线程修改的结果。另一个线程马上就能看到。比如：用volatile修饰的变量，就会具有可见性。volatile修饰的变量不允许线程内部缓存和重排序，即直接修改内存。所以对其他线程是可见的。但是这里需要注意一个问题，volatile只能让被他修饰内容具有可见性，但不能保证它具有原子性。比如 volatile int a = 0；之后有一个操作 a++；这个变量a具有可见性，但是a++ 依然是一个非原子操作，也就是这个操作同样存在线程安全问题。
在 Java 中 volatile、synchronized 和 final 实现可见性。

2. 原子性:

原子是世界上的最小单位，具有不可分割性。比如 a=0；（a非long和double类型） 这个操作是不可分割的，那么我们说这个操作时原子操作。再比如：a++； 这个操作实际是a = a + 1；是可分割的，所以他不是一个原子操作。非原子操作都会存在线程安全问题，需要我们使用同步技术（sychronized）来让它变成一个原子操作。一个操作是原子操作，那么我们称它具有原子性。java的concurrent包下提供了一些原子类，我们可以通过阅读API来了解这些原子类的用法。比如：AtomicInteger、AtomicLong、AtomicReference等。
在 Java 中 synchronized 和在 lock、unlock 中操作保证原子性。

3. 有序性

Java 语言提供了 volatile 和 synchronized 两个关键字来保证线程之间操作的有序性，volatile 是因为其本身包含“禁止指令重排序”的语义，synchronized 是由“一个变量在同一个时刻只允许一条线程对其进行 lock 操作”这条规则获得的，此规则决定了持有同一个对象锁的两个同步块只能串行执行。

volatile的两层语义

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。

2）禁止进行指令重排序。

先看一段代码，假如线程1先执行，线程2后执行：

//线程1
boolean stop = false;
while(!stop){
    doSomething();
}
 
//线程2
stop = true;

这段代码是很典型的一段代码，很多人在中断线程时可能都会采用这种标记办法。但是事实上，这段代码会完全运行正确么？即一定会将线程中断么？不一定，也许在大多数时候，这个代码能够把线程中断，但是也有可能会导致无法中断线程（虽然这个可能性很小，但是只要一旦发生这种情况就会造成死循环了）。

下面解释一下这段代码为何有可能导致无法中断线程。在前面已经解释过，每个线程在运行过程中都有自己的工作内存，那么线程1在运行的时候，会将stop变量的值拷贝一份放在自己的工作内存当中。

那么当线程2更改了stop变量的值之后，但是还没来得及写入主存当中，线程2转去做其他事情了，那么线程1由于不知道线程2对stop变量的更改，因此还会一直循环下去。

但是用volatile修饰之后就变得不一样了：

第一：使用volatile关键字会强制将修改的值立即写入主存；

第二：使用volatile关键字的话，当线程2进行修改时，会导致线程1的工作内存中缓存变量stop的缓存行无效（反映到硬件层的话，就是CPU的L1或者L2缓存中对应的缓存行无效）；

第三：由于线程1的工作内存中缓存变量stop的缓存行无效，所以线程1再次读取变量stop的值时会去主存读取。

那么在线程2修改stop值时（当然这里包括2个操作，修改线程2工作内存中的值，然后将修改后的值写入内存），会使得线程1的工作内存中缓存变量stop的缓存行无效，然后线程1读取时，发现自己的缓存行无效，它会等待缓存行对应的主存地址被更新之后，然后去对应的主存读取最新的值。
　　那么线程1读取到的就是最新的正确的值。

但是值得注意的是volatile关键字并不能保证原子性!

看一段代码:

public static volatile int i = 0;

    static class MyThread implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 10000; i++) {
                numSum();
            }
        }
    }

    public static void numSum(){
        i++;
    }

    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();

        Thread t1 = new Thread(myThread);
        t1.start();

        Thread t2 = new Thread(myThread);
        t2.start();


        Thread.sleep(4000);

        System.out.println(i);
    }

运行结果:

可以发现i的值并不是我们想要的20000,为什么会这样呢?volatile不是保证了i的可见性了吗?
其实是因为i++操作本身就不是一个原子性操作,
i++有三个步骤:

1. 将i从内存读取到缓存区.
2. 在缓存区自增1.
3. 写入到内存中.

volatile关键字不能保证i++在多线程情况下的正常操作,不具备原子性.

那么如何解决i++问题呢?

i++问题

如何使正确使变量i在多线程环境下自增呢?

1. 使用synchronized关键字修饰numSum方法或者加锁Lock…
2. 使用JAVA中的AtomicInteger类,

Volatile和Synchronized比较

1. 关键字volatile是线程同步的轻量级表现，所以volatile的性能肯定比synchronized要好，并且volatile只能修饰于变量，而synchronized可以修饰方法，以及代码块。

2. 多线程访问volatile不会发生阻塞，而synchronized会出现阻塞

3. volatile能保证数据的可见性，但是不能保证原子性。而synchronized可以保证原子性，也可以间接保证可见性，以为它会将私有内存和公共内存的数据作同步。

4. 关键字volatile解决的是变量在多个线程之间的可见性；而synchronized关键字解决的是多个线程之间访问资源的同步性。