并发编程基础之volatile关键字的用法

一：概念

volatile关键字是一个轻量级的线程同步，它可以保证线程之间对于共享变量的同步，假设有两个线程a和b，

它们都可以访问一个成员变量，当a修改成员变量的值的时候，要保证b也能够取得成员变量最新的值，程序的

内存模型是这样的，程序运行时，成员变量的值被加载到内存中，如果线程a运行时，会把变量的值拷贝到cpu分配

给a的高速缓存区，就是内存的一个副本，线程b运行时，会把变量拷贝到cpu分配给b的高速缓存区，正常情况下，

a线程修改成员变量时，会将高速缓存中的值写入主存，然后b线程运行时读取主存中值到缓存，但是不是强制性的，

使用volatile关键字就是强制性。

1：将高速缓存强制写入主内存

2：会使b线程高速缓存标记失效

二：比较经典的一个示例

t1线程先启动，然后一直打印‘i love u’,这时t2线程启动，将flag变量的值修改为true，然后t1线程的执行终止，如果flag变量不加volatile修饰，

出现死循环的概率是存在的，但是比较低，如果加volatile，会强制t2线程修改主内存中flag的值，而且t1线程高速缓存标记会失效，可以保证

一定能够终止t1程序的执行

/**
 * 
 */
package com.day2;

/**
 * @author Administrator
 *
 */
public class ListAdd1 {
	
	private boolean flag;
	
	public static void main(String[] args) {
		ListAdd1 list = new ListAdd1();
		
		//线程1
		Thread t1 = new Thread("t1"){
			public void run(){
				while(!list.flag){
					System.out.println("i love u");
				}
			}
		};
		
		//线程2
		Thread t2 = new Thread("t2"){
			public void run(){
				list.flag = true;
			}
		};
		
		t1.start();
		//保证t1线程先启动
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t2.start();
	}
	
	
}

private volatile boolean flag;

　　

但是volatile并不能保证操作的原子性，线程抢到cpu的时间片，修改高速缓存的值，写入主内存这几个过程不是原子的，

int i = 0；

i = i+1；

如果线程1在抢到cpu的时间片之后，还没有修改高速缓存的值，然后线程2也读取了主内存中缓存的值i = 0，然后执行加1，

写入高速缓存，线程1之前读取缓存中的值也是0，然后执行加1，写入主内存，这样就出现问题了，所以使用volatile不能

保证线程安全问题。

如下示例：

启动10个线程，count初始值为0，正常情况，10个线程个循环1000次，最后的count值应该为10000，但是不是，这个值

是随机的。

/**
 * 
 */
package com.day2;

/**
 * @author Administrator
 *
 */
public class ListAdd2 {
	
	private volatile int count;
	
	public static void main(String[] args) {
		ListAdd2 list = new ListAdd2();
		
		System.out.println(list.count);
		
		for(int i=0;i<10;i++){
			new Thread("t"+i){
				public void run(){
					for(int j=0;j<1000;j++){
						list.count++;
					}
				}
			}.start();
		}
		
		System.out.println(list.count);
	}
	
	
}

　　

如果想确保线程安全，那么必须使用synchronized锁

synchronized (list) {
							list.count++;
						}

　

因为10个线程访问的是同一个实例，所以使用对象锁就可以了。