Volatile

[align=center][size=large]Volatile[/size][/align]

一、概念

volatile : 作用是保证变量在线程间的可见性

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

package com.study.current.thread.day01;

/**
 * volatile 线程间可见
 * 不具备原子性，只可以使一个变量在多个线程间可见
 * 
 * @description 
 * 线程t1 运行，根据 isRunnable 的值去执行
 * 在Main线程中，修改 isRunnable 的值，去停止 t1 的运行
 * volatile 使两个线程间共享 变量 isRunnable 的值
 * 
 * <p>
 *  
 * 每个线程都有自己独立的运行空间，线程在运行前拷贝主线程中的变量到自己的运行空间中
 * 每次线程运行时，都去自己空间中查看运行时需要的变量的值；
 * volatile 强制	去主内存空间中读取数据
 *
 * 
 */
public class RunThread extends Thread {
	/**
	 * 不加 volatile 
	 * 运行结果：
	 *  进入 run 方法
		setValue  ---  false 
		false

		程序未停止
	 */
	private volatile boolean isRunnable = true ;

	public void setValue(boolean isRunnable){
		this.isRunnable = isRunnable ;
	}

	public void run() {
		System.out.println("进入 run 方法");
		while(isRunnable){

		}
		System.out.println("退出 run 方法");
	}


	/**
	 * @param args
	 * @throws InterruptedException 
	 */
	public static void main(String[] args) throws InterruptedException {

		RunThread rt = new RunThread();
		rt.start();
		Thread.sleep(3000);

		rt.setValue(false);
		System.out.println("setValue  ---  false ");
		Thread.sleep(1000);

		System.out.println(rt.isRunnable);
	}

}

一个线程可以执行的操作有 使用user / 复制 assign / 装载loan / 存储 store / 锁定 lock / 解锁 unlock
而主内存可以执行的操作有 读 read / 写 write / 锁定 lock / 解锁 unlock ，每个操作都是原子的

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

二、volatile 不是原子性的

volatile 关键字虽然拥有多个线程间的可见性，但是却不具备同步性（原子性）
可以算上是一个轻量级的 synchronized ，性能比 synchronized 强的多，不会造成阻塞
一般 volatile 用于只针对于多个线程可见的变量操作，并不能代替 synchronized 的同步功能

原子性的操作使用 AtomicInteger

package com.study.current.thread.day01;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * volatile 无原子性
 * 每次加1000次，加10次，最终结果为 10000
 * 运行结果不为10000
 * 
 * 
 */
public class VolatileNoAtomic extends Thread {
	public static volatile int count  ; // 此处赋值 0 ，则符合，
//	public static AtomicInteger count = new AtomicInteger(0);

	public static void add(){
		for(int i = 0 ; i < 1000 ; i++){
			count ++ ;
//			count.incrementAndGet();
		}
		System.out.println("add() -- count:"+count);
	}

	public void run(){
		add();
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		VolatileNoAtomic[] vn = new VolatileNoAtomic[10];
		for(int i = 0 ; i < 10 ; i ++){
			vn[i] = new VolatileNoAtomic();
		}

		for(int i = 0 ; i < 10 ; i++){
			vn[i].start();
		}


	}

}

四、AtomicInteger 的原子性只是当前方法的原子性保证，当多次运行时不一定能够保证

package com.study.current.thread.day01;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * atomic 只保证本身操作的原子性，不保证多次操作的原子性
 */
public class AtomicUse {

	public static AtomicInteger count = new AtomicInteger(0);

	/**
	 * 如果不加 synchronized
	 * 
	 * 最终输出结果依然是正确的，但过程中是不对的，
	 * 如果是原子性的，每次累加10
	 * @return
	 */
	public synchronized int add(){
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		count.addAndGet(1);
		count.addAndGet(2);
		count.addAndGet(3);
		count.addAndGet(4);
		return count.get();

	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		final AtomicUse au = new AtomicUse();

		List<Thread > list = new ArrayList<Thread>(10);
		for(int i = 0 ; i < 10 ; i++){
			list.add(new Thread(new Runnable() {

				public void run() {
					int count = au.add();
					System.out.println(count );
				}
			})) ;
		}

		for(int i = 0 ; i< 10 ; i++){
			list.get(i).start();
		}
	}

}