【认识原子性】：

一个小程序认识原子性：

package T05_YuanZiXing;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class T00_00_IPlusPlus {
    private static long n = 0L;

    public static void main(String[] args) throws Exception {

        //Lock lock = new ReentrantLock();

        Thread[] threads = new Thread[100];
        CountDownLatch latch = new CountDownLatch(threads.length);

        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    n++;
                }
                latch.countDown();
            });
        }

        for (Thread t : threads) {
            t.start();
        }

        latch.await();

        System.out.println(n);

    }
}

【最终输出】：

//启动了100个线程，每个线程将数字加到1W ，最后应该是100W。
【问题所在】：

在这里插入图片描述
多个线程同时拿到了变量，同时++，然后同时写回去。

【一些概念】：
race condition => 竞争条件，指的是多个线程访问共享数据的时候产生竞争———上述程序中变量n即是共享数据。

数据的不一致（unconsistency)，并发访问之下产生的不期望出现的结果

如何保障数据一致呢？–> 线程同步（线程执行的顺序安排好），

monitor （管程） —> 锁

critical section -> 临界区

如果临界区执行时间长，语句多，叫做锁的粒度比较粗，反之，就是锁的粒度比较细。

【修改程序】：

        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    synchronized (T00_01_IPlusPlus.class) {
                        //lock.lock();
                        n++;
                        //lock.unlock();
                    }
                }
                latch.countDown();
            });
        }

【原子操作】：

原子操作的意思就是不能够中间被打断，只能作为一个整体，不能并发执行。

【什么样的语句是原子性的，什么样的语句不是原子性的呢？】：

不管是Java、C、C++、高级语言、低级语言最终一定都是要搞成机器语言的。机器语言翻译过来就是汇编语言。即便是汇编语言，它执行的任何一条指令都有可能被其他的线程所打断。
【得查汇编手册】：

CPU级别汇编，需要查询汇编手册！

Java中的8大原子操作：（了解即可，无需背过）

lock：主内存，标识变量为线程独占
unlock：主内存，解锁线程独占变量
read：主内存，读取内存到线程缓存（工作内存）
load：工作内存，read后的值放入线程本地变量副本
use：工作内存，传值给执行引擎
assign：工作内存，执行引擎结果赋值给线程本地变量
store：工作内存，存值到主内存给write备用
write：主内存，写变量值

【为何不用背呢？】：

//正常的情况下，你判断不了的情况下。这句话到底是否具备原子性呢？——你给它上锁就可以了。

【n++翻译成汇编指令】：

在这里插入图片描述

1——将static的值给拿过来；
2——扔到栈空间里面；
3——将这个值++；
4——将值放回去；
5——返回。

【用上锁保证原子性】：

synchronized (T00_01_IPlusPlus.class) {
      n++;
}

//大括号里面的所有操作都被当作了一个整体——不可打断。

【上锁的本质（一）】：

一句高级语言翻译成机器语言可能有好多句。需要保证这些操作不被打断。

【上锁的本质（二）】：

上锁的本质就是把并发编程序列化。
【程序解释】：

package T05_YuanZiXing;

import Utils.SleepHelper;

public class T00_01_WhatIsLock {
    private static Object o = new Object();
    
    public static void main(String[] args) {
        Runnable r = () -> {
                System.out.println(Thread.currentThread().getName() + " start!");
                SleepHelper.sleepSeconds(2);
                System.out.println(Thread.currentThread().getName() + " end!");
        };

        for (int i = 0; i < 3; i++) {
            new Thread(r).start();
        }
    }
}

【最终输出】：
在这里插入图片描述
//基本上是同时启动， 2秒之后同时结束。

【进行改进】：

package T05_YuanZiXing;

import Utils.SleepHelper;

public class T00_01_WhatIsLock_02 {
    private static Object o = new Object();


    public static void main(String[] args) {
        Runnable r = () -> {
            synchronized (o) {
                System.out.println(Thread.currentThread().getName() + " start!");
                SleepHelper.sleepSeconds(2);
                System.out.println(Thread.currentThread().getName() + " end!");
            }
        };

        for (int i = 0; i < 3; i++) {
            new Thread(r).start();
        }
    }
}

【最终输出】：
在这里插入图片描述
//红线处会等待2S ，一共执行完需要6S的时间。

【理解序列化】：

原先上厕所，三个人同时一起完成，现在要排队一个一个完成了。

【上锁的本质（三）】：

【程序演示】：

package T05_YuanZiXing;

import Utils.SleepHelper;

public class T00_02_SingleLockVSMultiLock {
    private static Object o1 = new Object();
    private static Object o2 = new Object();
    private static Object o3 = new Object();

    public static void main(String[] args) {
        Runnable r1 = () -> {
            synchronized (o1) {
                System.out.println(Thread.currentThread().getName() + " start!");
                SleepHelper.sleepSeconds(2);
                System.out.println(Thread.currentThread().getName() + " end!");
            }
        };

        Runnable r2 = () -> {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " start!");
                SleepHelper.sleepSeconds(2);
                System.out.println(Thread.currentThread().getName() + " end!");
            }
        };

        Runnable r3 = () -> {
            synchronized (o3) {
                System.out.println(Thread.currentThread().getName() + " start!");
                SleepHelper.sleepSeconds(2);
                System.out.println(Thread.currentThread().getName() + " end!");
            }
        };

        new Thread(r1).start();
        new Thread(r2).start();
        new Thread(r3).start();
    }
}