黑马课程

文章目录

1. Java线程
- 1.1 创建和运行线程
- - 方法一：Thread
  - 方法二：Runnable（推荐）
  - lambda精简
  - Thread和runnable原理
  - 方法三：FutureTask配合Thread
- 1.2 查看进程和线程的方法
- 1.3 线程运行原理
- - 栈与栈帧
  - 线程上下文切换
- 1.4 线程常见方法
- - 方法概述
  - start() 和 run()
  - sleep() 和 yield()
  - join()
  - interrupt()
  - 过时方法
  - 主线程和守护线程
- 1.5 终止模式之两阶段终止模式
- 1.6 应用 - 防止CPU占用100%（sleep）
- 1.7 习题：烧水泡茶多线程方案
- 1.8 小结
2. 并发共享模型之管程 (悲观锁)
- 2.1 synchronized 解决方案
- - 面向过程
  - 改进：面向对象
  - 方法上的synchronized
  - 习题：线程八锁
- 2.2 线程安全分析
- - 成员变量的线程不安全
  - 局部变量是线程安全的
  - 局部变量的线程不安全
- 2.3 常见线程安全类
- 2.4 习题
- - 线程安全性判断
  - 练习：卖票
  - *练习：转账
- 2.5 Monitor
- - Java对象头
  - Monitor（锁）
  - synchronized原理
  - synchronized优化：多种锁
  - 轻量级锁
  - 锁膨胀
  - 自旋优化
  - 偏向锁
  - 撤销偏向锁
  - 批量重偏向和批量撤销
  - 锁消除
3. 同步
- 3.1 wait notify
- 3.2 同步模式之保护性暂停
- - Guarded Suspension
  - join 原理
  - 多任务版 Guard Suspension
- 3.3 同步模式之生产者/消费者
- 3.4 pack和unpack
- 3.5 线程状态
- 3.6 线程状态的转换

1. Java线程

前期准备：
导入依赖

<dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>lombok</artifactId>
</dependency>
<dependency>
	<groupId>ch.qos.logback</groupId>
	<artifactId>logback-classic</artifactId>
</dependency>

1.1 创建和运行线程

方法一：Thread

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

在这里插入图片描述

方法二：Runnable（推荐）

把【线程】和【任务】（要执行的代码）分开

Thread 代表线程
Runnable 可运行的任务（线程要执行的代码）

@Slf4j(topic = "test")
public class ConcurrentApplication {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                log.debug("running inside");
            }
        };
        Thread t = new Thread(runnable);
        t.setName("t1");
        t.start();
        log.debug("running outside");
    }

}

lambda精简

runnable是一个函数式接口，可以用lambda简化

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

如下

@Slf4j(topic = "test")
public class ConcurrentApplication {
    public static void main(String[] args) {
        Runnable runnable = () -> log.debug("running inside");
        Thread t = new Thread(runnable);
        t.setName("t1");
        t.start();
        log.debug("running outside");
    }
}

Thread和runnable原理

class Thread implements Runnable{
    //1. runnable作为参数传递到Thread的构造方法中，然后交由init函数
	public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
    //2. init函数将调用它的重载函数
    private void init(ThreadGroup g, Runnable target, String name, long stackSize) {
        init(g, target, name, stackSize, null, true);
    }
    //3. 重载函数将target赋值给Thread的私有变量target
     private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
         ...
         this.target = target;
         ...
    }
    //4. 根据私有变量target是否为空，选择是否执行target方法
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
}

无论是否有runnable，走的都是Thread自身的run方法
方法一是重写Thread的run方法，方法二是通过Thread的run方法执行传来的Runnable对象里的run方法

方法三：FutureTask配合Thread

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

@Slf4j(topic = "test")
public class ConcurrentApplication {
    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 t = new Thread(task);
        t.setName("t1");
        t.start();
        //等待结果返回
        log.debug("{}", task.get());//{}是占位符
    }
}

1.2 查看进程和线程的方法

windows

tasklist		查看进程
tasklist | findstr keyword		根据关键字查找进程
taskkill /F /PID <PID>		根据进程号杀死进程

linux

ps -fe		查看所有进程
ps -fe | grep keyword		根据关键字查找
kill <PID>		杀死进程
top		以动态方式展示进程
top -H -p <PID>		根据进程号查找线程

java

jsp		查看所有Java进程
jstack <PID>		查看某个Java进程的所有线程情况
jconsole		查看某个Java进程中线程的运行情况（图形界面）

jconsole有兴趣学习

1.3 线程运行原理

栈与栈帧

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

每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

示例程序

public class ConcurrentApplication {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        method1(10);
    }
    private static void method1(int x){
        int y = x+1;
        Object m = method2();
        System.out.println(m);
    }
    private static Object method2(){
        Object n = new Object();
        return n;
    }
}

栈帧

在这里插入图片描述

jvm加载 ConcurrentApplication 类到方法区
启动一个名为 main 的主线程，并为其分配栈内存（由多个栈帧组成）
将main线程交给任务调度器调度执行
main栈帧、method1栈帧、method2栈帧依次进入mian线程栈
每个线程中有一个程序计数器，记录下一条执行命令

每个线程一个栈，线程中的每一个方法为一个栈帧

多线程debug时，模式要选线程Thread

线程上下文切换

可能的原因

线程的 cpu 时间片用完
垃圾回收
有更高优先级的线程需要运行
线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

当Context Switch时，需要由操作系统保存当前线程的状态
Java使用程序计数器记录下一条 jvm 指令的执行地址，是线程私有的

状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等
Context Switch 频繁发生会影响性能

1.4 线程常见方法

方法概述

start()
- 启动一个新线程，在新的线程中运行 run 方法中的代码
- start 方法只是让线程进入就绪，里面代码不一定立刻运行
- 每个线程对象的start方法只能调用一次，如果调用了多次会出现IllegalThreadStateException
run()
- 新线程启动后会调用的方法
join()
- 等待线程运行结束
join(long n)
- 等待线程运行结束,最多等待 n毫秒
getId()
- 获取线程长整型的 id
getName()
setName(String)
getPriority()

setPriority(int)

java中规定线程优先级是1~10 的整数，较大的优先级能提高该线程被 CPU 调度的机率

public final static int MIN_PRIORITY = 1;//最小
public final static int NORM_PRIORITY = 5;//默认
public final static int MAX_PRIORITY = 10;//最大

getState()
- 获取线程状态
- Java 中线程状态是用 6 个 enum 表示，分别为：NEW, RUNNABLE, BLOCKED, WAITING,TIMED_WAITING, TERMINATED
isInterrupted()
- 判断是否被打断，不影响打断标志
isAlive()
- 线程是否存活（是否运行完毕）
interrupt()
- 打断线程
- 如果被打断线程正在 sleep，wait，join 会导致被打断的线程抛出 InterruptedException，并清除打断标记
- 如果打断的正在运行的线程，则会设置打断标记
- park 的线程被打断，也会设置打断标记
interrupted()
- static
- 判断当前线程是否被打断，会清除打断标志
currentThread()
- static
- 获取当前正在执行的线程
sleep(long n)
- static
- 让当前执行的线程休眠n毫秒，休眠时让出 cpu 的时间片给其它线程
yield()
- static
- 提示线程调度器让出当前线程对CPU的使用
- 主要是为了测试和调试

start() 和 run()

run

@Slf4j(topic = "test")
public static void main(String[] args) throws ExecutionException, InterruptedException {
    Thread t1 = new Thread("t1"){
        @Override
        public void run(){
            log.debug("running inside");
        }
    };
    t1.run();
}

执行结果：执行run方法的是 main 线程，新创建的线程并未启动
在这里插入图片描述

start

//查看启动前后线程的状态
System.out.println(t1.getState());//状态：NEW
t1.start();
System.out.println(t1.getState());//状态：RUNNABLE

在这里插入图片描述

sleep() 和 yield()

sleep
1. 调用 sleep 会让当前线程从 Runnable 进入 Timed Waiting 状态（阻塞）
2. 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
```
t1.interrupt();//叫醒t1线程
```
3. 睡眠结束后的线程未必会立刻得到执行（可能cpu正忙）
4. 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性
```
TimeUnit.SECONDS.sleep(2);//睡眠2秒
```
yield
1. 调用 yield 会让当前线程从 Running运行状态 进入 Ready就绪状态，然后调度执行其它线程
  Runnable包括 Running(运行) 和 Ready(就绪) 2种状态
2. 具体的实现依赖于操作系统的任务调度器

sleep会使当前线程陷入阻塞，而yield不会阻塞，只是让出cpu资源而已

