保证java运行线程安全机制

如何保证线程安全：
1.如果可以设计出不需要共享的数据，天生安全
2.如果非要进行数据的共享，尽可能的保证数据只读性——不可变对象
3.利用各种机制保证以上的三点：原子性，可见性，重排序。

主要方法有两种：
sychronized方法：
执行synchronized修饰的普通方法时，首先需要lock引用指向的对象中的锁
1.如果可以缩，就正常执行代码
2.否则，需要等其他线程把锁unlock

方法执行结束时，unlock这把锁。
即便不是同一个方法，但是只要指向同一个对象，争抢的就是同一把锁。
静态方法锁的是类。
代码块锁的是代码块（括号里的引用指向的对象）。

1.方法的修饰符 2.修饰代码块

保证原子性

保证可见性：
在加锁和释放锁的时机上，会刷新每个线程的工作内存，达到可加性、
保证重排序的正确性：
锁之前的语句无法重排序到临界区（锁的代码部分）
临界区内部的无法重排序到外头

稍轻量级 volatile关键字

语法：修饰变量
1.保证变量的可见性问题
2.可以部分保证代码的重排序问题。

基本数据类型：
boolean byte short int char float 字面量 原子
变量 不是原子
long double 任何情况都不是原子

展示四种方法使得三个线程能够按照顺序执行（也就是在内部方法打印1 2 3）

public class OneTwoThree2 {
    private static class Foo {
        private volatile int n = 0;

        // 虽然 n 不为 0，但不让出 CPU，导致 n 无法及时变化
        public void oneVersion1() {
            synchronized (this) {
                if (n != 0) {
                    return;
                }

                System.out.println("one");
                n = 1;
            }
        }

        // 减少了锁的开销
        public void oneVersion2() {
            if (n != 0) {
                return;
            }

            System.out.println("one");
            n = 1;
        }

        // 条件不满足时及时释放 CPU，但是还参与 CPU 的争夺
        public void oneVersion3() {
            if (n != 0) {
                Thread.yield();
                return;
            }

            System.out.println("one");
            n = 1;
        }

        // 条件不满足，让出 CPU，并且不再参加 CPU 的争夺
        public void oneVersion4() throws InterruptedException {
            if (n != 0) {
                synchronized (this) {
                    wait();
                }
                return;
            }

            // 两句话的次序不能颠倒
            System.out.println("one");
            n = 1;
            synchronized (this) {
                notifyAll();
            }
        }

        public void one() throws InterruptedException {
            if (n != 0) {
                // Thread.yield(); 通过调用 yield 释放 CPU
                // 可以适当增加性能
                synchronized (this) {
                    wait();
                }
                return;
            }

            // 两句话的次序不能颠倒
            System.out.println("one");
            n = 1;
            synchronized (this) {
                notifyAll();
            }
        }

        public void two() throws InterruptedException {
            if (n != 1) {
                synchronized (this) {
                    wait();
                }
                return;
            }

            System.out.println("two");
            n = 2;
            synchronized (this) {
                notifyAll();
            }
        }

        public void three() throws InterruptedException {
            if (n != 2) {
                synchronized (this) {
                    wait();
                }
                return;
            }

            System.out.println("three");
            n = 0;
            synchronized (this) {
                notifyAll();
            }
        }
    }

    private static Foo foo = new Foo();

    private static class OneThread extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    foo.one();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static class TwoThread extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    foo.two();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static class ThreeThread extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    foo.three();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        Thread one = new OneThread();
        Thread two = new TwoThread();
        Thread three = new ThreeThread();
        one.start();
        two.start();
        three.start();
    }
}