volatile
我们在代码中开启一个线程之后,想要依据某些条件去控制线程是否结束的时候,可以通过定义一个 volatile 关键字修饰的变量去进行操作。示例代码如下:
public class RunThread extends Thread {
private volatile boolean isRunning;
public void setRunning(boolean running) {
isRunning = running;
}
@Override
public void run() {
System.out.println("进入线程。。。");
while (isRunning) {
// do something
}
System.out.println("线程结束");
}
public static void main(String[] arg0) throws InterruptedException {
RunThread t1 = new RunThread();
t1.start();
Thread.sleep(3000);
t1.setRunning(false);
Thread.sleep(1000);
System.out.println("t1 isRunnung : " + t1.isRunning);
}
}
打印结果:
结果正常,没毛病。
那么我们多个线程调用呢?是否还能达到预期效果?我们来试一下:
public class RunThread1 extends Thread {
private static volatile int count;
private static void addCount() {
for (int i = 0; i < 1000; i++) {
count++;
}
System.out.println(count);
}
@Override
public void run() {
addCount();
}
public static void main(String[] arg0) {
RunThread1[] ts = new RunThread1[10];
for (int i = 0; i < 10; i++) {
ts[i] = new RunThread1();
}
for (int i = 0; i < 10; i++) {
ts[i].start();
}
}
}
运行结果:
正常来说,我们最终的结果肯定要是 10000 才是正常的,但是这个输出的结果,明显与我们的预期不相符。
验证结果:volatile 线程间可见性,非原子性,属于线程不安全。
Atomic
那么如果我们上面的多线程调用情况我们要怎么办呢? 这里提供一种写法:
public class RunThread2 extends Thread {
private static AtomicInteger count = new AtomicInteger();
private static void addCount() {
for (int i = 0; i < 1000; i++) {
count.getAndIncrement();
}
System.out.println(count);
}
@Override
public void run() {
addCount();
}
public static void main(String[] arg0) {
RunThread2[] ts = new RunThread2[10];
for (int i = 0; i < 10; i++) {
ts[i] = new RunThread2();
}
for (int i = 0; i < 10; i++) {
ts[i].start();
}
}
}
打印结果:
最终输出结果,是不是有 10000 了, 有时候编译器有些延迟,但是不影响我们每次的打印结果都有 10000 。
这里简略的介绍一下 Atomic 包:Java从JDK1.5开始提供了java.util.concurrent.atomic包,方便程序员在多线程环境下,无锁的进行原子操作。原子变量的底层使用了处理器提供的原子指令,但是不同的CPU架构可能提供的原子指令不一样,也有可能需要某种形式的内部锁,所以该方法不能绝对保证线程不被阻塞。
当然 Atomic 包中还有其他原子更新方式,比如 AtomicBoolean , AtomicLong , AtomicIntegerArray , AtomicLongArray , AtomicReferenceArray.. 等等。有需要的还请各位自行 Google.
学习笔记整理。