join()

public static void main(String[] args){
    ...
	t1.start();
    ...
	t1.join();//等待线程t1执行完毕之后，再执行main中后面的代码
    ...
}

join(n)：有时限的等待

interrupt()

对于正常运行的线程，interrupt不会影响其运行，只是会设置打断标记为true
对于处于sleep等的线程，interrupt会将其唤醒，即打断阻塞

打断标记：如果本线程被打断过，打断标记将为true

打断 sleep，wait，join 的线程：会清除打断标记，仍为false

Thread t1 = new Thread(() ->{
    try{ Thread.sleep(10000);} catch (InterruptedException e) { e.printStackTrace(); }
    try{ Thread.sleep(10000);} catch (InterruptedException e) { e.printStackTrace(); }
}, "t1");

t1.start();
Thread.sleep(1000); //等t1进入sleep
log.debug("before interrupt: {}", t1.isInterrupted());
log.debug("before interrupt: {}", t1.getState());

t1.interrupt();
Thread.sleep(1000); //等t1再次进入sleep
log.debug("after interrupt: {}", t1.isInterrupted());
log.debug("after interrupt: {}", t1.getState());

结果

01:29:13.546 [main] DEBUG test - before interrupt: false
01:29:13.551 [main] DEBUG test - before interrupt: TIMED_WAITING
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at com.example.ConcurrentApplication.lambda$main$0(ConcurrentApplication.java:18)
	at java.lang.Thread.run(Thread.java:748)
01:29:14.565 [main] DEBUG test - after interrupt: false
01:29:14.565 [main] DEBUG test - after interrupt: TIMED_WAITING

注意：这里 interrupt 之后，打断标记会短暂地标记为true，然后再被标记为false
可以通过去掉main主线程的第二次sleep观察到

打断正常运行的线程：不会清除打断标记，变为true

Thread t1 = new Thread(() ->{
    while(true){
        boolean interrupted = Thread.currentThread().isInterrupted();
        if(interrupted){
            log.debug("被打断了，退出循环");
            break;
        }
    }
}, "t1");
t1.start();
Thread.sleep(1000);
t1.interrupt();

可以用来停止线程

打断park线程：不会清除打断标记
- 初始打断标记为false，打断后，标记为true
- 注意：打断标记为true时，park将失效；解决方法：使用 interrupted() 方法

过时方法

不推荐使用的方法，这些方法已过时，容易破坏同步代码块，造成线程死锁：

stop()：停止线程运行

废弃原因：方法粗暴，除非可能执行 finally 代码块以及释放 synchronized 外，线程将直接被终止，如果线程持有 JUC 的互斥锁可能导致锁来不及释放，造成其他线程永远等待的局面
suspend()：挂起（暂停）线程运行

废弃原因：如果目标线程在暂停时对系统资源持有锁，则在目标线程恢复之前没有线程可以访问该资源，如果恢复目标线程的线程在调用 resume 之前会尝试访问此共享资源，则会导致死锁
resume()：恢复线程运行

主线程和守护线程

默认情况下，Java 进程需要等待所有线程都运行结束，才会结束
有一种特殊的线程叫做守护线程，只要其它非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束

Thread t1 = new Thread(()->{
    while(true){
        if(Thread.currentThread().isInterrupted()){
            break;
        }
    }
    log.debug("未运行的部分");
}, "t1");
t1.setDaemon(true);//设置为守护线程
t1.start();
log.debug("finish");

结果：即便t1线程是一个while循环，也可观察到java进程的结束

垃圾回收器线程就是一种守护线程
Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求

1.5 终止模式之两阶段终止模式

错误思路

使用线程对象的 stop() 方法停止线程
- stop 方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁，其它线程将永远无法获取锁
使用 System.exit(int) 方法停止线程
- 目的仅是停止一个线程，但这种做法会让整个程序都停止

应用示例

需求：每隔一段时间打印监控数据

在这里插入图片描述

package com.example;

@Slf4j(topic = "c.test")
public class ConcurrentApplication {
    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination tpt = new TwoPhaseTermination();
        tpt.start();

        Thread.sleep(3500);
        tpt.stop();
    }
}

@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;
                }
                //未被打断，无异常则每隔1秒执行一次监控记录
                try {
                    Thread.sleep(1000);//如果在这里sleep被打断，将进入catch里面
                    log.debug("执行监控记录");
                }catch (InterruptedException e){
                    e.printStackTrace();
                    current.interrupt();//重新设置打断标记为true，应对sleep时打断情况
                }
            }
        });
        monitor.start();
    }
    //停止监控线程
    public void stop(){
        monitor.interrupt();
    }
}

结果：优雅结束线程

01:57:22.026 [Thread-1] DEBUG c.TwoPhaseTermination - 执行监控记录
01:57:23.034 [Thread-1] DEBUG c.TwoPhaseTermination - 执行监控记录
01:57:24.036 [Thread-1] DEBUG c.TwoPhaseTermination - 执行监控记录
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at com.example.TwoPhaseTermination.lambda$start$0(ConcurrentApplication.java:40)
	at java.lang.Thread.run(Thread.java:748)
01:57:24.533 [Thread-1] DEBUG c.TwoPhaseTermination - 料理后事

1.6 应用 - 防止CPU占用100%（sleep）

在一个1核虚拟机上实验

public class ConcurrentApplication {
    public static void main(String[] args){
        new Thread(()->{
            while (true){
                //如果不加下面一句，cpu会占满至100%
                try{ Thread.sleep(1); }catch (Exception e){}
            }
        }).start();
    }
}

可以用 wait 或条件变量达到类似的效果
不同的是，后两种都需要加锁，并且需要相应的唤醒操作，一般适用于要进行同步的场景
sleep 适用于无需锁同步的场景

1.7 习题：烧水泡茶多线程方案

题目：

想泡壶茶喝。情况是：开水没有；水壶要洗，茶壶、茶杯要洗；火已生了，茶叶也有了。怎么办？

分析：

在这里插入图片描述

实现：

public static void sleep(int i){
    try{
        TimeUnit.SECONDS.sleep(i);
    }catch (InterruptedException e){
        e.printStackTrace();
    }
}
public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        log.debug("洗水壶");
        sleep(1);
        log.debug("烧开水");
        sleep(15);
    }, "zhangsan");
    Thread t2 = new Thread(() -> {
        log.debug("洗茶壶");
        sleep(1);
        log.debug("洗茶杯");
        sleep(2);
        log.debug("拿茶叶");
        sleep(1);
        try {
            t1.join();//等待开水烧好
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("泡茶");
    }, "lisi");
    t1.start();
    t2.start();
}

改进之处：

需要zhangsan来最后泡茶
目前两个线程是各执行各的，如果需要交换信息呢？

1.8 小结

本章的重点在于掌握

线程创建
线程重要 api，如 start，run，sleep，join，interrupt 等
应用方面
- 异步调用：主线程执行期间，其它线程异步执行耗时操作
- 提高效率：并行计算，缩短运算时间
- 同步等待：join
- 统筹规划：合理使用线程，得到最优效果
原理方面
- 线程运行流程：栈、栈帧、上下文切换、程序计数器
- Thread 两种创建方式的源码
模式方面
- 终止模式之两阶段终止

2. 并发共享模型之管程 (悲观锁)

Monitor，称为管程、监视器，是重量级锁的原理
悲观锁：阻塞等待

思考：两个线程对初始值为0的静态变量做自增和自减，各执行5000，最后结果是多少？
答案：可能为0，可能为正，可能为负
分析：自增实际上会产生如下的JVM字节码命令（自减类似）
getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
iadd // 自增
putstatic i // 将修改后的值存入静态变量i
变量存储在主内存中，自增自减需要将变量的值读取到自己线程独有的工作内存中操作
当自增自减同时读取了 i 的值，那么最终写入时，会有一方覆盖另一方的结果，导致某方本次操作失效，从而使得结果变化难定

竞态条件

Race Condition，多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件

解决方案

阻塞式：synchronized（对象锁），Lock
非阻塞式：原子变量

2.1 synchronized 解决方案

java 中互斥和同步都可以采用 synchronized 关键字来完成
synchronized，俗称对象锁

面向过程

语法

synchronized(对象){
    临界区
}

示例：2个线程做自增自减

锁推荐使用 final

static int counter = 0; //静态变量
static Object lock = new Object(); //锁

public static void main(String[] args){
    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();
    System.out.println(counter);
}

synchronized 实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切换所打断

改进：面向对象

