JUC并发编程深入学习Java并发编程【上】

JUC并发编程，深入学习Java并发编程，与视频每一P对应，全系列6w+字。

P1-5 为什么学+特色+预备知识进程线程概念

进程：

一个程序被运行，从磁盘加载这个程序的代码到内存，就开起了一个进程。

进程可以视为程序的一个实例，大部分程序可以同时运行多个实例进程（笔记本，记事本，图画，浏览器等），也有的程序只能启动一个实例进程（网易云音乐，360安全卫士等）。

线程：

一个进程内可以分为一到多个线程。

一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给CPU执行。

Java中线程是最小调度单元，进程作为资源分配的最小单位。在windows中进程是不活动的，知识作为线程的容器。

对比：

进程拥有共享的资源，如内存空间等，供其内部线程共享。

进程间通信较为复杂：同一台计算机的进程通信称为IPC。不同计算机之间的进程通信，需要通过网络，遵守共同的协议。

线程通信简单，因为共享进程内的内存，多个线程可以访问同一个共享变量。

线程更轻量，上下文切换成本要比进程上下文切换低。

给项目引入如下pom依赖：

<properties>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.10</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
    </dependency>
</dependencies>

logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration
 xmlns="http://ch.qos.logback/xml/ns/logback"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://ch.qos.logback/xml/ns/logback logback.xsd">
 <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
 <encoder>
 <pattern>%date{HH:mm:ss} [%t] %logger - %m%n</pattern>
 </encoder>
 </appender>
 <logger name="c" level="debug" additivity="false">
 <appender-ref ref="STDOUT"/>
 </logger>
 <root level="ERROR">
 <appender-ref ref="STDOUT"/>
 </root>
</configuration>

P6 并发并行概念

操作系统任务调度器，可以把CPU时间交给不同线程使用，线程可以轮流使用CPU资源。

假如CPU为单核，同一时间段应对多件事情叫并发。同一时间段处理多件事情的能力。一个人做多件事。

假如CPU为多核，多个核心同时执行任务，叫作并行。同一时间同时做多件事情的能力。多个人做多件事。

P7 线程应用异步调用

同步：需要等待结果返回，才能继续运行。

异步：不需要等待结果返回，就能继续运行。

多线程可以让方法执行变为异步的，不会干巴巴等着，比如读取磁盘要花费5秒，如果没有线程调度机制，这5秒什么事情都做不了。

视频文件要转换格式操作比较费时，可以开一个新线程处理视频转换，避免阻塞主线程。

P8 线程应用提升效率

P9 P10 线程应用提升效率验证和小结

单核多线程比单核单线程的速度慢。

多核多线程比多核单线程快。

P11 创建线程方法1

源代码是在如下位置：

一开始默认有一个主线程在运行。

@Slf4j(topic = "c.Test1")
public class Test1 {

    public static void main(String[] args){
        Thread t = new Thread(){
            @Override
            public void run(){
                log.debug("running");
            }
        };
        t.setName("t1");
        t.start();
        log.debug("running");
    }
}

P12 创建线程方法2

使用Runnable配合Thread创建线程：

@Slf4j(topic="c.Test2")
public class test2 {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                log.debug("running");
            }
        };
        Thread t = new Thread(r,"t2");
        t.start();
    }
}

将任务和线程分离：

P13 创建线程lambda简化

@Slf4j(topic="c.Test2")
public class test2 {
    public static void main(String[] args) {
        Runnable r =()->{
                log.debug("running");
        };
        Thread t = new Thread(r,"t2");
        t.start();
    }
}

超级简化版：

@Slf4j(topic="c.Test2")
public class test2 {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            log.debug("running");
        },"t2");
        t.start();
    }
}

P14 创建线程方法1,2-原理

P15 创建线程方法3

FutureTask配合Thread，FutureTask能够接收Callable类型的参数，用来处理有返回结果的情况。

@Slf4j(topic="c.Test2")
public class Test3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> task = new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                log.debug("running...");
                Thread.sleep(2000);
                return 100;
            }
        });
        Thread t1 = new Thread(task,"t1");
        t1.start();
        log.debug("{}",task.get());//阻塞住，等待线程，直到线程返回结果
    }
}

P16 线程运行现象

交替运行。

P17 线程运行windows查看和杀死

查看方式：1.通过任务管理器。2.在控制台输入tasklist

找到java进程：

tasklist | findstr java

查看所有java进程：

jps

