架构师养成记--4.volatile关键字

volatile修饰的变量可在多个线程间可见。

如下代码，在子线程运行期间主线程修改属性值并不对子线程产生影响，原因是子线程有自己独立的内存空间，其中有主内存中的变量副本。

 public class RunThread extends Thread{

     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");
     }

 }

那么如何达到预期效果让子线程停止呢？那就是变量isRunning使用volatile修饰，原理如下图

需要注意的一点是，volatile关键字修饰的变量只有可见性，没有原子性。如下代码，如果使用第九行代码的话最终打印结果不是10000

 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();
         }
     }

 }

那么如何才能有原子性呢？可以对对象进行AtimicInteger　　修饰

多个addAndGet在一个方法内是非原子性的，需要加synchronized进行修饰，保证4个addAndGet整体原子性

 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); //+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();
         }

     }
 }