@Slf4j(topic = "c.test")
public class ConcurrentApplication {
    public static void main(String[] args){
        Room room = new Room();

        Thread t1 = new Thread(() -> {
            for(int i=0; i<5000; ++i) room.increment();
        }, "t1");
        Thread t2 = new Thread(() -> {
            for(int i=0; i<5000; ++i) room.decrement();
        }, "t2");
        t1.start();
        t2.start();
        System.out.println(room.getCounter());
    }
}

class Room{
    private int counter = 0;
    public void increment(){
        synchronized (this){ //这里的this指的是调用该方法的对象，即锁对象
            counter++;
        }
    }
    public void decrement(){
        synchronized (this){
            counter--;
        }
    }
    public int getCounter(){
        synchronized (this){ //使读取过程中counter不会被修改
            return counter;
        }
    }
}

关于this
当使用锁的时候，必然需要创建一个锁对象。例如：Room room = new Room();
这里的this，就是指代调用该方法的Room对象，即room

方法上的synchronized

非静态方法

class Test{
    public synchronized void test(){}
}
//等价于
class Test{
    public void test(){
        synchronized (this){};
    }
}

synchronized (this)，锁的是该方法所在类的实例对象

静态方法

class Test{
    public synchronized static void test(){}
}
//等价于
class Test{
    public static void test(){
        synchronized (Test.class){};
    }
}

前面的Room就可以简化为

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

习题：线程八锁

考察 synchronized 锁住的是哪个对象

锁对象：n1，多个线程是同一个锁对象

题1

public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}
@Slf4j(topic = "c.Number")
class Number{
    public synchronized void a() { log.debug("1"); }
    public synchronized void b() { log.debug("2"); }
}

结果：12或21（12概率大，因为线程1先启动）

题2

public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}
@Slf4j(topic = "c.Number")
class Number{
    public synchronized void a() { 
        sleep(1);//这里的sleep被封装过，代表1秒
        log.debug("1"); 
    }
    public synchronized void b() { log.debug("2"); }
}

锁对象：n1
结果

如果是t1先获得调度，那么结果：1s 后打印 12
如果是t2先获得调度，那么结果：立即打印 2，1s 后打印 1

题3

public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
    new Thread(()->{ n1.c(); }).start();
}
@Slf4j(topic = "c.Number")
class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
    public void c() {
        log.debug("3");
    }
}

结果

t1先获得调度：立即打印 3，1s 后打印 12（312）
t2先获得调度：立即打印 23，1s 后打印 1 （231）
t3先获得调度：立即打印3，12看调度顺序（312，321）

题4

public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n2.b(); }).start();
}
@Slf4j(topic = "c.Number")
class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}

结果：21（相当于未加锁，不存在互斥）

题5

public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}
@Slf4j(topic = "c.Number")
class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}

结果：a() 锁住的是类对象 Number.class，b() 锁住的是普通对象 n1，两个锁对象不同，相当于未加锁，输出 21

题6

public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}
@Slf4j(topic = "c.Number")
class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public static synchronized void b() {
        log.debug("2");
    }
}

结果：21或12（锁住了同一个类对象，存在互斥）

题7

public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n2.b(); }).start();
}
@Slf4j(topic = "c.Number")
class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}

结果：21（相当于未加锁，不存在互斥）

题8

public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n2.b(); }).start();
}
@Slf4j(topic = "c.Number")
class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public static synchronized void b() {
        log.debug("2");
    }
}

结果：12 或 21（是同一个类对象锁，存在互斥）

2.2 线程安全分析

成员变量和静态变量是否线程安全？

如果它们没有共享，则线程安全
如果它们被共享了，根据它们的状态是否能够改变，又分两种情况
- 如果只有读操作，则线程安全
- 如果有读写操作，则这段代码是临界区，需要考虑线程安全

局部变量是否线程安全？

局部变量是线程安全的——存储在每个栈帧中，并不共享
但局部变量引用的对象则未必
- 如果该对象没有逃离方法的作用访问，它是线程安全的
- 如果该对象逃离方法的作用范围，需要考虑线程安全

成员变量的线程不安全

static final int THREAD_NUMBER = 2;
static final int LOOP_NUMBER = 200;
public static void main(String[] args) {
    ThreadUnsafe test = new ThreadUnsafe();
    for (int i = 0; i < THREAD_NUMBER; i++) {
        new Thread(() -> {
        	test.method1(LOOP_NUMBER);
        }, "Thread" + i).start();
    }
}

class ThreadUnsafe {
    ArrayList<String> list = new ArrayList<>();
    public void method1(int loopNumber) {
        for (int i = 0; i < loopNumber; i++) {
            method2();
            method3();
        }
    }
    private void method2() {
        list.add("1");
    }
    private void method3() {
        list.remove(0);//删除第1个元素
    }
}

原因：这里的 test对象 和 list对象 是线程共享的
分析
看似每一次remove前都add过一次，似乎不会出现错误。但是考虑以下情况：
两个线程都执行add操作，由于读取时恰好读取了同一个index，所以出现一次add被覆盖掉了（两个都添加在了同一个index上）
此时相当于只增加了一个数据，却要删除2个数据，因此报错 IndexOutOfBoundsException

局部变量是线程安全的

static final int THREAD_NUMBER = 2;
static final int LOOP_NUMBER = 200;
public static void main(String[] args) {
    ThreadSafe test = new ThreadSafe();
    for (int i = 0; i < THREAD_NUMBER; i++) {
        new Thread(() -> {
            test.method1(LOOP_NUMBER);
        }, "Thread" + i).start();
    }
}

class ThreadSafe {
    public void method1(int loopNumber) {
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < loopNumber; i++) {
            method2(list);
            method3(list);
        }
    }
    private void method2(ArrayList<String> list) {
        list.add("1");
    }
    private void method3(ArrayList<String> list) {
        list.remove(0);
    }
}

每次调用 method1 都会新创建一个 list 实例，相当于两个线程利用同一个 test 对象，创建了两个不同的 list 对象在堆上，互不影响

思考：如果这里的method2和method3改为public，被其他线程调用，还是线程安全的吗？
答案：是线程安全的。即便供其他线程调用，其他线程传来的也是该线程的list，不会影响到本线程的list

局部变量的线程不安全

static final int THREAD_NUMBER = 2;
static final int LOOP_NUMBER = 200;
public static void main(String[] args) {
    ThreadSafeSubClass test = new ThreadSafeSubClass();
    for (int i = 0; i < THREAD_NUMBER; i++) {
        new Thread(() -> {
            test.method1(LOOP_NUMBER);
        }, "Thread" + i).start();
    }
}

class ThreadSafe {
    public void method1(int loopNumber) {
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < loopNumber; i++) {
            method2(list);
            method3(list);
        }
    }
    public void method2(ArrayList<String> list) {
        list.add("1");
    }
    public void method3(ArrayList<String> list) {
        list.remove(0);
    }
}
class ThreadSafeSubClass extends ThreadSafe{
    @Override
    public void method3(ArrayList<String> list) {
        new Thread(() -> {
            list.remove(0);
        }).start();
    }
}

这里是会出现线程不安全的，父子线程将共用一个list
一种不安全的情况如下：
ThreadSafe里面的for循环2次，那么就有1个父线程（执行2次add），2个子线程（各执行1次remove），这3个线程共享同一个list
执行顺序如果是：第1个add完成（size=1） —— 第1个remove尚未完成（size=1） —— 第2个add完成（size=2）—— 第1个remove完成（size=0） —— 第2个remove（报错！！）

这里也可以看出private和final对线程安全的意义

不以父子类来看，概括的说，只要出现共享变量，就会存在线程不安全的问题

2.3 常见线程安全类

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

这里说它们是线程安全的是指，多个线程调用它们同一个实例的某个方法时，是线程安全的，如下：

Hashtable table = new Hashtable();
new Thread(()->{
    table.put("key1", "value1");
}).start();
new Thread(()->{
    table.put("key2", "value2");
}).start();

HashTable中的put方法定义如下

 public synchronized V get(Object key){}

但注意它们多个方法的组合不是原子的，例如下述代码就不是原子的

Hashtable table = new Hashtable();
if(table.get("key") == null){
    table.put("key", value);
}
//get和put单独都是线程安全的，但它们组合使用是不安全的

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

String的subString是返回一个新的String对象，不会改变原有字符串

2.4 习题

线程安全性判断

例1

public class MyServlet extends HttpServlet {
    Map<String,Object> map = new HashMap<>();//不安全
    String S1 = "...";//安全
    final String S2 = "...";//安全
    Date D1 = new Date();//不安全
    final Date D2 = new Date();//不安全：final规定了D2的引用值不能改变，但对象里面的属性是可以改变的
}