杀死某个进程：

taskkill /F /PID PID号

P18 线程运行linux查看和杀死

列出所有正在执行的进程信息：

ps -fe

用grep关键字进行筛选：

ps -fe | grep 关键字

查看java进程页可以用Jps。

杀死某个进程：

kill PID号

查看进程内的线程信息：

top -H -p PID号

P19 线程运行jconsole

输入win+r，键入jconsole，可以打开图形化界面。

可以远程连接到服务器监控信息。

P20 线程运行原理栈帧debug

JVM由堆、栈、方法区组成。栈内存是给线程用的，每个线程启动后，虚拟机会为其分配一块栈内存。

栈由栈帧组成，对应每次方法调用时所占用的内存。

每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法。

P21 线程运行原理栈帧图解

返回地址对应的是方法区中的方法，局部变量对应的是堆中的对象。

P22 线程运行原理多线程

P23 线程运行原理上下文切换

CPU不再执行当前的线程，转而执行另一个线程的代码：

1.线程的CPU时间片用完。

2.垃圾回收。暂停当前所有的工作线程，让垃圾回收的线程去回收垃圾。

3.有更高优先级的线程需要运行。

4.线程自己调用了sleep，yield，wait，join，park，synchronized，lock等方法。

当Context Switch发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java中对应概念是程序计数器，作用是记住下一条jvm指令的执行地址，是线程私有的。

状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址。

P24 常见方法概述

start() 启动一个新线程，在新的线程运行run方法中的代码。start方法只能让线程进入就绪，代码不一定立即执行（只有等CPU的时间片分配给它才能运行）。每个线程对象的start方法只能调用一次。

join()等待线程运行结束。假如当前的主线程正在等待某个线程执行结束后返回的结果，就可以调用这个join方法。join(long n)表示最多等待n毫秒。

getId()获得线程id，getName()获得线程名称，setName()设置线程名称，getPriority()获得优先级，setPriority(int)设置线程优先级，getStatus()获取线程状态，isInterupted()判断是否被打断，isAlive()判断线程是否存活，interrupt()打断线程，interrupted()判断当前线程是否被打断。

currentThread()获取当前正在执行的线程，sleep(long n)让当前执行的线程休眠n毫秒，休眠时让出其cpu的时间片给其它线程。

yield()提示线程调度器让出当前线程对CPU的使用。

P25 常见方法start vs run

用run时是主线程来执行run方法。无法做到异步。

@Slf4j(topic="c.Test4")
public class Test4 {
    public static void main(String[] args) {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug("running...");
            }
        };
        t1.run();
    }
}

下面是使用start方法启动，可以异步执行任务。

@Slf4j(topic="c.Test4")
public class Test4 {
    public static void main(String[] args) {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug("running...");
            }
        };
        System.out.println(t1.getState());
        t1.start();
        System.out.println(t1.getState());
    }
}

在new之后start之前是NEW状态，在start之后是RUNNABLE状态。

P26 常见方法sleep状态

sleep让线程从running状态变成time waiting状态，从运行状态变到有时限（因为会传递一个参数）的等待状态。

P27 常见方法sleep打断

正在睡眠的线程可以由其它线程用interrupt方法打断唤醒。此时睡眠的方法会抛出InterruptException。

程序思路，t1.start执行完，输出begin，然后休眠，执行t1的run方法输出enter slee...，然后休眠，1秒到后输出interrupt，最终t1.interrupt方法被调用，休眠线程立刻被打断，开始执行wake up....

@Slf4j(topic="c.Test7")
public class Test6 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1") {
            public void run() {
                log.debug("enter sleep....");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    log.debug("wake up...");
                    throw new RuntimeException(e);
                }
            }
        };
        t1.start();
        log.debug("begin");
        Thread.sleep(1000);
        log.debug("interrupt");
        t1.interrupt();
    }
}

P28 常见方法sleep可读性

建议用TimeUnit的sleep代替Thread的sleep来获得更好的可读性。

@Slf4j(topic = "c.Test8")
public class Test7 {
    public static void main(String[] args) throws InterruptedException {
        log.debug("enter");
        TimeUnit.SECONDS.sleep(1);
        log.debug("end");
    }
}

P29 常见方法yield_vs_sleep

1.yield

某个线程调用yield，可以让出CPU的使用权。

调用yield会让当前线程从Running进入Runnable就绪状态，然后调度执行其它线程。

2.sleep

