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

 

 

 

 

 

 

 

 

 

 

 

程序举例:

代码:

 

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

 



 

 

 

posted on 2017-06-06 18:29  快鸟  阅读(293)  评论(0编辑  收藏  举报