大气蓝色企业网站模板/seo排名策略

黑马课程

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(){@Overridepublic 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() {@Overridepublic 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的私有变量targetprivate void init(ThreadGroup g, Runnable target, String name,long stackSize, AccessControlContext acc,boolean inheritThreadLocals) {...this.target = target;...}//4. 根据私有变量target是否为空，选择是否执行target方法@Overridepublic 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>() {@Overridepublic 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;}
}

栈帧

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

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

多线程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"){@Overridepublic 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 interruptedat 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 interruptedat 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{@Overridepublic 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-5static 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账户 = 2000log.debug("total: {}", (a.getMoney()+b.getMoney()));}//随机1-5static 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_110: iadd11: putstatic     #314: aload_1							// 即将离开临界区，此时先从 slot 1 拿到之前存储的lock引用15: monitorexit						// 将lock对象 Mark Word 重置（原信息保存在monitor中），唤醒 EntryList16: goto          24					// 跳转到24行，结束执行19: astore_2							// 从这里开始处理异常情况：将异常对象e存储到 slot 2中20: aload_1							// 出现异常以至于未能释放锁：此时也能获取到锁21: monitorexit						// 将lock对象 Mark Word 重置（原信息保存在monitor中），唤醒 EntryList22: aload_2							// 获取到异常对象e23: athrow							// 抛出异常 throw e24: returnException table:						// 监控6到16行，即synchronized部分，如果出现异常，跳转到19行from    to  target type6    16    19   any19    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){//同步块 Amethod2();}
}
public static void method2(){synchronized (obj){//同步块 B}
}

上面代码的工作原理：

1. 创建锁记录对象（Lock Record Object），每个线程都有一个锁记录结构，如果需要加锁就在当前栈帧中新建一个锁记录对象。该对象包含以下内容：

   • 锁记录地址和状态：地址表示锁记录对象自身地址，00表示初始状态为轻量级锁
   • Object reference：存储要锁对象（即代码中的 obj ）的引用地址

2. 锁记录对象中的Object reference指向锁对象，同时通过CAS操作（一种原子操作）尝试将自己的 lock record 地址 00 和 锁对象的 Mark Word 01 交换

   • 此时锁对象Mark Word就成了状态00，即表示处于轻量级锁状态，同时还存储了锁记录对象的地址
   • 锁记录对象也成功存储了锁对象的Mark Word内容，以便之后恢复
   • 交换成功，即加锁成功（其他线程访问锁对象，发现其状态已经是轻量级锁状态00，说明该锁已被其他对象使用，CAS失败）

3. 如果CAS失败，检查锁对象指向的地址是否在本线程的栈帧范围内：

   • 如果不是当前线程对其加锁，那么表示有竞争，将进入锁膨胀阶段
   • 如果是当前线程，那就是 synchronized锁重入 （如代码中的method2），于是再添加一个Lock Record对象作为重入的计数
     重入的Lock Record对象无需记录 Mark Word，只需记录锁对象的地址

   

4. 解锁

   • 锁记录的值为null：说明有重入，删除null的锁记录对象即可
   • 锁记录的值不为null：CAS操作恢复自己的Mark Word
     • 成功：解锁成功
     • 失败：说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程

锁膨胀

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

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

1. Thread-1希望获取锁对象 obj ，执行CAS操作，尝试将自己栈帧中的锁记录对象与锁对象obj的Mark Word进行交换时，发现锁对象状态已经是 00 轻量级锁状态，于是加锁失败，进行锁膨胀
2. 锁膨胀流程
   • Thread-1为 锁对象obj 申请Monitor锁，让 obj 指向重量级锁地址，更改状态为 10
   • Thread-1自身进入Monitor的EntryList BLOCKED
3. 当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{@Overridepublic 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;}@Overridepublic 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(()->{//匿名内部类引用的局部变量应当声明为finalqueue.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线程结束，interrupttimed_waiting --> runnable
    

  • Thread.sleep(long n)

    - Thread.sleep(long n)runnable --> timed_waiting
    - 时间超过ntimed_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

  • 当前线程的所有代码运行完毕后