JUC--volatiley&CAS

public class VolatileTest {

    public static void main(String[] args) {

        ThreadDemo td = new ThreadDemo();

        new Thread(td).start();

        while(true){

            if(td.getFlag()){

                System.out.println("========");

                break;

            }

        }

    }

}

class ThreadDemo implements Runnable{

   private boolean flag=false;

    @Override

    public void run() {

        try {

            Thread.sleep(200);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        flag=true;

        System.out.println("flag="+getFlag());

    }

    public boolean getFlag(){

        return flag;

    }

}

flag是main thread和td共享的数据，他们都在各自的线程内有一个copy，由于while true的速度十分快，main thread不能读取到td修改后的值，所以只能输出 flag=true。

内存不可见性：当多个thread操作共享数据时，彼此不可见

volatile:当多个thread操作共享数据时，保证数据是可见的，内存栅栏　　可以理解为多个线程直接操作主存中的数据

因为使用vloatile 不能指令重排所以效率低

volatile相比synchronized：

　　是一种较为轻量级的同步策略，volatile不具备互斥性，两个线程可以同时访问共享数据，volatile不能保证变量的原子性，

原子性问题：i++

以下情况使用volatile不能解决非原子性问题：内存可见性问题依然存在

public class AtomicTest {

    public static void main(String[] args) {

        AtomicDemo ad = new AtomicDemo();

        for(int i=0;i<10;i++){

            new Thread(ad).start();

        }

    }

}

class AtomicDemo implements Runnable{

    private int serialNum=0;

    @Override

    public void run() {

        try {

            Thread.sleep(200);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        System.out.println(Thread.currentThread().getName()+":"+getSerialNum());

    }

    public int getSerialNum(){

        return serialNum++;

    }

}

二、使用源自变量 java.util.concurrent.atomic 原子变量包

　　1.使用volatile保证内存可见性

　　2.使用CAS compare and swap算法保证数据的原子性

　　　　CAS是硬件对于并发操作共享数据的支持　　

　　　　CAS包含三个操作数：

　　　　　　内存值V 预估值A 更新值B

（1）首先读取内存之V 在替换的时候读取旧值A

AtomicInteger:保证线程安全内存可见性原子性问题

private AtomicInteger serialNum=new AtomicInteger();

    @Override

    public void run() {

        try {

            Thread.sleep(200);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        System.out.println(Thread.currentThread().getName()+":"+getSerialNum());

    }

    public int getSerialNum(){

        return serialNum.getAndIncrement();

    }

CAS算法的模拟：

public class TestCAS {

    public static void main(String[] args) {

        final CompareAndSwap cas = new CompareAndSwap();

        for(int i=0;i<10;i++){

            new Thread(new Runnable() {

                @Override

                public void run() {

                    int expectVal = cas.get();

                    boolean b= cas.compareAndSwap(expectVal,(int)(Math.random()*101));

                }

            }).start();

        }

    }

}

class CompareAndSwap {

    private int value;

    public synchronized int get() {

        return value;

    }

    public synchronized int cas(int expectVal, int newVal) {

        int oldVal = value;

        if (oldVal == expectVal)

            this.value = newVal;

        return oldVal;

    }

    public synchronized boolean compareAndSwap(int expectVal, int newVal) {

        return  expectVal==cas(expectVal,newVal);

    }

}

巴特西

JUC--volatiley&CAS

最新文章

热门文章