并发编程三大特性

并发编程三大特性:原子性，可见性，有序性

1.什么是原子性？

原子性是指在一个操作中，所有的子操作都是一个整体，要么同时全部执行，要么同时不执行，且在执行过程中，不能被挂起，直到执行完。可能这样解释很懵，那么看下面例子就全明白了。

int等不大于32位的基本类型的操作都是具有原子性，对于long和double变量，把它们作为2个原子性的32位值来对待，而不是一个原子性的64位值， 这样将一个long型的值保存到内存的时候，可能是2次32位的写操作， 2个竞争线程想写不同的值到内存的时候，可能导致内存中的值是不正确的结果。

nt i=1，这是原子操作;

double i=1 这不是一个，因为double是64位数据类型。

x=y也不是原子操作，因为执行这个操作需要三步，要先从内存中拿取y的值，然后对x值进行修改，然后把x的值写回内存中。

2.可见性

可见性就是指当一个线程修改了线程共享变量的值，其它线程能够立即得知这个修改。

讲可见性，就必须先了解JMM模型(java内存模型),在JMM中，主存中有A=2，子线程复制一份副本放在自己的工作内存中，如果要对A进行操作修改，那么要先修改自己工作内存的A，然后再将数据同步到主存中。

3.有序性 

指令重排是指在程序执行过程中,为了提高性能, 编译器和CPU可能会对指令进行重新排序，在单线程中这完全没问题，还能提高性能，而在多线程中却有很多问题，会出现重排后结果不一致问题。为了解决这一问题就会防止指令重排，采用内存屏障来确保指令不会被重排序，下面是内存屏障的原理，了解即可。 

 那么java是通过什么来预防三大特性所带来的问题的呢?

原子性

当我们执行以下操作时，创建10个线程，每个线程循环10000此次，每次循环对value+1，按照如此逻辑，打印结果应该时100000，而运行以下代码，每次结果都会不一样，因为他不能保证原子性，当线程1对value进行加1操作，还没回写主存中，时间片就轮转到线程2对value进行加1操作，但是线程2对数据进行了回写主存，那么此时主存的value的值为1，再次时间片轮转到线程1，而线程1就差数据回写没完成，那么执行回写操作，将value的值又改为了1，此时线程1修改的值被更新丢失(类似数据库的丢失更新)。

public class DefaultTest {
    private static int value = 0;

    public static void main(String[] args) throws InterruptedException {
        //创建10个线程
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
        //每个线程对value加10000
                for (int j = 0; j < 10000; j++) {
                    value++;
                }
            }).start();
        }
        Thread.sleep(2000);;
        System.out.println(value);
    }
}

java为了解决上面并发带来的问题引入了java.util.concurrent.atomic包，此包下的所有类都是线程安全的，保证了原子性。以下用AtomicInteger来替代int

public class AtomicIntegerTest {
    private static AtomicInteger value = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    value.addAndGet(1);
                }
            }).start();
        }
        Thread.sleep(2000);
        System.out.println(value);
    }
}

也可以用synchronized来保证原子性，可见性，有序性，这是重量级锁。对于不同情况采用不同应对方式，这里就不讲synchronized了。

可见性

当我们执行以下代码，创建两个线程，线程t1将线程t2的stop改为true，按照逻辑，此时线程t2应该会退出循环，然而并没有这样子。因为线程t1对线程t2的值进行修改后，线程t2时没有感知到，这就是数据不可见问题，那么java对这种问题，引入了volatile关键字。

public class u_volatile {
    public static void main(String[] args) throws InterruptedException {
        Task task = new Task();
        Thread t1 = new Thread(task, "线程t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    System.out.println("开始通知线程停止");
                    task.stop = true;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        t2.start();
        Thread.sleep(1000);
    }
}

class Task implements Runnable {
    boolean stop = false;
    //属性
    int i = 0;

    @Override
    public void run() {
        long s = System.currentTimeMillis();
        while (!stop) {
            i++;
        }
        System.out.println("线程退出" + (System.currentTimeMillis() - s));
    }
}

volatile关键字只能修改全局变量，对属性stop加入volatile修饰，就能保住可见性了

public class u_volatile {
    public static void main(String[] args) throws InterruptedException {
        Task task = new Task();
        Thread t1 = new Thread(task, "线程t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    System.out.println("开始通知线程停止");
                    task.stop = true;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        t2.start();
        Thread.sleep(1000);
    }
}

class Task implements Runnable {
    volatile boolean stop = false;
    //属性
    int i = 0;

    @Override
    public void run() {
        long s = System.currentTimeMillis();
        while (!stop) {
            i++;
        }
        System.out.println("线程退出" + (System.currentTimeMillis() - s));
    }
}

总结 

在java中通过atomic来保证原子性；volatile保证可见性、禁止指令重排，但是不保证原子性；synchronized保证了有序，可见，原子性，volatile不会造成线程阻塞，synchronized可能会造成线程的阻塞，所以后面才有锁优化和无锁编程。