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