例2

//MyServlet只有一份，对应的UserServiceImpl只有一份，所以这里是线程不安全的
public class MyServlet extends HttpServlet {
    private UserService userService = new UserServiceImpl();
    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        userService.update(...);
    }
}
public class UserServiceImpl implements UserService {
    private int count = 0;
    public void update() {
        count++;
    }
}

例3

@Aspect
@Component
public class MyAspect {
    private long start = 0L;
    @Before("execution(* *(..))")
    public void before() {
        start = System.nanoTime();
    }
    @After("execution(* *(..))")
    public void after() {
        long end = System.nanoTime();
        System.out.println("cost time:" + (end-start));
    }
}

MyAspect默认应该是单例模式，单例bean被所有线程共享，start作为成员变量也将被线程共享
因此上面代码是线程不安全的

bean中最好不要使用成员变量，改为环绕通知，使用局部变量

例4

public class MyServlet extends HttpServlet {
    // 是否安全？—— 线程安全
    private UserService userService = new UserServiceImpl();
    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        userService.update(...);
    }
}
public class UserServiceImpl implements UserService {
    // 是否安全？ —— 线程安全（userDao里面没有可更改的属性）
    private UserDao userDao = new UserDaoImpl();
    public void update() {
        userDao.update();
    }
}
public class UserDaoImpl implements UserDao {
    public void update() {
        String sql = "update user set password = ? where username = ?";
		// 是否安全？—— 线程安全（没有成员变量的类大多线程安全，这里的conn创建在各自的线程空间之中）
        try (Connection conn = DriverManager.getConnection("","","")){
			// ...
        } catch (Exception e) {
			// ...
        }
    }
}

例5

public class MyServlet extends HttpServlet {
    // 是否安全？—— 线程不安全
    private UserService userService = new UserServiceImpl();
    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        userService.update(...);
    }
}
public class UserServiceImpl implements UserService {
    // 是否安全？ —— 线程不安全
    private UserDao userDao = new UserDaoImpl();
    public void update() {
        userDao.update();
    }
}
public class UserDaoImpl implements UserDao {
    // 是否安全？—— 线程不安全
    private Connection conn = null;
    public void update() {
        String sql = "update user set password = ? where username = ?";
        conn = DriverManager.getConnection("","","");
		// ...
    }
}

例6

public class MyServlet extends HttpServlet {
    // 是否安全？—— 线程安全
    private UserService userService = new UserServiceImpl();
    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        userService.update(...);
    }
}
public class UserServiceImpl implements UserService {
    public void update() {
        private UserDao userDao = new UserDaoImpl();
        userDao.update();
    }
}
public class UserDaoImpl implements UserDao {
    // 是否安全？—— 线程不安全
    private Connection conn = null;
    public void update() {
        String sql = "update user set password = ? where username = ?";
        conn = DriverManager.getConnection("","","");
		// ...
    }
}

例7

public abstract class Test {
    public void bar() {
		// 是否安全？—— 线程不安全（如果foo被子类继承，且子类有新的线程，那么父子类共享sdf变量，存在线程不安全的隐患）
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        foo(sdf);
    }
    public abstract foo(SimpleDateFormat sdf);
    public static void main(String[] args) {
        new Test().bar();
    }
}

其中 foo 的行为是不确定的，可能导致不安全的发生，被称之为外星方法

思考：为什么String类要设置为final
—— 保证了线程安全

练习：卖票

思考下列代码是否存在线程安全性问题，如果存在，如何改正？

package com.example;

@Slf4j(topic = "c.test")
public class ConcurrentApplication {
    public static void main(String[] args) throws InterruptedException {
        //模拟多人买票
        TicketWindow window = new TicketWindow(10000);
        //卖出的票数统计
        List<Integer> amountList = new Vector<>();//Vector是线程安全的，List不是
        //为了使主线程在所有抢票线程结束之后再统计余票，需要join所有抢票线程
        //可以使用一个List来循环join操作
        List<Thread> threadList = new ArrayList<>();
        //假设2000个人在抢票
        for(int i=0; i<2000; ++i){
            //每个人随机买1-5张票
            Thread thread = new Thread(() -> {
                int amount = window.sell(randomAmount());
                amountList.add(amount);
            });
            threadList.add(thread);
            thread.start();
        }
        //等待2000个抢票线程执行完毕
        for(Thread thread : threadList){
            thread.join();
        }
        //验证是否线程安全：卖出的票数+剩余的票数=总票数
        log.debug("余票：{}", window.getCount());
        log.debug("卖出的票数：{}", amountList.stream().mapToInt(i -> i).sum());
    }
    //随机1-5
    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 this.count;
    }
    public int sell(int amount){
        if(this.count >= amount){
            this.count -= amount;
            return amount;
        }else return 0;
    }
}

某次结果如下：

在这里插入图片描述

这里余票+卖出的票数大于总票数，显然是有问题的，主要在于TicketWindow.sell()方法，它是线程不安全的

分析：存在读写的地方

int amount = window.sell(randomAmount());//不安全
amountList.add(amount);//安全：Vector的add自身已经被定义为了synchronized，不用再考虑
threadList.add(thread);//安全：ArrayList虽然不是线程安全类，但由于该语句只在主线程中使用，不存在线程共享

改进方法

public synchronized int sell(int amount){
    if(this.count >= amount){
        this.count -= amount;
        return amount;
    }else return 0;
}

*练习：转账

思考下列代码是否存在线程安全性问题，如果存在，如何改正？

package com.example;

@Slf4j(topic = "c.test")
public class ConcurrentApplication {
    public static void main(String[] args) throws InterruptedException {
        Account a = new Account(1000);
        Account b = new Account(1000);
        //a不断向b转账
        Thread t1 = new Thread(() -> {
            for(int i=0; i<1000; ++i){
                a.transfer(b, randomAmount());
            }
        }, "t1");
        //同时，b也不断向a转账
        Thread t2 = new Thread(() -> {
            for(int i=0; i<1000; ++i){
                b.transfer(a, randomAmount());
            }
        }, "t2");
        t1.start();t2.start();
        t1.join();t2.join();
        //验证是否有错误：a账户+b账户 = 2000
        log.debug("total: {}", (a.getMoney()+b.getMoney()));
    }

    //随机1-5
    static Random random = new Random();
    public static int randomAmount(){return random.nextInt(5)+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){
        if(this.money >= amount){
            this.setMoney(this.getMoney()-amount);
            target.setMoney(target.getMoney()+amount);
        }
    }
}

结果：多次运行后，可以看到有的时候 total = 2000 total > 2000 total < 2000 这3种情况都有出现

改进方法

注意，这里改进不对的话，还会造成死锁

错误方法
```
public synchronized void transfer(Account target, int amount){
    if(this.money >= amount){
        this.setMoney(this.getMoney()-amount);
        target.setMoney(target.getMoney()+amount);
    }
}
```
分析：它相当于
```
public synchronized void transfer(Account target, int amount){
    synchronized(this){
        if(this.money >= amount){
            this.setMoney(this.getMoney()-amount);
            target.setMoney(target.getMoney()+amount);
        }
    }
}
```
当a向b转账时，这里的this指的是a的账户，也就是说

a.transfer(b, randomAmount())是安全的，但b.transfer(a, randomAmount())是不安全的，因为a上锁了，但b没有

反之亦然，在 transfer上加 synchronized，只能保证单向转账，不能双方同时转账

分析：假设a，b同时转账，a–>b = 10，b -->a = 20，其中一种情况可能为：
- 线程B（先开始）：b调用transfer，此时b账户上锁，this.setMoney（b=980），target.setMoney读取但尚未写入（a=1000）
- 线程A：a调用transfer，此时账户a上锁，this.setMoney（a=990），等待b的锁
- 线程B：target.setMoney继续写入（a=1020），覆盖掉线程A对账户a的操作；此时线程B结束，释放b的锁
- 线程A：target.setMoney（b=990）
- 最终结果：a=1020，b=990
  
  （如果线程A先开始，有可能出现 a=1010，b=1010 的情况）
