Java多线程：线程间通信之volatile与sychronized

时间：2024-06-27 15:03:08

由前文Java内存模型我们熟悉了Java的内存工作模式和线程间的交互规范，本篇从应用层面讲解Java线程间通信。

Java为线程间通信提供了三个相关的关键字volatile, synchronized和final。对于final，我们在博文Java中static关键字和final关键字中已经介绍。

1. volatile

1.1. 定义

由volatile定义的变量其特殊性在于：

一个线程对变量的写一定对之后对这个变量的读的线程可见。

换言之

一个线程对volatile变量的读一定能看见它之前最后一个线程对这个变量的写。

1.2. 机理

volatile意味着可见性，在讲解volatile的机理前，我先给下面的这个例子：

package com.cielo.main;

/**

 * Created by 63289 on 2017/3/31.

 */

class MyThread extends Thread {

    private boolean isRunning = true;

    public boolean isRunning() {

        return isRunning;

    }

    public void setRunning(boolean isRunning) {

        this.isRunning = isRunning;

    }

    @Override

    public void run() {

        System.out.println("进入到run方法中了");

        while (isRunning == true) {

        }

        System.out.println("线程执行完成了");

    }

}

public class RunThread{

    public static void main(String[] args) {

        try {

            MyThread thread = new MyThread();

            thread.start();

            Thread.sleep(1000);

            thread.setRunning(false);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

}

在这个例子中，主线程启动了子线程，子线程成功进入run方法，输出”进入到run方法中”，只有由于isRunning==true，无限循环。此时，sleep一秒后的主线程想要改变isRunning的值，它将isRunning变量读取到它的内存空间进行修改后，写入主内存，但由于子线程一直在私有栈中读取isRunning变量，没有在主内存中读取isRunning变量，因此不会退出循环。

如果我们把isRunning赋值行改为：

private volatile boolean isRunning = true;
将其用volatile修饰，则强制该变量从主内存中读取。

这样我们也就明白了volatile的实现机理，即：

  1. 当一个线程要使用volatile变量时，它会直接从主内存中读取，而不使用自己工作内存中的副本。

  2. 当一个线程对一个volatile变量写时，它会将变量的值刷新到共享内存(主内存)中。

1.3. 特性：不会被重排序

从Java内存模型一篇中，我们简单了解了重排序，这里不会被重排序主要指语句重排序。

我们考虑到下面这个例子，有A,B两个线程

线程A：加载配置文件，将配置元素初始化，之后标识初始化成功。

Map configOptions ;

char[] configText;

volatile boolean initialized = false;

//线程A首先从文件中读取配置信息,调用process...处理配置信息,处理完成了将initialized 设置为true

configOptions = new HashMap();

configText = readConfigFile(fileName);

processConfig(configText, configOptions);//负责将配置信息configOptions 成功初始化

initialized = true;

线程B：等待初始化标识为true，之后开始工作。

while(!initialized)

{

    sleep();

}

//使用配置信息干活

doSomethingWithConfig();

很简单的一个例子，在编译器中，如果进行重排序，则会有将initialized=true这一行先执行的可能，如果这件事发生的话，线程B就会先运行，进而使用了没有加载配置文件的Object。而如果initialized变量使用了volatile修饰，则编译器不会将该变量的相关代码进行重排序。（当然，这里的例子只是为了直观，实际情况编译器的重排序会更加复杂）

1.4. 非原子性

使用volatile时，我们要清楚，volatile是非原子性的。

原子性即是指，对于一个操作，其操作的内容只有全部执行/全不执行两个状态，不存在中间态。而volatile并不能锁定某组操作，防止其他线程的干扰，即没有规定原子性，因而volatile是非原子性的。或者说，volatile是非线程安全的。

综上，如果我们想要使用一个原子性的修饰符来控制操作，即在操作变量时锁定变量，我们就需要另一个修饰词synchronized。

2. synchronized

2.1. 定义

synchronized作用的代码范围对于不同线程是互斥的，并且线程在释放锁的时候会将共享变量的值刷新到共享内存中。

2.2. synchronized与voliatile区别

  1. 使用：voliatile 用于修饰变量，synchronized可以修饰对象，类，方法，代码块，语句。

  2. 原子性：voliatile只保证变量的可见性，不能用于同步变量，即不保证原子性，多线程并发访问voliatile修饰的变量时也不会产生阻塞。synchronized是原子性的，只有锁定了变量的线程才能进入临界区，从而保证临界区的所有语句全部执行。多线程并发访问sychronized修饰的变量会产生阻塞。

  3. 机理：

当线程对volatile变量读时，会把工作内存中值置为无效。当线程对sychronized变量读时，会在该线程锁定变量时把工作内存中值置为无效。

当线程对voliatile变量写时，会把值刷新到主内存中。当线程对sychronized变量写时，会在变量解锁时把值刷新到主内存中。

2.3. 注意

  1. 无论synchronized加在方法上还是对象上，其修饰的都是对象，而不是方法或者某个代码块代码语句。

  2. 每个对象只有一个锁与之相关联。

  3. 实现同步需要很大的系统开销来做控制，不要做无谓的锁定。

2.4. synchronized的作用域

synchronized的作用域只有两种。实际上，synchronized直接作用于内存中的一个内存块，因此，可以通过锁定内存块来锁定一个实例变量或者锁定一个静态区域。

  1. 某个对象实例内

synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法，如果对象有多个synchronized方法，则只要一个线程访问了任何一个synchronized方法，其他线程不能同时访问任何一个该对象的synchronized方法(synchronized作用于对象，且每个对象只有一个锁)。

显然，不同对象的synchronized方法则不会互相影响(synchronized作用于对象)。

  1. 某个类的范围

又或者说作用于静态方法/静态代码块。synchronized static aMethod(){}防止多个线程同时访问这个类中的synchronized static方法，它可以对类的所有实例对象起作用。

2.5. synchronized应用

2.5.1. synchronized方法

每个实例对应一个lock,线程获得该含有synchronized方法的实例的锁才可以执行，否则阻塞。方法一旦执行，则一直到方法返回才可以释放锁。此后被阻塞的线程才能获得该锁。对于一个实例，其声明为synchronized的方法显然只有一个能处于执行状态。从而避免了类访问变量的冲突。

synchronized同步的开销很大，如果synchronized作用于一个比较大的方法上，显然是不合算的。

2.5.2. synchronized代码块

synchronized代码块形式如下：

        synchronized (synchronizedObject){

            //Some thing

        }

代码块内部代码必须在获得synchronizedObject的锁时才能执行。需要重点说的是synchronized(this)，这也是比较常用的代码块。

synchronized的效果类似于在方法前修饰，只是修饰的范围缩小成代码块。两个线程同时访问一个变量时，如果一个线程在执行synchronized的代码，那么该实例被锁定，另一个线程如果要访问该实例被synchronized作用的范围，则会被阻塞。

此外，如果不使用this作为锁，而是只是想让一段代码同步，可以临时创建如下锁：

    private byte[] lock=new byte[0];

从操作码上讲，创建一个长度为0的数组对象是最经济的，只需要3条操作码。

2.5.3. synchronized静态方法

synchronized修饰静态方法时或者在普通方法中以类为对象如下形式：

class StaticSynchronized{

    public void aMethod{

        synchronized (StaticSynchronized.class){

            //Some thing

        }

    }

}

为synchronized静态方法。

注意的是，对于同一个类，其static和实例方法如果都用synchronized修饰，其作用的必然不是同一个对象(显然)。

2.5.4. synchronized对象

比较简单粗暴的实现方式，直接把对象锁定，思路也很清晰。Java负责跟踪被加锁的对象，该锁定对象的线程每次给对象加锁时对象的计数器+1，每次解锁时计数器-1，如果对象的计数器为0，那么解除该线程的锁定。

3. 参考文章

如何使用 volatile, synchronized, final 进行线程间通信

JAVA多线程之volatile 与 synchronized 的比较

Java synchronized详解

​

相关文章