volatile概念：
volatile关键字的主要作用是使变量在多线程间可见。
示例1：
package test;
public class RunThread extends Thread{
private boolean isRunning = true;
//private volatile 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");
}
}
结果：
不使用volatile结果：
进入run方法..
isRunning的值已经被设置了false
false
使用volatile结果：
进入run方法..
isRunning的值已经被设置了false
线程停止
false
示例总结：
在java中，每一个线程都会有一块工作内存区，其中天存放着所有线程共享的主内存中的变量值得拷贝，当线程执行时，他在自己的工作内存区中操作这些变量。为了存取一个共享变量，一个线程通常先获取锁定并去清除它的内存工作区，把这些共享变量从所有线程的共享内存中正确的装入到它自己所在的工作内存区中，当线程解锁时保证该工作内存区中变量的值写回到共享内存中。
一个线程可以执行的操作有使用，赋值，装载，存储，锁定，解锁。而主内存可以执行的操作有读 ，写，锁定，解锁，每个操作都是原子的
volatile的 作用就是强制线程到主内存(共享内存)去读写变量，而不去线程工作内存区里去读取，从而实现了多个线程间的变量可见，也就是满足线程安全的可见性。
volatile关键字的非原子性
volatile关键字虽然拥有多个线程之间的可见性，但是却不具备同步性（也就是原子性），可以算上是一个轻量级的synchroized，性能要比synchroized强的很多，不会造成阻塞（在很多开源的架构里，比如netty的底层代码就是大量使用volatile，可见netty性能一定是非常不错的。）这里需要注意：一般volatile用于只针对多个线程可见的变量操作，并不能代替synchroized的同步功能。
示例2：
package test;
import java.util.concurrent.atomic.AtomicInteger;
/**
* volatile关键字不具备synchronized关键字的原子性（同步）
* @author alienware
*
*/
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[100];
for (int i = 0; i < 10; i++) {
arr[i] = new VolatileNoAtomic();
}
for (int i = 0; i < 10; i++) {
arr[i].start();
}
}
}
结果：（结果是随机的，正常最后的值为10000）
1000
2000
3000
5000
4000
6671
7660
7154
8660
9660
示例总结：
volatile关键字只具有可见性，没有原子性 。要实现原子性建议使用atomic类的系列对象，支持原子性操作（注意atomic类只保证本身方法 原子性，并不保证多次操作的原子性）
示例3：
package test;
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 int multiAdd(){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
count.addAndGet(1);
count.addAndGet(2);
count.addAndGet(3);
count.addAndGet(4); //+10
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 < 100; i++) {
ts.add(new Thread(new Runnable() {
@Override
public void run() {
System.out.println(au.multiAdd());
}
}));
}
for(Thread t : ts){
t.start();
}
}
}
示例总结：
通过上面的例子可以看出（tomic类只保证本身方法 原子性，并不保证多次操作的原子性），案例中会出现不是整10的结果例如991这样的数字（随机的）,就表明count.addAndGet(1);count.addAndGet(2);count.addAndGet(3);count.addAndGet(4); 多次相加没有保证原子性。只是对一次相加具有原子性。