错误方法
```
public synchronized void setMoney(int money) {this.money = money;}
//转账
public synchronized void transfer(Account target, int amount){
    if(this.money >= amount){
        this.setMoney(this.getMoney()-amount);
        target.setMoney(target.getMoney()+amount);
    }
}
```
分析：容易导致死锁问题
- 线程A：a.transfer，对a账户加锁；this.setMoney，对setMoney加锁；准备调用target.setMoney
- 线程B：b.transfer，对b账户加锁；调用this.setMoney，发现它已被线程A加锁，于是等待线程A释放setMoney的锁
- 线程A：调用target.setMoney，发现线程B已对b账户加锁，于是等待线程B释放b账户的锁
- 线程A，B都在等待对方释放锁，最终陷入死锁

可行方法

//转账
public void transfer(Account target, int amount){
    synchronized (Account.class){
        if(this.money >= amount){
            this.setMoney(this.getMoney()-amount);
            target.setMoney(target.getMoney()+amount);
        }
    }
}

这只是临时解决，实际上是不会采用这种方式的，因为效率非常的慢：同一时间只允许一个人操作

2.5 Monitor

这一节有些知识点比较模糊，可能存在错误之处，待深入学习改正

Java对象头

以32位虚拟机为例

int 类型占 4 字节
Integer 类型占 16 字节：4字节数据 + 8字节对象头 + 4字节的对齐

Mark Word

32位系统

64位系统
- hashcode：哈希码
- age：分代年龄
- biased_lock：是不是偏向锁
不同状态下，Mark Word的结构会变化
普通对象的对象头
- 一个普通对象的对象头占 64 bits，即8字节
- Mark Word 占 32 bits：对象的基本信息
- Klass Word 占 32 bits：指针，指向这个对象对应的Class
数组对象的对象头
- 一个数组对象的对象头占 96 bits，即12字节
- Mark Word 占 32 bits
- Klass Word 占 32 bits
- array length 占 32 bits

Monitor（锁）

Monitor，常称为 监视器 或管程，是对象锁的底层原理

每个Java对象都可以关联一个 Monitor 对象，如果使用 synchronized 给对象上锁（重量级）之后，该对象头的 Mark Word 中就被设置指向 Monitor 对象的指针

在这里插入图片描述

对象是java提供的，Monitor是操作系统提供的
上锁时，对象的 Mark Word 标志变为 10（Heavyweight Locked），剩下的 30 bits 指针指向Monitor对象
Owner：当前锁的拥有者
EntryList：等待队列，等待该锁被释放的线程队列，这些线程处于阻塞状态
WaitSet：线程队列，这些线程该之前获得过锁，但条件不满足从而进入 WAITING 状态的线程（后面会解释）

synchronized原理

public class ConcurrentApplication {
    static final Object lock = new Object();
    static int counter = 0;
    public static void main(String[] args){
        synchronized (lock){
            counter++;
        }
    }
}

对应的字节码文件

打印字节码：
javac ConcurrentApplication.java
javap -c ConcurrentApplication.class

public class ConcurrentApplication {
  static final java.lang.Object lock;
  static int counter;
  ...
  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // 拿到lock引用，synchronized的开始
       3: dup								// 复制了一份lock引用
       4: astore_1							// 将复制的lock引用存放在 slot 1 里面
       5: monitorenter						// 将lock对象的 Mark Word 置为 Monitor 指针
       6: getstatic     #3                  // 这里开始4句做 counter++ 操作
       9: iconst_1
      10: iadd
      11: putstatic     #3
      14: aload_1							// 即将离开临界区，此时先从 slot 1 拿到之前存储的lock引用
      15: monitorexit						// 将lock对象 Mark Word 重置（原信息保存在monitor中），唤醒 EntryList
      16: goto          24					// 跳转到24行，结束执行
      19: astore_2							// 从这里开始处理异常情况：将异常对象e存储到 slot 2中
      20: aload_1							// 出现异常以至于未能释放锁：此时也能获取到锁
      21: monitorexit						// 将lock对象 Mark Word 重置（原信息保存在monitor中），唤醒 EntryList
      22: aload_2							// 获取到异常对象e
      23: athrow							// 抛出异常 throw e
      24: return
    Exception table:						// 监控6到16行，即synchronized部分，如果出现异常，跳转到19行
       from    to  target type
           6    16    19   any
          19    22    19   any
	...
}

synchronized优化：多种锁

1. 重量级锁：Monitor

也称为管程或监视器锁
介绍：重量级锁需要和操作系统对象Monitor关联，因此会涉及到内核态和用户态的转换
优点：安全性高，常用于金融系统等
缺点：会阻塞其他线程，状态的切换也会导致效率低

2. 轻量级锁

介绍
- 轻量级锁应用在多线程交叉访问锁对象的情况，即不存在两个线程同时竞争一个锁对象
- 轻量级锁不需要和Monitor关联，而是通过一个叫 Lock Record 对象在虚拟机内部标识，因此不涉及到状态切换
- 一旦发生竞争，就升级为重量级锁
优点：不用访问Monitor，避免了内核态和用户态的切换，提高程序响应速度，常见于秒杀活动场景

轻量级锁是否存在自旋优化？
目前偏向于是没有的，而是在升级为重量级锁之后，会使用自旋优化（有时间可查源码分析）

3. 偏向锁

依据：很多时候，一个锁对象常常是被同一个线程使用。如果每次锁重入都需要加锁解锁，耗费性能
特点
- 线程加锁时，锁对象会记录当前线程的ID，如果该线程再次访问对应的临界资源，就无需再加锁
- 只适应无并发情况，一旦出现竞争，就升级为重量级锁

在java中，一个对象被创建时，默认其为偏向锁，以101结尾

轻量级锁

无竞争时、线程交叉访问临界资源时可使用轻量级锁
语法仍然是 synchronized，一开始都是轻量级锁，如果发现竞争，就自动升级为重量级锁
Lock Record 对象仅在轻量级锁中使用

static final Object obj = new Object();
public static void method1(){
    synchronized (obj){
        //同步块 A
        method2();
    }
}
public static void method2(){
    synchronized (obj){
        //同步块 B
    }
}

上面代码的工作原理：

创建锁记录对象（Lock Record Object），每个线程都有一个锁记录结构，如果需要加锁就在当前栈帧中新建一个锁记录对象。该对象包含以下内容：
- 锁记录地址和状态：地址表示锁记录对象自身地址，00表示初始状态为轻量级锁
- Object reference：存储要锁对象（即代码中的 obj ）的引用地址
锁记录对象中的Object reference指向锁对象，同时通过CAS操作（一种原子操作）尝试将自己的 lock record 地址 00 和锁对象的 Mark Word 01 交换
- 此时锁对象Mark Word就成了状态00，即表示处于轻量级锁状态，同时还存储了锁记录对象的地址
- 锁记录对象也成功存储了锁对象的Mark Word内容，以便之后恢复
- 交换成功，即加锁成功（其他线程访问锁对象，发现其状态已经是轻量级锁状态00，说明该锁已被其他对象使用，CAS失败）
如果CAS失败，检查锁对象指向的地址是否在本线程的栈帧范围内：
- 如果不是当前线程对其加锁，那么表示有竞争，将进入锁膨胀阶段
- 如果是当前线程，那就是 synchronized锁重入 （如代码中的method2），于是再添加一个Lock Record对象作为重入的计数
  重入的Lock Record对象无需记录 Mark Word，只需记录锁对象的地址
解锁
- 锁记录的值为null：说明有重入，删除null的锁记录对象即可
- 锁记录的值不为null：CAS操作恢复自己的Mark Word
  - 成功：解锁成功
  - 失败：说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程

锁膨胀

如果在尝试加轻量级锁的过程中，CAS操作无法成功，说明该锁已被其他线程占用，此时需要进行锁膨胀，将轻量级锁变成重量级锁

场景：Thread-0已经持有obj锁，此时Thread-1也请求该锁：

Thread-1希望获取锁对象 obj ，执行CAS操作，尝试将自己栈帧中的锁记录对象与锁对象obj的Mark Word进行交换时，发现锁对象状态已经是 00 轻量级锁状态，于是加锁失败，进行锁膨胀
锁膨胀流程
- Thread-1为锁对象obj 申请Monitor锁，让 obj 指向重量级锁地址，更改状态为 10
- Thread-1自身进入Monitor的EntryList BLOCKED
当Thread-0解锁时，发现锁对象obj的指向地址已经不是自己，解锁失败，于是进入重量级解锁流程
- 根据锁对象obj里面的Monitor地址，找到Monitor对象，设置Owner为null，唤醒EntryList中的BLOCKED线程

自旋优化

重量级锁竞争的时候，可以通过自旋来进行优化：即线程一直循环获取锁，直到持锁线程释放锁，从而避免线程阻塞

自旋成功
- 在自旋重试的过程中发现锁对象被释放，于是成功加锁
- 多核下才能实现
自旋失败
- 自旋多次之后，进入阻塞状态