调用sleep会让当前线程从Running进入Timed Waitring状态（阻塞）

P30 常见方法线程优先级

线程优先级会提示（hint）调度器优先调度该线程，但它仅仅只是一个提示，调度器可以忽略它。

如果cpu较忙，优先级高的线程会获得更多的时间片，但cpu如果闲时，优先级几乎没作用。

@Slf4j(topic="c.Test4")
public class test4 {
    public static void main(String[] args) {
        Runnable task1 =()->{
            int count=0;
            for(;;){
                System.out.println("------>1"+count++);
            }
        };
        Runnable task2 =()->{
            int count=0;
           for(;;){
               //Thread.yield();
                System.out.println("          ------>2"+count++);
            }
        };
        Thread t1 = new Thread(task1,"t1");
        Thread t2 = new Thread(task2,"t2");
        //t1.setPriority(Thread.MIN_PRIORITY);
        //t2.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
    }
}

P31 常见方法sleep应用

在没有利用cpu来计算时，不要让while(true)空转浪费cpu，这时可以使用yield或sleep来让出cpu的使用权给其它程序。

可以用wait或者条件变量达到类似的效果。但需要加锁，并且需要设置相应的唤醒操作，一般适用于要进行同步的场景。sleep适合无锁同步的场景。

P32 常见方法join

join等待某个线程执行结束。

下面这个例子因为t1线程睡了1秒，对r的更改不会发生，主线程会直接输出r的结果r=0。此时若想让r=10，则需要在t1.start()的下面加上t1.join()表示等待t1执行结束返回结果，主线程再执行。

@Slf4j(topic="c.Test5")
public class test5 {
    static int r=0;

    public static void main(String[] args) throws InterruptedException{
        test1();
    }

    public static void test1() throws InterruptedException{
        log.debug("开始");
        Thread t1 = new Thread(()->{
           log.debug("开始");
           sleep(1);
           log.debug("结束");
           r=10;
        },"t1");
        t1.start();
        t1.join();
        log.debug("结果为:{}",r);
        log.debug("结果");
    }
}

P33 常见方法join同步应用

需要等待结果返回，才能继续运行是同步。

不需要等待结果返回，就能继续运行是异步。

@Slf4j(topic = "c.TestJoin")
public class TestJoin {
    static int r = 0;
    static int r1 = 0;
    static int r2 = 0;

    public static void main(String[] args) throws InterruptedException {
        test2();
    }
    private static void test2() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            sleep(1);
            r1 = 10;
        });
        Thread t2 = new Thread(() -> {
            sleep(2);
            r2 = 20;
        });
        t1.start();
        t2.start();
        long start = System.currentTimeMillis();
        log.debug("join begin");
        t1.join();
        log.debug("t1 join end");
        t2.join();
        log.debug("t2 join end");
        long end = System.currentTimeMillis();
        log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
    }
}

P34 常见方法join限时同步

下面给t1.join()设置了1500毫秒等待时间，因为小于线程睡眠时间，所以没法能线程苏醒改变r,输出结果为r1=0。

@Slf4j(topic = "c.TestJoin")
public class TestJoin {
    static int r = 0;
    static int r1 = 0;
    static int r2 = 0;

    public static void main(String[] args) throws InterruptedException {
        test3();
    }
    public static void test3() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            sleep(2);
            r1 = 10;
        });
        long start = System.currentTimeMillis();
        t1.start();
        // 线程执行结束会导致 join 结束
        log.debug("join begin");
        t1.join(1500);
        long end = System.currentTimeMillis();
        log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
    }
}

P35 常见方法interrupt打断阻塞

如果线程是在睡眠中被打断会以报错的形式出现，打断标记为false。

@Slf4j(topic="c.Test6")
public class test6 {
    public static void main(String[] args) throws InterruptedException{
        Thread t1 = new Thread(() -> {
            log.debug("sleep...");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }, "t1");
        t1.start();
        Thread.sleep(1000);
        log.debug("interrupt");
        t1.interrupt();
        log.debug("打断标记:{}",t1.isInterrupted());
    }
}

P36 常见方法interrupt打断正常

如果在main方法中调用t1的interrupt方法，t1线程只是会被告知有线程想打断，不会强制被退出。此时isinterrupted状态会被设为true，此时可以利用该状态来让线程决定是否退出。

