6.并发编程--volatile

并发编程--volatile

volatile-说明

• volatile关键字的作用是变量在多个线程可见；
• volatile 关键字是非原子性的
• 要是实现原子性操作，建议使用atomic类的系列对象：支持原子性操作（注意atomic类只保证本身方法的原子性，并不保证多次操作的原子性）

1. volatile :

• volatile关键字的作用是变量在多个线程可见；

示例：RunThread.java
说明：在Java中，每个线程都会有一个工作内存区域，其中存放所有线程共享的主内存中的变量的值得拷贝。当线程执行的时候，在自己的工作内存区域中操作这些变量。为了存取一个共享的变量，一个线程通常先获得锁定并清除当前线程的内存工作区域，把这些共享变量从所有线程的共享内存区域中正确的装入到本身所以在的工作内存区域中，当线程解锁是保证该工作内存中的变量的值写会到共享内存区域中。

• * 一个线程可以执行的操作有：使用（use），赋值(assgin)，装载（load），存储(store)，锁定(lock)，解锁（unlock）;
• * 主内存中可以执行的操作有：读(read)，写(write)，锁定(lock)，解锁（unlock）; 每个操作都是原子性的。
• * volatile 的作用就是强制线程到主内存（共享内存）中去读取变量，而不是去线程工作内存区域里去读取，从而实现了多个线程间的变量可见。也就满足了线程安全的可见性；

public class RunThread extends Thread{

    private volatile boolean isRunning = true;
    private void setRunning(boolean isRunning){
        this.isRunning = isRunning;
    }

    public void run(){
        System.out.println("进入run方法..");
        int i = 0;
        while(isRunning == true){
            //..
        }
        System.out.println("线程停止");
    }

    public static void main(String[] args) throws InterruptedException {
        RunThread rt = new RunThread();
        rt.start();
        Thread.sleep(1000);
        rt.setRunning(false);
        System.out.println("isRunning的值已经被设置了false");
    }
}

View Code

2. volatile 关键字是非原子性的

volatile 关键字虽然拥有多个线程之间的可见性，但是却不具备同步性(也就是原子性)，可以算是一个轻量级的synchronized，性能要不synchronized强很多，不会造成阻塞(很多开源架构里面：netty的底层代码大量使用可volatile，可见netty性能)

• * 需要注意的事：一般volatile用于多个线程可见的变量操作，并不能替代synchronized的同步作用；

示例：concurrent.java
说明：volatile 关键字只具有可见性，没有原子性。

 1 import java.util.concurrent.atomic.AtomicInteger;
 2 /**
 3 * volatile关键字不具备synchronized关键字的原子性（同步）
 4 * @@author Maozw
 5 *
 6 */
 7 public class VolatileNoAtomic extends Thread{
 8     //private static volatile int count;
 9     private static AtomicInteger count = new AtomicInteger(0);
10     private static void addCount(){
11       for (int i = 0; i < 1000; i++) {
12         //count++ ;
13         count.incrementAndGet();
14       }
15       System.out.println(count);
16     }
17 
18     public void run(){
19       addCount();
20     }
21 
22     public static void main(String[] args) {
23 
24       VolatileNoAtomic[] arr = new VolatileNoAtomic[100];
25       for (int i = 0; i < 10; i++) {
26         arr[i] = new VolatileNoAtomic();
27       }
28 
29       for (int i = 0; i < 10; i++) {
30         arr[i].start();
31       }
32     }
33 }

• * 要是实现原子性操作，建议使用atomic类的系列对象：支持原子性操作（注意atomic类只保证本身方法的原子性，并不保证多次操作的原子性）

示例：
说明：

 1 import java.util.ArrayList;
 2 import java.util.List;
 3 import java.util.concurrent.atomic.AtomicInteger;
 4 
 5 public class AtomicUse {
 6 
 7 private static AtomicInteger count = new AtomicInteger(0);
 8 
 9     //多个addAndGet在一个方法内是非原子性的，需要加synchronized进行修饰，保证4个addAndGet整体原子性
10     /**synchronized*/
11     public synchronized int multiAdd(){
12         try {
13           Thread.sleep(100);
14         } catch (InterruptedException e) {
15           e.printStackTrace();
16         }
17         count.addAndGet(1);
18         count.addAndGet(2);
19         count.addAndGet(3);
20         count.addAndGet(4); //+10
21         return count.get();
22     }
23     public static void main(String[] args) {
24 
25       final AtomicUse au = new AtomicUse();
26 
27       List<Thread> ts = new ArrayList<Thread>();
28       for (int i = 0; i < 100; i++) {
29         ts.add(new Thread(new Runnable() {
30           @Override
31           public void run() {
32             System.out.println(au.multiAdd());
33           }
34         }));
35       }
36       for(Thread t : ts){
37         t.start();
38       }
39     }
40 }