Java 6 之后自旋锁是自适应的：如果对象的上次自旋成功，那么就认为这次成功的可能性会高，于是会多自旋几次；反之，少自旋甚至不自旋

自旋会占用CPU时间，单核CPU自旋就是浪费，多核才能发挥优势

Java 7 之后不能控制是否开启自旋功能

偏向锁

概念

在第一次加锁时，通过CAS操作将线程ID设置到锁对象的Mark Word头里面
锁重入时不再新增锁记录对象，而是比对锁记录对象中的线程ID，如果是本线程，就无需加锁，直接使用
以后只要不发生竞争，这个锁对象就归本线程所有

在一开始的时候，JVM不知道使用的是偏向锁还是轻量级锁，所以会在synchronized开始就创建一个Lock Record
确定为偏向锁后，就不存在指向Lock Record的指针

偏向状态

默认开启
开启了偏向锁后，那么对象创建后，Mark Word 后三位即为101（biased_lock=1, status=01），thread, epoch，age都为0
查看Java对象的对象头：初始状态
```
<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.9</version>
</dependency>
```
```
log.debug(ClassLayout.parseInstance(obj).toPrintable());
```
64位系统下，Mark Word占 64 bits
从最后3位，可以看到初始状态为001（无偏向锁，Normal状态）
- 之所以是001而不是101，是因为偏向锁默认是延迟的，不会在程序启动时立即生效（可以sleep(4000)来观察）
- 如果希望避免延迟，可以加VM参数来禁用延迟
```
-XX:BiasedLockingStartupDelay=0
```

测试偏向锁：加锁之后

synchronized (obj){
    log.debug(ClassLayout.parseInstance(obj).toPrintable());
}
log.debug(ClassLayout.parseInstance(obj).toPrintable());

在这里插入图片描述

这里的线程ID是操作系统设置的唯一标识，和Java设置的Thread-1之类的标识不通

禁用偏向锁
```
-XX:-UseBiasedLocking
```

撤销偏向锁

撤销偏向锁会使其升级为轻量级锁/重量级锁
偏向锁重偏向是更改偏向的线程

1. 调用hashCode

log.debug(ClassLayout.parseInstance(obj).toPrintable());
obj.hashCode();
synchronized (obj){
    log.debug(ClassLayout.parseInstance(obj).toPrintable());
}
log.debug(ClassLayout.parseInstance(obj).toPrintable());

调用hashCode会禁用掉偏向锁，直接使用重量级锁，上述代码后3位执行时从101 --> 000 -> 001

轻量级锁和重量级锁调用hashCode之后不会出现这个问题
轻量级锁的hashCode会存在Lork Record里面，重量级锁会存在Monitor里面，可以反复交换
偏向锁的Mark Word，只能一个数据覆盖一个另一个

2. 其他线程使用对象

当有其他线程使用偏向锁对象时，偏向锁会升级为轻量级锁，后3位从 101 变为 000

即便不竞争，两个线程以先后顺序访问锁对象，都会导致偏向锁升级为轻量级锁
如果存在竞争，则进一步升级为重量级锁

3. 调用wait/notify

wait和notify只有重量级锁才有，因此调用时需要先升级为重量级锁

批量重偏向和批量撤销

输出JVM的默认参数值

-XX:+PrintFlagsFinal

批量重偏向

重定向即更改偏向锁指向的Thread，且并不会升级为其他锁

设置偏向锁批量重偏向阈值：

-XX:BiasedLockingBulkRebiasThreshold = 20

上面的命令代表：当撤销重定向的次数达到20次时，jvm就认为偏向错误，于是更改偏向的线程

举例：https://blog.csdn.net/weixin_33255691/article/details/114770537

线程1：初始时，获取了50个锁对象，于是这50个锁对象都是偏向锁
线程1：运行结束，释放锁资源（此时这50个锁对象都偏向线程1）
线程2：需要用到线程1使用过的前30个锁对象，根据撤销偏向锁里介绍的，锁会升级为轻量级锁
最终结果
- 前19个锁对象升级成为轻量级锁
- 第20~30个锁对象更改偏向对象，偏向线程2
- 第31~40个锁对象未更改，仍偏向线程1

批量撤销

当撤销偏向锁阈值达到40次之后，jvm就认为根本不该偏向，于是整个类的所有对象都变为不可偏向，新建的锁对象也变为不可偏向

默认偏向锁批量撤销阈值：

-XX:BiasedLockingBulkRevokeThreshold  = 40

在同一次运行中，一个对象最多重偏向1次，第2次重偏向时会变为000轻量级锁

举例

线程1：初始时，获取了60个锁对象，于是这60个锁对象都是偏向锁
- 第1-60个：偏向1
线程2：对这60个锁对象再次加锁
- 前1-19个：变为轻量级锁
- 第20-60个：偏向2
线程3：对第20-39个锁再次加锁
- 前1-19个：已经是轻量级锁，所以这里没有使用它们
- 第20-39：轻量级锁
之后创建的新锁：000（无锁状态，不可加锁）

@Slf4j(topic = "c.test")
public class ConcurrentApplication {
    static Thread t1, t2, t3;
    public static void main(String[] args) throws InterruptedException {

        Vector<Dog> locks = new Vector<>();
        //线程1：使得60个锁对象成为偏向锁
        t1 = new Thread(()->{
            for(int i=0; i<60; ++i){
                Dog obj = new Dog();
                locks.add(obj);
                synchronized (obj){
                    if(i == 18){
                        //打印线程1关键节点的锁对象状态
                        log.debug("线程1：第 {} 个锁对象的对象头：{}", i+1, ClassLayout.parseInstance(locks.get(i)).toPrintable());
                    }
                }
            }
            LockSupport.unpark(t2);
        }, "t1");
        t1.start();
        //线程2：撤销前60个锁对象
        t2 = new Thread(()->{
            LockSupport.park();
            for(int i=0; i<60; ++i){
                Dog obj = locks.get(i);
                synchronized (obj){
                    if(i == 18 || i==19 || i==38 || i==39 || i==58 || i==59){
                    //if(i == 18 || i==19){
                        //打印线程2关键节点的锁对象状态
                        log.debug("线程2：第 {} 个锁对象的对象头：{}", i+1, ClassLayout.parseInstance(locks.get(i)).toPrintable());
                    }
                }
            }
            LockSupport.unpark(t3);
        }, "t2");
        t2.start();
        //线程3：撤销前20~40个锁对象
        t3 = new Thread(()->{
            LockSupport.park();
            for(int i=20; i<39; ++i){
                Dog obj = locks.get(i);
                synchronized (obj){
                    if(i == 18 || i==19 || i==38 || i==39 || i==58 || i==59){
                    //if(i == 18 || i==19){
                        //打印线程3：关键节点的锁对象状态
                        log.debug("线程3：第 {} 个锁对象的对象头：{}", i+1, ClassLayout.parseInstance(locks.get(i)).toPrintable());
                    }
                }
            }
        }, "t3");
        t3.start();
        t3.join();
        log.debug("新的锁对象的对象头：{}", ClassLayout.parseInstance(new Dog()).toPrintable());
    }
}

只能重偏向一次，2次重偏向的话会升级成轻量级锁，并且释放锁之后变成不可偏向

疑惑：
根据实验结果，t1获取100个锁，t2重偏向这100个锁，最终新的对象也不会出现不可加锁状态
考虑这种结论：所谓批量撤销阈值达到40，是否是指二次偏向的阈值达到20？

锁消除

锁消除是指对于被检测出不可能存在竞争的共享数据的锁进行消除，这是 JVM 即时编译器的优化

锁消除主要是通过逃逸分析来支持，如果堆上的共享数据不可能逃逸出去被其它线程访问到，那么就可以把它们当成私有数据对待，也就可以将它们的锁进行消除（同步消除：JVM 逃逸分析）

默认打开，设置关闭

-server -XX:+DoEscapeAnalysis -XX:+EliminateLocks

然后在打开/关闭的状态下依次测试下列代码

public static String getString(String s1, String s2) {
    StringBuffer sb = new StringBuffer();
    sb.append(s1);
    sb.append(s2);
    return sb.toString();
}

public static void main(String[] args) {
    long tsStart = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
        getString("TestLockEliminate ", "Suffix");
    }
    System.out.println("一共耗费：" + (System.currentTimeMillis() - tsStart) + " ms");
}

append是一个synchronized代码，但这里的 sb 是一个局部变量，因此会被 JIT 即时编译器优化

