[并发编程的艺术] 02-Java并发机制的底层实现原理

public class Test3 implements Runnable{
    private static volatile boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            System.out.println(Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Test3());
        thread.start();

        TimeUnit.SECONDS.sleep(1);
        flag = false;
    }
}

public class LazySingleton {
    // private static LazySingleton lazySingleton = null;
    private static volatile LazySingleton lazySingleton = null;

    private LazySingleton(){}

    public static LazySingleton getInstance(){
        /////////////////最简单的写法/////////////////
        // // 实例为空就实例化
        // if (null == lazySingleton) {
        //     lazySingleton = new LazySingleton();
        // }
        //
        // // 否则直接返回
        // return lazySingleton;
        /////////////////最简单的写法/////////////////

        // 这样去实例化，结果也不是预期的，因为第一个线程进入代码块进行实例化之后，退出代码块，随之切换到了其它线程，其它线程进入代码块
        // 也会进行实例化
        // if (null == lazySingleton) {
        //     try {
        //         TimeUnit.SECONDS.sleep(1);
        //     } catch (InterruptedException e) {
        //         e.printStackTrace();
        //     }
        //
        //     synchronized (LazySingleton.class) {
        //         lazySingleton = new LazySingleton();
        //     }
        // }

        // 使用双重检查保证单例的线程安全（此时也不是绝对的线程安全(指令重排序会导致不安全)，
        // 要达到线程安全，还要给lazySingleton加上volatile关键字，禁止指令重排序 ）
        //
        // 第一个线程实例化后，离开代码块，此时即使第二个线程进入代码块，经过判断会发现实例已经存在了，所以第二个线程不会去实例化对象了
        if (null == lazySingleton) {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (LazySingleton.class) {
                if (null == lazySingleton) {
                    lazySingleton = new LazySingleton();
                }
            }
        }
        return lazySingleton;
    }
}

/**
 * 测试懒汉式单例是否线程安全
 * 如果按照最简单的写法，拿到的对象并不是相同的。
 * 解决方法1：给getInstance方法加上synchronized，但是这样会导致其它线程等待，消耗性能。
 * 解决方法2：同步代码块
 */
@Test
public void f2() throws InterruptedException {
    for (int i = 0; i < 100; i++) {
        new Thread(() -> {
            System.out.println(LazySingleton.getInstance());
        }).start();
    }

    TimeUnit.SECONDS.sleep(2);
}

/**
 * 深入理解synchronized关键字
 *  保证原子性和可见性操作
 *  内置锁
 *      每个java对象都可以用作一个实现同步的锁，这些锁称为内置锁，线程进入同步代码块或方法块时会自动获得该锁，在退出代码块/方法块时会释放该锁
 *      获得内置锁的唯一途径就是进入这个锁保护的同步代码块/方法
 *  互斥锁
 *      内置锁是一个互斥锁，意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，直到线程B释放这个
 *      锁，如果B线程不释放这个锁，那么A线程将永远等待下去。
 *
 *  可修饰哪些地方
 *      1、可修饰实例方法、静态方法
 *          实例方法：锁住对象的实例 f1 两个不同对象都锁3秒，结果是几乎同时运行结束，说明锁的是各自的对象实例
 *          静态方法：锁住整个类 f2 两个对象调用m2不会同时结束，第一个线程结束3miao后第二个线程结束，说明整个类被锁类
 *              实际编程中尽量少用synchronized修饰静态方法，因为它会导致整个类被锁，所有线程串行执行
 *      2、可修饰代码块
 *          锁住括号中的对象 m3中锁的就是lock对象，因此f3中也是串行的效果, f4是并行效果
 *
 * @Auther: houwentao@g7.com.cn
 * @Date: 2019-03-01 21:18
 */
public class Test2 {
    private Object lock = new Object();
    public void m3(){
        synchronized (lock) {
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // 修饰静态方法
    public synchronized static void m2(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName());
    }

    // 修饰实例方法
    public synchronized void m1() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName());
    }

    @Test
    public void f4() throws InterruptedException {
        Test2 class1 = new Test2();
        Test2 class2 = new Test2();

        Thread thread = new Thread(() -> {
            class1.m3();
        });

        Thread thread1 = new Thread(() -> {
            class2.m3();
        });
        thread.start();
        thread1.start();

        thread.join();
        thread1.join();
    }

    @Test
    public void f3() throws InterruptedException {
        Test2 class1 = new Test2();

        Thread thread = new Thread(() -> {
            class1.m3();
        });

        Thread thread1 = new Thread(() -> {
            class1.m3();
        });
        thread.start();
        thread1.start();

        thread.join();
        thread1.join();
    }

    @Test
    public void f2() throws InterruptedException {
        Test2 class1 = new Test2();
        Test2 class2 = new Test2();

        Thread thread = new Thread(() -> {
            class1.m2();
        });

        Thread thread1 = new Thread(() -> {
            class2.m2();
        });
        thread.start();
        thread1.start();

        thread.join();
        thread1.join();
    }

    @Test
    public void f1() throws InterruptedException {
        Test2 class1 = new Test2();
        Test2 class2 = new Test2();

        Thread thread1 = new Thread(() -> {
            class1.m1();
        });

        Thread thread2 = new Thread(() -> {
            class2.m1();
        });

        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
    }
}

public class Counter {
    private AtomicInteger atomicInteger = new AtomicInteger();
    private int i = 0;

    public static void main(String[] args) {
        final Counter cas = new Counter();
        List<Thread> ts = new ArrayList<>(600);
        long start = System.currentTimeMillis();
        for (int j = 0; j < 100; j++) {
            Thread t = new Thread(() -> {
                for (int i = 0; i < 10000; i++) {
                    cas.count();
                    cas.safeCount();
                }
            });
            ts.add(t);
        }

        for (Thread t : ts) {
            t.start();
        }
        for (Thread t : ts) {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(cas.i);
        System.out.println(cas.atomicInteger.get());
        System.out.println(System.currentTimeMillis() - start);
    }

    // 使用cas实现线程安全的计数器
    private void safeCount(){
        for (; ; ) {
            int i = atomicInteger.get();
            boolean suc = atomicInteger.compareAndSet(i, ++i);
            if (suc)
                break;
        }
    }

    // 非线程安全计数器
    private void count(){
        i++;
    }
}

public boolean compareAndSet(
    V   expectedReference,    //预期引用
    V   newReference,         //更新后的引用
    int expectedStamp,     //预期标志
    int newStamp         //更新后的标志
)