volatile关键字的主要作用是使变量在多个线程间可见
JDK1.5开始对Thread进行了优化,对每个线程加了一块独立的内存空间。这个空间用于存放在thread中使用到的主线程中变量的副本,在线程运行过程中,直接在变量副本中操作,这样可以提高代码执行的效率。在下面代码中isRunning在线程执行过程中会使用,因此会将这个变量的副本放到线程独立的内存空间中。
public class RunThread extends Thread{
//volatile
private boolean isRunning = true;
private void setRunning(boolean isRunning){
this.isRunning = isRunning;
}
public void run(){
System.out.println("进入run方法..");
int i = 0;
while(isRunning == true){
//..
}
System.out.println("线程停止");
}
public static void main(String[] args) throws InterruptedException {
RunThread rt = new RunThread();
rt.start();
Thread.sleep(1000);
rt.setRunning(false);
System.out.println("isRunning的值已经被设置了false");
}
}
在Eclipse中console输出如下
若isRunning使用volatile成员变量修饰,即private volatile boolean isRunning = true;则当变量改变时,会强制线程执行引擎去主内存里读取
下面例子,10个线程对一个静态变量进行操作,最终的结果不一定是10000
import java.util.concurrent.atomic.AtomicInteger;
/**
* volatile关键字不具备synchronized关键字的原子性(同步)
*
*/
public class VolatileNoAtomic extends Thread{
private static volatile int count;
//private static AtomicInteger count = new AtomicInteger(0);
private static void addCount(){
for (int i = 0; i < 1000; i++) {
count++ ;
//count.incrementAndGet();
}
System.out.println(count);
}
public void run(){
addCount();
}
public static void main(String[] args) {
VolatileNoAtomic[] arr = new VolatileNoAtomic[10];
for (int i = 0; i < 10; i++) {
arr[i] = new VolatileNoAtomic();
}
for (int i = 0; i < 10; i++) {
arr[i].start();
}
}
}
Eclipse的console输出,运行结果如下图
为保证操作的原子性,做如下修改:
1.
//private static volatile int count;
private static AtomicInteger count = new AtomicInteger(0);//具备原子性
2.
//count++ ;
count.incrementAndGet();
run as -- java application,运行结果如下图:
volatile可以实现在多个线程之间的可见性,但是却不具备同步性(也就是原子性),可以算是一个轻量级的synchronized,性能要比synchronized强很多,不会造成阻塞(在很多开源的架构里,比如netty的底层代码就大量使用volatile,可见netty性能一定是非常不错的)。注意:一般volatile用于只针对于多个线程可见的变量操作,并不能代替synchronized的同步功能。要实现原子性建议使用atomic类的系列对象,支持原子性操作(注意:atomic类只保证本身方法原子性,并不保证多次操作的原子性)
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicUse {
private static AtomicInteger count = new AtomicInteger(0);
//多个addAndGet在一个方法内是非原子性的,需要加synchronized进行修饰,保证4个addAndGet整体原子性
/**synchronized*/
public synchronized int multiAdd(){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
count.addAndGet(1);
count.addAndGet(2);
count.addAndGet(3);
count.addAndGet(4);
return count.get();
}
public static void main(String[] args) {
final AtomicUse au = new AtomicUse();
List<Thread> ts = new ArrayList<Thread>();
for (int i = 0; i < 10; i++) {
ts.add(new Thread(new Runnable() {
@Override
public void run() {
System.out.println(au.multiAdd());
}
}));
}
for(Thread t : ts){
t.start();
}
}
}