3. 同步

3.1 wait notify

底层原理

Owner 线程发现条件不满足，调用 wait 方法，即可进入 WaitSet 变为 WAITING 状态
BLOCKED 和 WAITING 的线程都处于阻塞状态，不占用 CPU 时间片
BLOCKED 线程会在 Owner 线程释放锁时唤醒
WAITING 线程会在 Owner 线程调用 notify 或 notifyAll 时唤醒，唤醒后并不意味者立刻获得锁，需要进入 EntryList 重新竞争
调用wait()之后会释放占用的锁资源

API

obj.wait() 让进入 object 监视器的线程到 waitSet 等待（wait()时会释放锁）
obj.wait(n) 无参wait实际上是调用了wait(0)，带参是有时限的等待
obj.notify() 在 object 上正在 waitSet 等待的线程中挑一个唤醒
obj.notifyAll() 让 object 上正在 waitSet 等待的线程全部唤醒

必须获得此对象的锁，才能调用这几个方法

new Thread(() -> {
    synchronized (obj) {
        try {
            obj.wait(); // 让线程在obj上一直等待下去
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}).start();

sleep(long n) 和 wait(long n) 的区别

sleep 是 Thread 方法，而 wait 是 Object 的方法
sleep 不需要强制和 synchronized 配合使用，但 wait 需要和 synchronized 一起用
sleep 在睡眠的同时，不会释放对象锁的，但 wait 在等待的时候会释放对象锁
共同点：它们状态都将成为 TIMED_WAITING

wait()的使用方法

synchronized(lock){
    while(条件不成立){
        lock.wait()
    }
}
//另一个线程
synchronized(lock){
    lock.notifyAll();
}

3.2 同步模式之保护性暂停

一对一模型

Guarded Suspension

即 Guarded Suspension，用在一个线程等待另一个线程的执行结果

有一个结果需要从一个线程传递到另一个线程，让他们关联同一个 GuardedObject
如果有结果不断从一个线程到另一个线程那么可以使用消息队列（见生产者/消费者）
JDK 中，join 的实现、Future 的实现，采用的就是此模式
因为要等待另一方的结果，因此归类到同步模式

public static void main(String[] args) {
    GuardObject guardObject = new GuardObject();
    new Thread(() -> {
        log.debug("等待结果");
        List<String> list = (List<String>) guardObject.get();
        //list.stream().map(String::toUpperCase).forEach(log::debug);
        log.debug(Arrays.toString(list.toArray()));
    }, "t1").start();
    new Thread(() -> {
        log.debug("执行下载");
        sleep(2);//模拟下载时间
        List<String> list = new ArrayList<String>(){{add("one"); add("two");}};
        guardObject.complete(list);
    }).start();
}

class GaurdObject{
    private Object response;
    private final Object lock = new Object();
    //获取结果response
    //通过while和wait不断询问结果准备好了没
    public Object get(){
        synchronized (lock){
            while(response == null){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return response;
        }
    }
    public void complete(Object response){
        synchronized (lock){
            this.response = response;
            lock.notifyAll();
        }
    }
}

带时限的等待

public Object get(long timeout){
    synchronized (this){
        long begin = System.currentTimeMillis();
        long passedTime = 0;
        while(response == null){
            long waitTime = timeout - passedTime;
            if(waitTime <= 0) break;
            try {
                //this.wait(timeout);//假设timeout是2秒，在这里虚假唤醒，下一次循环时剩下wait时间应当是1秒而非2秒
                this.wait(waitTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            passedTime = System.currentTimeMillis() - begin;
        }
        return response;
    }
}

join 原理

join实际上是通过wait实现的

public final synchronized void join(long millis) throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;

    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (millis == 0) {
        while (isAlive()) {//判断线程是否存活
            wait(0);//相当于wait()，无限等待
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

多任务版 Guard Suspension

在这里插入图片描述

解耦结果生产者和结果等待者

流程说明

每个居民开启一个线程，申请一个GuardObject对象，然后调用对象的get方法等待邮递员线程工作
每个邮递员开启一个线程，获取信箱里所有的GuardObject的id，并根据id设置送信内容mail
邮递员根据id获取居民申请的GuardObject对象，然后将mail传进去并唤醒所有居民
每个居民被唤醒后去检查自己的response是否为空，从而完成收信

//一一对应的模式
package com.example;

@Slf4j(topic = "c.Test")
public class ConcurrentApplication{
    public static void main(String[] agrs){
        //各个居民只需开启收信功能
        for(int i=0; i<3; ++i){
            new People().start();//等待送信
        }
        TimeUnit.SECONDS.sleep(1);
        //邮递员依次检查信箱是否有信要送：这里设置的是每个居民有一个信箱，而有多少个信件就雇佣多少个邮递员
        for(Integer id : MailBoxes.getIds()){
            new Postman(id, "message"+id).start();
        }
    }
}

//居民
@Slf4j(topic = "c.People")
class People extends Thread{
    @Override
    public void run() {
        GuardObject guardObject = MailBoxes.createGuardObject();
        Object mail = guardObject.get(5000);
        log.debug("居民 {} 收到了信件 {}", guardObject.getId(), mail);
    }
}

//邮递员
@Slf4j(topic = "c.Postman")
class Postman extends Thread{
    private int id;
    private String mail;
    //Postman去信箱里获取送信地址（id）和送信内容（mail）
    public Postman(int id, String mail){this.id =id; this.mail = mail;}
    @Override
    public void run() {
        log.debug("邮递员发现了居民{}的信件，内容为：{}", id, mail);
        GuardObject guardObject = MailBoxes.getGuardObject(id);
        guardObject.complete(mail);
        log.debug("已向居民{}送信，内容为：{}", guardObject.getId(), mail);
    }
}

//解耦类：信箱
class MailBoxes{
    private static Map<Integer, GuardObject> boxes = new HashMap<>();
    private static int id;

    public static synchronized int generateId(){ return id++;}
    public static GuardObject createGuardObject(){
        GuardObject guardObject = new GuardObject(generateId());
        boxes.put(guardObject.getId(), guardObject);
        return guardObject;
    }
    public static GuardObject getGuardObject(int id){
        return boxes.remove(id);
    }
    public static Set<Integer> getIds(){
        return boxes.keySet();
    }
}

class GuardObject{
    private int id;
    public GuardObject(int id){this.id = id;}
    public int getId() {return id;}

    private Object response;
    public Object get(long timeout){
        synchronized (this){
            long begin = System.currentTimeMillis();
            long passTime = 0;
            while (response == null){
                long waitTime = timeout - passTime;
                if(waitTime <= 0) break;
                try {
                    this.wait(waitTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                passTime = System.currentTimeMillis() - begin;
            }
            return response;
        }
    }
    public void complete(Object response){
        synchronized (this){
            this.response = response;
            this.notifyAll();
        }
    }
}

结果

15:49:58.820 [Thread-7] DEBUG c.Postman - 邮递员发现了居民2的信件，内容为：message2
15:49:58.820 [Thread-5] DEBUG c.Postman - 邮递员发现了居民0的信件，内容为：message0
15:49:58.820 [Thread-6] DEBUG c.Postman - 邮递员发现了居民1的信件，内容为：message1
15:49:58.823 [Thread-7] DEBUG c.Postman - 已向居民2送信，内容为：message2
15:49:58.823 [Thread-5] DEBUG c.Postman - 已向居民0送信，内容为：message0
15:49:58.823 [Thread-2] DEBUG c.People - 居民 0 收到了信件 message0
15:49:58.823 [Thread-3] DEBUG c.People - 居民 2 收到了信件 message2
15:49:58.823 [Thread-6] DEBUG c.Postman - 已向居民1送信，内容为：message1
15:49:58.823 [Thread-1] DEBUG c.People - 居民 1 收到了信件 message1

3.3 同步模式之生产者/消费者

n对n模型

Guarded Suspension是通过wait使自己处于阻塞状态来等待收信，是典型的同步模式
注意：在课程中说生产者/消费者是异步模型，但鉴于wait仍需阻塞等待，这里个人理解将其归于同步模型

与前面的保护性暂停中的 GuardObject 不同，不需要产生结果和消费结果的线程一一对应
消费队列可以用来平衡生产和消费的线程资源
生产者仅负责产生结果数据，不关心数据该如何处理，而消费者专心处理结果数据
消息队列是有容量限制的，满时不会再加入数据，空时不会再消耗数据
JDK 中各种阻塞队列，采用的就是这种模式
生产者/消费者是在java线程间通信，而非进程间通信

package com.example;

@Slf4j(topic = "c.Test")
public class ConcurrentApplication{
    public static void main(String[] agrs){
        //先创建一个消息队列
        MessageQueue queue = new MessageQueue(2);
        //模拟3个生产者和1个消费者线程的情况
        for(int i=0; i<3; ++i){
            int finalI = i;
            new Thread(()->{
                //匿名内部类引用的局部变量应当声明为final
                queue.put(new Message(finalI, "message"+ finalI));
            }, "生产者"+i).start();
        }
        new Thread(()->{
            while(true){
                TimeUnit.SECONDS.sleep(1);//每隔1秒取一次消息
                Message message = queue.take();
            }
        }, "消费者").start();
    }
}

//消息队列类，java线程之间通信
@Slf4j(topic = "c.MessageQueue")
class MessageQueue{
    private LinkedList<Message> list = new LinkedList<>();//创建一个双向队列，作为消息的队列集合
    private int capacity;//消息队列容量
    public MessageQueue(int capacity){this.capacity=capacity;}
    //1. 获取消息
    public Message take(){
        //检查队列是否为空
        synchronized (list){
            while(list.isEmpty()){
                log.debug("队列为空！请消费者线程等待！");
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //从队列头部获取消息
            Message message = list.removeFirst();
            log.debug("取出消息 {}， 此时容量为：{}", message.getId(), list.size());
            list.notifyAll();
            return message;
        }
    }
    //2. 存入消息
    public void put(Message message){
        synchronized (list){
            //检查队列是否已满
            while(list.size() == capacity){
                log.debug("队列已满！请生产者线程等待！");
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            list.addLast(message);
            log.debug("存入消息 {}，此时容量为：{}", message.getId(), list.size());
            list.notifyAll();
        }
    }
}
//消息结构
class Message{
    private int id;
    private Object value;
    public Message(int id, Object value) {
        this.id = id;
        this.value = value;
    }
    public int getId() {
        return id;
    }
    public Object getValue() {
        return value;
    }
}

结果

16:29:26.626 [生产者0] DEBUG c.MessageQueue - 存入消息 0，此时容量为：1
16:29:26.628 [生产者2] DEBUG c.MessageQueue - 存入消息 2，此时容量为：2
16:29:26.628 [生产者1] DEBUG c.MessageQueue - 队列已满！请生产者线程等待！
16:29:27.628 [消费者] DEBUG c.MessageQueue - 取出消息 0， 此时容量为：1
16:29:27.629 [生产者1] DEBUG c.MessageQueue - 存入消息 1，此时容量为：2
16:29:28.631 [消费者] DEBUG c.MessageQueue - 取出消息 2， 此时容量为：1
16:29:29.640 [消费者] DEBUG c.MessageQueue - 取出消息 1， 此时容量为：0
16:29:30.645 [消费者] DEBUG c.MessageQueue - 队列为空！请消费者线程等待！

3.4 pack和unpack

基本使用

LockSupport.park();// 暂停当前线程
LockSupport.unpark(线程);// 恢复某个线程的运行

特点

与 Object 的 wait & notify 相比，不同点

wait，notify 和 notifyAll 必须配合 Object Monitor 一起使用，而 park，unpark 不必
park & unpark 是以线程为单位来【阻塞】和【唤醒】线程，而 notify 只能随机唤醒一个等待线程，notifyAll
是唤醒所有等待线程，就不那么精确
park & unpark 可以先 unpark，而 wait & notify 不能先 notify

相同点

park()之后也会进入无时限Waiting状态

原理

每个线程都有自己的一个Parker对象，由三部分组成：

_counter：标识，0标识线程已被阻塞，1表示未被阻塞

_cond：阻塞队列

_mutex：

park()
1. 当前线程调用 Unsafe.park() 方法
2. 设置_counter=0
3. 检查 _counter 的前值
  - 如果前值=0，获取 _mutex 互斥锁，线程进入 _cond 条件变量阻塞
  - 如果前值=1，继续运行
unpark()
1. 调用 Unsafe.unpark(Thread_0) 方法，
2. 设置_counter=1
3. 检查 _counter 的前值
  - 如果前值=0，获取_mutex互斥锁，将线程从_cond阻塞队列中将他唤醒
  - 如果前值=1，继续运行

3.5 线程状态

从操作系统层面来看有五种状态：

初始状态：仅是在语言层面创建了线程对象，还未与操作系统线程关联
可运行状态：（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行
运行状态：指获取了 CPU 时间片运行中的状态
阻塞状态：如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU
终止状态：表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态

线程中Java API（Thread.state）定义了六种状态：

NEW：线程刚被创建，但是还没有调用 start() 方法
RUNNABLE：当调用了 start() 方法之后
- Java API 层面的 RUNNABLE 状态涵盖了操作系统层面的【可运行状态】、【运行状态】和【阻塞状态】
- 由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为是可运行
BLOCKED：【阻塞状态】的细分；
- 如等待未被释放的锁
WAITING ：【阻塞状态】的细分；
- 无时限的等待，如 t2.join()，但t2是一个死循环
TIMED_WAITING ：【阻塞状态】的细分；
- 有时限的等待，如 sleep(10000)
TERMINATED：当线程代码运行结束

3.6 线程状态的转换

以 t 表示线程t
以 obj 表示synchronized之后获取的锁对象

new --> runnable
```
t.start()
```

runnable <–> waiting

obj.wait()

- obj.wait()	
	runnable --> waiting
- obj.notify(), obj.notifyAll(), t.interrupt()
	竞争锁成功：waiting --> runnable
	竞争锁失败：waiting --> blocked

t.join()

- t.join()
	runnable --> waiting（注意是当前线程在t线程对象的监视器上等待）
- t.interrupt()
	打断join：waiting --> runnable

park() 和 unpark()

- LockSupport.park()
	runnable --> waiting
- LockSupport.unpark() 或 t.interrupt()
	waiting --> runnable

runnable <–> timed_waiting

obj.wait(long n)

- obj.wait(long n)
	runnable --> timed_waiting
- 时间超过n，obj.notify(), obj.notifyAll(), t.interrupt()
	竞争锁成功：waiting --> runnable
	竞争锁失败：waiting --> blocked

t.join(long n)

- t.join(long n)
	runnable --> timed_waiting（注意是当前线程在t线程对象的监视器上等待）
- 时间超过n，t线程结束，interrupt
	timed_waiting --> runnable

Thread.sleep(long n)

- Thread.sleep(long n)
	runnable --> timed_waiting
- 时间超过n
	timed_waiting --> runnable

parkNanos(long nanos) 和 parkUntil(long millis)

- LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long millis)
	runnable --> timed_waiting
- LockSupport.unpark(目标线程)，interrupt()，等待超时
	timed_waiting --> runnable

runnable <–> blocked

竞争锁失败

- synchronized(obj)失败
	runnable --> blocked
- 锁被释放时会唤醒该对象上所有的BLOCKED线程，如果竞争成功
	blocked --> running

runnable --> terminated
- 当前线程的所有代码运行完毕后

一、Java并发编程之线程、synchronized

文章目录

1. Java线程

1.1 创建和运行线程

方法一：Thread

方法二：Runnable（推荐）

lambda精简

Thread和runnable原理

方法三：FutureTask配合Thread

1.2 查看进程和线程的方法

1.3 线程运行原理

栈与栈帧

线程上下文切换

1.4 线程常见方法

方法概述

start() 和 run()

sleep() 和 yield()

join()

interrupt()

过时方法

主线程和守护线程

1.5 终止模式之两阶段终止模式

1.6 应用 - 防止CPU占用100%（sleep）

1.7 习题：烧水泡茶多线程方案

1.8 小结

2. 并发共享模型之管程 (悲观锁)

2.1 synchronized 解决方案

面向过程

改进：面向对象

方法上的synchronized

习题：线程八锁

2.2 线程安全分析

成员变量的线程不安全

局部变量是线程安全的

局部变量的线程不安全

2.3 常见线程安全类

2.4 习题

线程安全性判断

练习：卖票

*练习：转账

2.5 Monitor

Java对象头

Monitor（锁）

synchronized原理

synchronized优化：多种锁

轻量级锁

锁膨胀

自旋优化

偏向锁

撤销偏向锁

批量重偏向和批量撤销

锁消除

3. 同步

3.1 wait notify

3.2 同步模式之保护性暂停

Guarded Suspension

join 原理

多任务版 Guard Suspension

3.3 同步模式之生产者/消费者

3.4 pack和unpack

3.5 线程状态

3.6 线程状态的转换

相关文章