@Slf4j(topic="c.Test7")
public class Test7 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            while(true){
                boolean interrupted = Thread.currentThread().isInterrupted();
                if(interrupted){
                    log.debug("被打断了，退出循环");
                    break;
                }
            }
        },"t1");
        t1.start();
        Thread.sleep(1000);
        log.debug("interrupt");
        t1.interrupt();
    }
}

P37 设计模式两阶段终止interrupt

在一个线程T1中如何优雅的终止线程T2，这里的优雅指的是给T2一个料理后事的机会。

错误思路：

1.使用线程对象的stop方法停止线程。stop方法会真正杀死线程，如果线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁，其它线程将永远无法获取锁。

2.使用System.exit(int)方法会直接把方法停止，直接把进程停止。

P38 设计模式两阶段终止interrupt分析

在工作中被打断，打断标记是false，会进入到料理后事。

在睡眠是被打断，会抛出异常，此时打断标记是true，此时可以重新设置打断标记为false。

P39 设计模式两阶段终止interrupt实现

@Slf4j(topic = "c.TwoPhaseTermination")
class TwoPhaseTermination{
    private Thread monitor;
    public void start(){
        monitor = new Thread(()->{
            while(true) {
                Thread current = Thread.currentThread();
                if (current.isInterrupted()) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("执行监控记录");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //重新设置打断标记
                    current.interrupt();
                }
            }
        });
        monitor.start();
    }
    public void stop(){
        monitor.interrupt();
    }
}

P40 设计模式两阶段终止interrupt细节

P41 常见方法interrupt打断park

@Slf4j(topic="c.Test9")
public class java9 {
    public static void main(String[] args) throws InterruptedException{
        test1();
    }
    public static void test1() throws InterruptedException{
        Thread t1 = new Thread(()->{
            log.debug("park...");
            LockSupport.park();
            log.debug("unpark...");
            log.debug("打断状态:{}",Thread.interrupted());
            LockSupport.park();
            log.debug("unpark...");
        },"t1");
        t1.start();
        sleep(1);
        t1.interrupt();
    }
}

P42 常见方法过时方法

切忌用stop，suspend方法。

P43 常见方法守护线程

默认情况下，Java进程需要等待所有的线程都运行结束，才会结束。

有一种特殊的线程叫守护线程，只要其它非守护线程执行结束了，即时守护线程的代码没有执行完，也会强制结束。

在t1启动前调用setDaemon方法开启守护线程，如果主线程运行结束，守护线程也会结束。

@Slf4j(topic="c.Test15")
public class Test10 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
           while(true){
               if(Thread.currentThread().isInterrupted()){
                   break;
               }
           }
        });
        t1.setDaemon(true);
        t1.start();
        Thread.sleep(1000);
        log.debug("结束");
    }
}

垃圾回收器线程是一种守护线程。如果程序停止，垃圾回收线程也会被强制停止。

P44 线程状态五种

初始状态：在语言层面上创建线程对象，还没与操作系统中的线程关联，仅停留在对象层面。比如new了一个Thread对象，但没调用start方法。

可运行状态：就绪状态，线程已经被创建，与操作系统线程关联，可以由CPU调度器调度执行，可以获得CPU时间片，但暂时没获得时间片。

运行状态：指获取了CPU时间片，运行中的状态。

阻塞状态：调用了阻塞API，比如BIO读写文件，线程不会用到CPU，会导致上下文切换，进入阻塞状态。等BIO操作完毕，会由操作系统唤醒阻塞的线程，转换至可运行状态。

终止状态：线程已经执行完毕，生命周期结束，不会再转换为其它状态。

P45 线程状态六种

从Java的层面进行描述：

NEW：指被创建，还没调用Start方法。

RUNNABLE：涵盖了操作系统层面的可运行、运行、阻塞状态。

TERMINATED：指被终止状态，不会再转化为其它状态。

3种阻塞的状态：

BLOCKED（想获得锁，但获得不了，拿不到锁会陷入block状态）

WAITING（这个是join等待时的状态）

TIMED_WAITING（这个是sleep时的状态，有时限的等待）

P46 线程状态六种演示

P47 习题应用之统筹分析

P48 习题应用之统筹实现

@Slf4j(topic = "c.Test16")
public class Test11 {
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            log.debug("洗水壶");
            Sleeper.sleep(1);
            log.debug("烧开水");
            Sleeper.sleep(5);
        },"老王");
        Thread t2 = new Thread(()->{
            log.debug("洗茶壶");
            Sleeper.sleep(1);
            log.debug("洗茶杯");
            Sleeper.sleep(2);
            log.debug("拿茶叶");
            Sleeper.sleep(1);
            try {
                t1.join();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("泡茶");
        },"小王");
        t1.start();
        t2.start();
    }
}

