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);
}
}
复制代码
但结果并不是
这时候可以给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包里面还有其他类型的