黑马课程
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());//{}是占位符
}
}
FutureTask
可以有返回值，线程 t2 调用task.get()时，如果任务没有执行完，当前线程 t2 阻塞
- Runnable是没有返回值的，Callable有，但Thread只能接收Runnable接口的
- 在不修改Callable接口的基础上，想要将它用到Thread上，就可以通过FutureTask对它进行一个封装。FutureTask类实现了Runnable接口的。它会调用run方法，然后在run方法里面调用call方法，并将结果封装到一个outcome变量里面，通过get可以获取
- FutureTask对象其实只被执行了一次，在初始化时会将state变量设置为New，第一次执行后（run方法）会通过CAS操作更改state的值，并将结果封装到outcome变量。之后执行发现不为NEW了，就直接返回
- 在
thread.start()之后直接使用task.get()，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
-
调用 sleep 会让当前线程从
Runnable进入Timed Waiting状态（阻塞） -
其它线程可以使用
interrupt方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedExceptiont1.interrupt();//叫醒t1线程 -
睡眠结束后的线程未必会立刻得到执行（可能cpu正忙）
-
建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性
TimeUnit.SECONDS.sleep(2);//睡眠2秒
-
-
yield
- 调用 yield 会让当前线程从
Running运行状态进入Ready就绪状态，然后调度执行其它线程
Runnable包括 Running(运行) 和 Ready(就绪) 2种状态 - 具体的实现依赖于操作系统的任务调度器
- 调用 yield 会让当前线程从
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) 方法停止线程
- 目的仅是停止一个线程，但这种做法会让整个程序都停止
两阶段终止
用线程 t2 去终止线程 t1
- 第一阶段：t2 向 t1 发送终止指令，即调用 t1.interrupt()
- 第二阶段：t1 检测到中断标志位为true之后，就开始料理后事。如果 t1 被打断时正处于 sleep 状态，还需要自己调用一次 interrupt() 将标志位设置为 true
应用示例
需求：每隔一段时间打印监控数据
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，对a账户的setMoney加锁；准备调用b账户的setMoney
- 线程B：b.transfer，对b账户加锁；调用this.setMoney，对b账户的setMoney加锁；准备调用a账户的setMoney，发现它已被线程A加锁，于是等待线程A释放setMoney的锁
- 线程A：b账户的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 bitsKlass Word占 32 bitsarray 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 状态的线程
当竞争锁失败时会进入Monitor的EntryList，此时为Blocked状态
如果是主动调用wait，进入的是Monitor的WaitSet，此时是Waiting状态
- 调用 wait 时，转为 waiting 状态，被 notify 唤醒后竞争锁，失败后会进入blocked状态
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()
- 当前线程调用 Unsafe.park() 方法
- 设置
_counter=0 - 检查 _counter 的前值
- 如果
前值=0，获取 _mutex 互斥锁，线程进入 _cond 条件变量阻塞 - 如果
前值=1，继续运行
- 如果
-
unpark()
- 调用 Unsafe.unpark(Thread_0) 方法，
- 设置
_counter=1 - 检查 _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
- 当前线程的所有代码运行完毕后
扫一扫
590
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