缺点：上面模拟的是小王等老王的水烧开了，小王泡茶，如果反过来要实现老王等小王的茶叶拿过来，老王泡茶呢？代码最好能适应2种情况。

上面的两个线程各执行各的，如果要模拟老王把水壶交给小王泡茶，或模拟小王把茶叶交给老王泡茶呢？

P49 第三章小节

P50 本章内容

P51 小故事线程安全问题

多线程下访问共享资源，因为分时系统导致的数据不一致等安全问题。

P52 上下文切换分析

@Slf4j(topic="c.Test12")
public class Test12 {
    static int counter = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                counter++;
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                counter--;
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}", counter);
    }
}

结果并不唯一如下：

i++和i--编译成字节码不是一条代码：

造成数据不一致的原因是：

某个线程的事情还没干完，数据还没来得及写入，上下文就切换了。根本原因：上下文切换导致指令交错。

P53 临界区与竞态条件

问题出现在多个线程访问共享资源。

在多个线程对共享资源读写操作时发生指令交错，出现问题。

一段代码内如果存在对共享资源的多线程读写操作，称这段代码为临界区。

竞态条件：多个

P54 上下文切换synchronized解决

为了避免临界区的竞态条件发生，有多种手段可以达到目的。

1.阻塞式的解决方案：synchronized，Lock。

2.非阻塞式的解决方案：原子变量。

本次课使用的是synchronized来解决问题，即对象锁，它采用互斥的方式来让同一时刻至多只能有1个线程持有对象锁，其它线程想获取对象锁会被阻塞。这样保证拥有锁的线程可以安全的执行临界区内的代码，不用担心上下文切换。

synchronized(对象){
    临界区
}

@Slf4j(topic="c.Test12")
public class Test12 {
    static int counter = 0;
    static Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (lock){
                    counter++;
                }
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (lock){
                    counter--;
                }
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}", counter);
    }
}

P55 上下文切换synchronized理解

假如t1通过synchronized拿到锁以后，但是时间片不幸用完了，但这个锁仍旧是t1的，只有时间片下次重新轮到t1时才能继续执行。

只有当t1执行完synchronized()块内的代码，会释放锁。其它线程才能竞争。

P56 上下文切换synchronized理解

当锁被占用时，就算指令没执行完上下文切换，其它线程也获取不到锁，只有当拥有锁的线程的所有代码执行完才能释放锁。

P57 上下文切换synchronized思考

1.把加锁提到for循环外，相当于5000次for循环都视为一个原子操作。

2.如果线程1加锁，线程2没加锁会导致的情况：线程2去访问临界资源时，不会尝试获取对象锁，因此不会被阻塞住，仍然能继续访问。

P58 锁对象面向对象改进

@Slf4j(topic="c.Test12")
public class Test12 {
    public static void main(String[] args) throws InterruptedException {
        Room room = new Room();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (room){
                    room.increment();
                }
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (room){
                    room.decrement();
                }
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}", room.getCounter());
    }
}

class Room{
    private int counter = 0;
    public void increment(){
        synchronized (this){
            counter++;
        }
    }
    public void decrement(){
        synchronized (this){
            counter--;
        }
    }
    public int getCounter(){
        synchronized (this){
            return counter;
        }
    }
}

P59 synchronized 加在方法上

synchronized可以加在方法上，相当于锁住方法。

synchronized加在静态方法上，相当于所住类。

P60 P61 P62上下文切换synchronized习题1~8

线程1锁的是类，线程2锁的是方法。

下面一个锁类一个锁方法，锁的仍然是不同对象，所以会并行执行。

锁的是同一个Number对象，锁的是静态方法，所以锁的是类。

P63 线程安全分析

P64 线程安全分析局部变量

局部变量的i++只有一行字节码，不同于静态变量的i++。

P65 线程安全分析局部变量引用

创建2个线程，然后每个线程去调用method1:

如果method1还没把数据放入，method2就要取出数据，此时集合为空，会报错。

将list改为局部变量后，放到方法内：

list是局部变量，每个线程会创建不同实例，没有共享。

method2和method3的参数从method1中传递过啦，与method1中引用同一个对象。

P66 线程安全分析局部变量暴露引用

