Java多线程之可见性与原子性——synchronized VS volatile

<转：http://blog.csdn.net/uniquewonderq/article/details/48113071>

 

 

 

 

 

 

 

 

 

 

 

 

程序举例：

代码：

 

[java] view plain copy

 

1. package com.synch;  
2. public class SynchronizedDemo {  
3.     //共享变量  
4.     private boolean ready = false;  
5.     private int result = 0;  
6.     private int number = 1;     
7.     //写操作  
8.     public synchronized void write(){  
9.         ready = true;                                         
10.         number = 2;                                       
11.     }  
12.     //读操作  
13.     public synchronized void read(){                   
14.         if(ready){                             
15.             result = number*3;        
16.         }         
17.         System.out.println("result的值为：" + result);  
18.     }  
19.   
20.     //内部线程类  
21.     private class ReadWriteThread extends Thread {  
22.         //根据构造方法中传入的flag参数，确定线程执行读操作还是写操作  
23.         private boolean flag;  
24.         public ReadWriteThread(boolean flag){  
25.             this.flag = flag;  
26.         }  
27.         @Override                                                                      
28.         public void run() {  
29.             if(flag){  
30.                 //构造方法中传入true，执行写操作  
31.                 write();  
32.             }else{  
33.                 //构造方法中传入false，执行读操作  
34.                 read();  
35.             }  
36.         }  
37.     }  
38.   
39.     public static void main(String[] args)  {  
40.         SynchronizedDemo synDemo = new SynchronizedDemo();  
41.         //启动线程执行写操作  
42.         synDemo .new ReadWriteThread(true).start();  
43. //      try {  
44. //          Thread.sleep(1000);  
45. //      } catch (InterruptedException e) {  
46. //          // TODO Auto-generated catch block  
47. //          e.printStackTrace();  
48. //      }  
49.         //启动线程执行读操作  
50.         synDemo.new ReadWriteThread(false).start();  
51.     }  
52. }  

 

 

 

 

 

 

 

 

 

 

 

代码示例：

 

[java] view plain copy

 

1. package com.synch;  
2.   
3. import java.util.concurrent.locks.Lock;  
4. import java.util.concurrent.locks.ReentrantLock;  
5.   
6. public class VolatileDemo {  
7.   
8.     private Lock lock = new ReentrantLock();  
9.     private int number = 0;  
10.       
11.     public int getNumber(){  
12.         return this.number;  
13.     }  
14.       
15.     public void increase(){  
16.         try {  
17.             Thread.sleep(100);  
18.         } catch (InterruptedException e) {  
19.             // TODO Auto-generated catch block  
20.             e.printStackTrace();  
21.         }  
22.         lock.lock();  
23.         try {  
24.             this.number++;  
25.         } finally {  
26.             lock.unlock();  
27.         }  
28.     }  
29.       
30.     /** 
31.      * @param args 
32.      */  
33.     public static void main(String[] args) {  
34.         // TODO Auto-generated method stub  
35.         final VolatileDemo volDemo = new VolatileDemo();  
36.         for(int i = 0 ; i < 500 ; i++){  
37.             new Thread(new Runnable() {  
38.                   
39.                 @Override  
40.                 public void run() {  
41.                     volDemo.increase();  
42.                 }  
43.             }).start();  
44.         }  
45.           
46.         //如果还有子线程在运行，主线程就让出CPU资源，  
47.         //直到所有的子线程都运行完了，主线程再继续往下执行  
48.         while(Thread.activeCount() > 1){//让所有的子线程都执行完后，然后再执行<pre name="code" class="java">//System.out.println("number : " + volDemo.getNumber());   语句。因为主线程算一个。当活跃线程为1时，也就是所有的子线程执行完毕了。此///时退出while 循环执行输出语句。  

Thread.yield();}System.out.println("number : " + volDemo.getNumber());}}