并发编程总结之volatile

并发编程
许进
多线程, 并发编程
阅读次
× 文章目录
  1. 1. volatile概念
    1. 1.1. volatile概念-具有可见性
      1. 1.1.1. 代码示例
      2. 1.1.2. 示例代码线程操作内存简图
      3. 1.1.3. 小结
    2. 1.2. volatile-不具有原子性
      1. 1.2.1. 示例代码1
      2. 1.2.2. 示例代码2

摘要:本节主要介绍了 volatile关键字的作用是使变量在多个线程间可见,但是不具有原子性，以及volatile的运行内存介绍。

  1. 在java中，每个线程都会有一块工作内存区，其中存放着所有线程共享的主内存中的变量值的拷贝。当线程执行时，它在自己的工作区内存中操作这些变量。为了存取一个共享的变量，一个线程通常会先获取锁定并清除它的内存工作区，把这些共享变量从所有线程的共享内存中正确的装入到它自己所在的工作内存中，当线程解锁时，保证该工作内存中变量的值写回到共享内存中。

  2. volatile的作用就是强制线程到主内存(共享内存)里去读取变量，而不去线程工作区内存里去读取，从而实现了多个线程间的变量可见，也就是满足线程安全的可见性。

volatile概念

volatile概念-具有可见性

volatile关键字的作用是使变量在多个线程间可见。

代码示例

如下代码所示，当isRunning没有被volatile关键字修饰的时候，程序一直循环，线程不会结束。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class RunThread extends Thread {
    // isRunning没有被volatile关键字修饰
    private boolean isRunning = true;//①
    private void setRunning(boolean isRunning) {
        this.isRunning = isRunning;
    }
    public void run() {
        System.out.println("开始进入run方法..");
        while (isRunning == true) {
            // 一直循环........
        }
        System.out.println("while循环结束,线程停止");
    }
    public static void main(String[] args) throws InterruptedException {
        RunThread rt = new RunThread();
        rt.start();
        Thread.sleep(3000);
        rt.setRunning(false);
        System.out.println("isRunning的值已经被设置了false");
        Thread.sleep(1000);
        System.out.println(rt.isRunning);
    }
}

当把上述代码的①处，修改为如下时:

1
private volatile boolean isRunning = true;

运行结果是isRunning修改为false之后，线程读取到isRunning = false，从而线程结束while循环，线程退出

1
2
3
4
开始进入run方法..
isRunning的值已经被设置了false
while循环结束,线程停止
false

示例代码线程操作内存简图

小结

  1. 在java中，每个线程都会有一块工作内存区，其中存放着所有线程共享的主内存中的变量值得拷贝。当线程执行时，它在自己的工作区内存中操作这些变量。为了存取一个共享的变量，一个线程通常会先获取锁定并清除它的内存工作区，把这些共享变量从所有线程的共享内存中正确的装入到它自己所在的工作内存中，当线程解锁时，保证该工作内存中变量的值写回到共享内存中。
  2. 一个线程可以执行的操作有使用(use)，赋值(assign),装载(load),存储(store),锁定(lock),解锁(unlock)。而主内存可以执行的操作有读(read),写(write),锁定(lock),解锁（unlock)，每个操作都是原子的。
  3. volatile的作用就是强制线程到主内存(共享内存)里去读取变量，而不去线程工作区内存里去读取，从而实现了多个线程间的变量可见，也就是满足线程安全的可见性。

volatile-不具有原子性

volatile关键字虽然拥有多个线程之间的可见性，但是不具备同步性，也就是原子性，可以算得上一个轻量级别的synchronized,性能要比synchronized强很多，不会造成阻塞(在很多开源框架，比如Netty的底层代码就大量的使用volatile，由此可见Netty的性能非常不错),但是需要注意的是，volatile用于只针对于多个线程可见的变量操作，并不能替代synchronized的同步功能。

示例代码1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class VolatileNoAtomic extends Thread {
    private static volatile int count;
    private static void addCount() {
        for (int i = 0; i < 1000; i++) {
            count++;
        }
        System.out.println(count);
    }
    public void run() {
        addCount();
    }
    public static void main(String[] args) {
        VolatileNoAtomic[] arr = new VolatileNoAtomic[100];
        for (int i = 0; i < 10; i++) {
            arr[i] = new VolatileNoAtomic();
        }
        for (int i = 0; i < 10; i++) {
            arr[i].start();
        }
    }
}

运行结果，随机因为volatile没有原子性，所以最终打印结果不是10000

示例代码2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class VolatileNoAtomic extends Thread {
    private static AtomicInteger count = new AtomicInteger(0);
    private static void addCount() {
        for (int i = 0; i < 1000; i++) {
            count.incrementAndGet();
        }
        System.out.println(count);
    }
    public void run() {
        addCount();
    }
    public static void main(String[] args) {
        VolatileNoAtomic[] arr = new VolatileNoAtomic[100];
        for (int i = 0; i < 10; i++) {
            arr[i] = new VolatileNoAtomic();
        }
        for (int i = 0; i < 10; i++) {
            arr[i].start();
        }
    }
}

运行最终打印结果是:10000

小结:volatile关键字只有可见性，没有原子性。要实现原子性建议使用atomic类的系列对象，支持原子性操作。

注意atomic类只保证本身方法的原子性，并不保证多次操作的原子性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package org.xujin.multithread.sync007;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * @author xujin
 */
public class AtomicUse {
    private static AtomicInteger count = new AtomicInteger(0);
   // 多个addAndGet在一个方法内是非原子性的，需要加synchronized进行修饰，保证4个addAndGet整体原子性
    /** synchronized */
    public synchronized int multiAdd() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        count.addAndGet(1);
        count.addAndGet(2);
        count.addAndGet(3);
        count.addAndGet(4); // +10,执行到这里相当于加10->1+2+3+4=10，
        return count.get();
    }
    public static void main(String[] args) {
        final AtomicUse au = new AtomicUse();
        List<Thread> ts = new ArrayList<Thread>();
        for (int i = 0; i < 100; i++) {
            ts.add(new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(au.multiAdd());
                }
            }));
        }
        for (Thread t : ts) {
            t.start();
        }
    }
}
本文由许进创作和发表,采用CC BY 3.0 CN协议 进行许可。转载请注明作者及出处,本文作者为许进,本文标题为并发编程总结之volatile 本文链接为http://xujin.org/bf/bf-volatile/
如果您觉得文章不错,可以打赏我喝一杯咖啡！