Java线程安全 关于原子性与volatile的试验

1. 变量递增试验

     static /*volatile*/ int shared=0;//volatile也无法保证++操作的原子性
     static synchronized int incrShared(){//不加synchronized的话，shared最终结果值小于预期
         return ++shared;
     }
     public static void testIncrShared(String[] args) throws InterruptedException {
         shared=0;
         Thread[] thrds = new Thread[20];
         for(int j=0;j<thrds.length;j++){
             thrds[j] = new Thread(new Runnable() {
                 @Override
                 public void run() {
                     for(int k=0;k<1000;k++){
                         System.out.println(incrShared());
                     }
                 }
             });
         }
         for(int j=0;j<thrds.length;j++){
             thrds[j].start();
         }
         for(int j=0;j<thrds.length;j++){
             thrds[j].join();
         }
         System.out.println(shared);
     }

2. volatile试验

     static /*volatile*/ int a0,a1;//这里加volatile的话，可以避免r0==r1==0的结果
     static /*volatile*/ int r0,r1;//这里即使加volatile，也无法避免r0==r1==0的结果
     public static void testVolatile(String[] args) throws InterruptedException {
         int[] a=new int[2];
         int[] r=new int[2];
         final int SLEEP=10;
         final Object lock=new Object();
         Runnable run1=new Runnable() {
             @Override
             public void run() {
                 try {
                     Thread.sleep(SLEEP);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 //synchronized (lock) {//加锁也可以建立happens-before关系，避免r0==r1==0的结果
                     a0=1;
                 //}
                 r1=a1;
             }
         };
         Runnable run2=new Runnable() {
             @Override
             public void run() {
                 try {
                     Thread.sleep(SLEEP);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 //synchronized (lock) {
                     a1=1;
                 //}
                 r0=a0;
             }
         };
         Thread thrd1;
         Thread thrd2;

         int i;
         int[][] acnt=new int[2][2];
         int[][] rcnt=new int[2][2];
         for(i=0;i<10000;i++){
             a0=a1=0;
             r0=r1=0;
             thrd1 = new Thread(run1);
             thrd2 = new Thread(run2);

             thrd1.start();
             thrd2.start();

             thrd1.join();
             thrd2.join();

             a[0]=a0;
             a[1]=a1;
             r[0]=r0;
             r[1]=r1;
             System.out.println(i);
             System.out.println(Arrays.toString(a));
             System.out.println(Arrays.toString(r));
             acnt[a[0]][a[1]]++;
             rcnt[r[0]][r[1]]++;
         }
         System.out.println(Arrays.deepToString(acnt));
         System.out.println(Arrays.deepToString(rcnt));
     }

3. volatile试验2

     static boolean shouldStop=false;
     public static void testVolatile2(String[] args) throws InterruptedException {
         shouldStop=false;
         Runnable run1=new Runnable() {
             @Override
             public void run() {
                 int i=0;
                 while (!shouldStop) {//无法读取到线程2修改后的shouldStop值，导致无限循环
                     i++;
                     //System.out.println(i);//如果调用其他函数的话，就又可以读取到shouldStop的最新值了
                 }
             }
         };
         Runnable run2=new Runnable() {
             @Override
             public void run() {
                 try {
                     Thread.sleep(10);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 shouldStop=true;
             }
         };
         Thread thrd1;
         Thread thrd2;

         int i;
         int[][] acnt=new int[2][2];
         int[][] rcnt=new int[2][2];
         for(i=0;i<100;i++){
             thrd1 = new Thread(run1);
             thrd2 = new Thread(run2);

             thrd1.start();
             thrd2.start();

             thrd2.join();
             System.out.println(i);
             System.out.println(shouldStop);
             thrd1.join();

         }
     }