因为下面ThreadSafeSubClass继承了ThreadSafe类，然后重写了method3方法，导致出现了问题。

必须要改为private和final防止子类去重写和修改，满足开闭原则，不让子类改变父类的行为。

P67 线程安全分析局部变量组合调用

常见线程安全的类：

String、Integer、StringBuffer、Random、Vector、Hashtable、java.util.concurrent包下的类

注意：每个方法是原子的，单多个方法的组合不是原子的。

下面Hashtable的get和put单个方法是线程安全的，但二者组合在一起仍然会受到线程上下文的切换的影响。

P68 线程安全分析常见类不可变

String、Integer等都是不可变类，即时被线程共享，因为其内部的状态不可以改变，因此它们的方法是线程安全的。

String的replace和substring等方法看似可以改变值，实则是创建了一个新的字符串对象，里面包含了截取后的结果。

P69 线程安全分析实例分析1~3

线程不安全：Map<String,Object> map = new HashMap<>();

线程不安全：Date

下面这段非线程安全：

Spring里某一个对象没有加Scope都是单例的，只有1份，成员变量需要被共享。

P70 线程安全分析实例分析4~7

下面这个方法是线程安全，因为没有成员变量，也就是类下没有定义变量。变量在方法内部，各自都在线程的栈内存中，因此是线程安全的。

下面是线程安全的，因为UserDaoImpl里面没有可以更改的成员变量（无状态）。

下面是线程安全的，因为是通过new来创建对象，相当于每个线程拿到的是不一样的副本。

P71 习题卖票读题

证明方法：余票数和卖出去的票数相等，代表前后一致，没有线程安全问题。

@Slf4j(topic="c.ExerciseSell")
public class ExerciseTransfer {
    public static void main(String[] args) throws InterruptedException {
        //模拟多人买票
        TicketWindow window = new TicketWindow(100000);
        //所有线程的集合
        List<Thread> threadList = new ArrayList<>();
        //卖出的票数统计
        List<Integer> amountList = new Vector<>();
        for(int i=0;i<20000;i++){
            Thread thread = new Thread(()->{
                int amount = window.sell(randomAmount());//买票
                try {
                    Thread.sleep(randomAmount());
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                amountList.add(amount);
            });
            threadList.add(thread);
            thread.start();
        }
        for (Thread thread :threadList) {
            thread.join();
        }
        log.debug("余票:{}",window.getCount());
        log.debug("卖出的票数:{}",amountList.stream().mapToInt(i->i).sum());
    }
    static Random random = new Random();
    public static int randomAmount(){
        return random.nextInt(5)+1;
    }
}
class TicketWindow{
    private int count;
    public TicketWindow(int count){
        this.count = count;
    }
    public int getCount(){
        return count;
    }
    public int sell(int amount){
        if(this.count >= amount){
            this.count -= amount;
            return amount;
        }else{
            return 0;
        }
    }
}

P72 习题卖票测试方法

老师用的是一个测试脚本进行测试。

P73 习题卖票解题

临界区：多个线程对共享变量有读写操作。

在sell方法中存在对共享变量的读写操作，因此只需要在方法上加synchronized：

P74 习题转账

这道题的难点在于有2个共享变量，一个是a的账户中的money，一个是b的账户中的money。

@Slf4j(topic="c.ExerciseTransfer")
public class ExerciseTransfer1{
    public static void main(String[] args) throws InterruptedException {
        Account a = new Account(1000);
        Account b = new Account(1000);
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 1000; i++) {
                a.transfer(b,randomAmount());
            }
        },"t1");
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 1000; i++) {
                b.transfer(a,randomAmount());
            }
        },"t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("total:{}",(a.getMoney()+b.getMoney()));
    }
    static Random random = new Random();
    public static int randomAmount(){return random.nextInt(100)+1;}
}
class Account {
    private int money;
    public Account(int money){
        this.money = money;
    }
    public int getMoney(){
        return money;
    }
    public void setMoney(int money){
        this.money = money;
    }
    public void transfer(Account target,int amount){
        synchronized(Account.class) {
            if (this.money >= amount) {
                this.setMoney(this.getMoney() - amount);//自身余额，减去转账金额
                target.setMoney(target.getMoney() + amount);//对方余额加上转账金额
            }
        }
    }

}

偷懒的方法加入下面：synchronized(Account.class)，相当于锁住两个账户的临界资源，缺点是n个账户只能有2个账户进行交互。