6.volatile关键字。

1. Volatile关键字的主要作用是使变量在多个线程间可见。
2.     在java中，每一个线程都会有一块内存区，其中存放着所有线程共享的主内存中变量值的拷贝，当线程执行时，他在自己的工作内存中操作这些变量，为了存取一个共享变量，一个线程通常先获取锁定并清除他的内存工作区，把这些变量从所有的共享内存区中装入到他自己所在的工作内存区中，当线程结束时保证该工作内存区中变量的值回到共享内存中。
3.    Volatile的作用就是强制线程到主内存里去读取变量，而不是去线程内存区里读取，从而实现了多个线程间变量的可见性，也就是满足线程安全的可见性。
4. public class RunThread extends Thread{
5.     使用volatile关键字
6.    private volatile boolean isRunning = true;
7.    private void setRunning(boolean isRunning){
8.       this.isRunning = isRunning;
9.    }
10.   
11.    public void run(){
12.       System.out.println("进入run方法..");
13.       int i = 0;
14.       while(isRunning == true){
15.          //..
16.       }
17.       System.out.println("线程停止");
18.    }
19.   
20.    public static void main(String[] args) throws InterruptedException {
21.       RunThread rt = new RunThread();
22.       rt.start();
23.       Thread.sleep(1000);
24.       rt.setRunning(false);
25.       System.out.println("isRunning的值已经被设置了false");
26.    }
27.   
28.   
29. }
30. 输出结果：
31. 进入run方法..
32. isRunning的值已经被设置了false
33. 线程停止
34.  
35. public class RunThread extends Thread{
36.      
37.    private  boolean isRunning = true;
38.    private void setRunning(boolean isRunning){
39.       this.isRunning = isRunning;
40.    }
41.   
42.    public void run(){
43.       System.out.println("进入run方法..");
44.       int i = 0;
45.       while(isRunning == true){
46.          //..
47.       }
48.       System.out.println("线程停止");
49.    }
50.   
51.    public static void main(String[] args) throws InterruptedException {
52.       RunThread rt = new RunThread();
53.       rt.start();
54.       Thread.sleep(1000);
55.       rt.setRunning(false);
56.       System.out.println("isRunning的值已经被设置了false");
57.    }
58.   
59.   
60. }
61.  
62. 输出结果：未使用volatile关键字，isRunning改变,线程未发现改变。
63. 进入run方法..
64. isRunning的值已经被设置了false
65. Volatile关键字拥有多个线程的可见性，却不具备同步性（原子性）可以算是一个轻量级的synchronized,性能比synchronized强的多，不会造成阻塞，。Volatile只针对多线程可见性，并不能替换sychronized同步的功能。
66. public class AtomicUse {
67.             可见的但不同步
68.    private static AtomicInteger count = new AtomicInteger(0);
69.   
70.    //多个addAndGet在一个方法内是非原子性的，需要加synchronized进行修饰，保证4个addAndGet整体原子性
71.    /**synchronized*/同步
72.    public synchronized int multiAdd(){
73.          try {
74.             Thread.sleep(100);
75.          } catch (InterruptedException e) {
76.             e.printStackTrace();
77.          }
78.          count.addAndGet(1);
79.          count.addAndGet(2);
80.          count.addAndGet(3);
81.          count.addAndGet(4); //+10
82.          return count.get();
83.    }
84.   
85.   
86.    public static void main(String[] args) {
87.      
88.       final AtomicUse au = new AtomicUse();
89.  
90.       List<Thread> ts = new ArrayList<Thread>();
91.       for (int i = 0; i < 100; i++) {
92.          ts.add(new Thread(new Runnable() {
93.             @Override
94.             public void run() {
95.                 System.out.println(au.multiAdd());
96.             }
97.          }));
98.       }
99.  
100.       for(Thread t : ts){
101.          t.start();
102.       }
103.  
104.  
105.   
106.      
107.  
108.      
109.    }
110. }
111. 输出结果：
112. 10
113. 20
114. 30
115. 40
116. 50
117. 60
118. …………………….
119.