java多线程总结-同步之volatile关键字

目录

• 1 案例之变量内存可见性
• 2 案例之变量的原子性

1 案例之变量内存可见性

代码解析：新起一个子线程执行m()方法，1秒后主线程将b置为false，子线程是否会停止执行死循环while(b){},打印“end”

package com.bernardlowe.concurrent.t01;

import java.util.concurrent.TimeUnit;

public class Test_09 {
	
	boolean b = true;
	
	void m(){
		System.out.println("start");
		while(b){}
		System.out.println("end");
	}
	
	public static void main(String[] args) {
		final Test_09 t = new Test_09();
		new Thread(new Runnable() {
			@Override
			public void run() {
				t.m();
			}
		}).start();
		
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		t.b = false;
	}
	
}

**结果：1秒钟过后并不会停止执行死循环while(b){},打印“end” **
这时候，如果将boolean b = true;这段代码前加一个volatile关键字
即volatile boolean b = true;，就会达到预想中的效果

思考：为什么加上这个关键字，其他线程就会读取到已经改变的变量的值了？

是因为在CPU计算过程中，会将计算过程需要的数据加载到CPU计算缓存中，当CPU计算中断时，有可能刷新缓存，重新读取内存中的数据。在线程运行的过程中，如果某变量被其他线程修改，可能造成数据不一致的情况，从而导致结果错误。
而volatile修饰的变量是线程可见的，当JVM解释volatile修饰的变量时，会通知CPU，在计算过程中，每次使用变量参与计算时，都会检查内存中的数据是否发生变化，而不是一直使用CPU缓存中的数据，可以保证计算结果的正确。

但是这样还有一个问题，volatile只能保证可见性，不能保证原子性

2 案例之变量的原子性

下面再看一个示例：
预期结果：起10个线程，每个线程都对count增加10000，预期结果为count=100000

package com.bernardlowe.concurrent.t01;

import java.util.ArrayList;
import java.util.List;

public class Test_10 {
	
	volatile int count = 0;
	/*synchronized*/ void m(){
		for(int i = 0; i < 10000; i++){
			count++;
		}
	}
	
	public static void main(String[] args) {
		final Test_10 t = new Test_10();
		List<Thread> threads = new ArrayList<>();
		for(int i = 0; i < 10; i++){
			threads.add(new Thread(new Runnable() {
				@Override
				public void run() {
					t.m();
				}
			}));
		}
		for(Thread thread : threads){
			thread.start();
		}
		for(Thread thread : threads){
			try {
				thread.join();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println(t.count);
	}
}

但结果并不是

原因是volatile只是通知底层计算时，CPU检查内存数据，而不是让一个变量在多个线程中同步。

这时候可以给m()方法增加一个synchronized关键字，可以达到预期的效果，即synchronized void m()

还有另一种方法可以保证原子性，在上面代码将count声明为AtomicInteger原子操作，结果仍然是100000

	// 其中的每个方法都是原子操作。可以保证线程安全。
	AtomicInteger count = new AtomicInteger(0);
	void m(){
		for(int i = 0; i < 10000; i++){
			count.incrementAndGet();
		}
	}

这里不仅仅可声明Integer类型，java.util.concurrent.atomic包里面还有其他类型的