第三章 - 共享模型之管程(一)

本章内容

  • 共享问题
  • synchronized
  • 线程安全分析
  • Monitor
  • wait/notify
  • 线程状态转换
  • 活跃性
  • Lock

共享带来的问题

小故事

  • 老王(操作系统)有一个功能强大的算盘(CPU),现在想把它租出去,赚一点外快

第三章 - 共享模型之管程(一)_juc

  • 小南、小女(线程)来使用这个算盘来进行一些计算,并按照时间给老王支付费用
  • 但小南不能一天24小时使用算盘,他经常要小憩一会(sleep),又或是去吃饭上厕所(阻塞 io 操作),有时还需要一根烟,没烟时思路全无(wait)这些情况统称为(阻塞)

第三章 - 共享模型之管程(一)_java_02

  • 在这些时候,算盘没利用起来(不能收钱了),老王觉得有点不划算
  • 另外,小女也想用用算盘,如果总是小南占着算盘,让小女觉得不公平
  • 于是,老王灵机一动,想了个办法 [ 让他们每人用一会,轮流使用算盘 ]
  • 这样,当小南阻塞的时候,算盘可以分给小女使用,不会浪费,反之亦然
  • 最近执行的计算比较复杂,需要存储一些中间结果,而学生们的脑容量(工作内存)不够,所以老王申请了一个笔记本(主存),把一些中间结果先记在本上
  • 计算流程是这样的

第三章 - 共享模型之管程(一)_多线程_03

  • 但是由于分时系统,有一天还是发生了事故
  • 小南刚读取了初始值 0 做了个 +1 运算,还没来得及写回结果
  • 老王说 [ 小南,你的时间到了,该别人了,记住结果走吧 ],于是小南念叨着 [ 结果是1,结果是1…] 不甘心地到一边待着去了(上下文切换)
  • 老王说 [ 小女,该你了 ],小女看到了笔记本上还写着 0 做了一个 -1 运算,将结果 -1 写入笔记本
  • 这时小女的时间也用完了,老王又叫醒了小南:[小南,把你上次的题目算完吧],小南将他脑海中的结果 1 写入了笔记本

第三章 - 共享模型之管程(一)_java_04

  • 小南和小女都觉得自己没做错,但笔记本里的结果是 1 而不是 0

由故事引发的Java代码的体现

两个线程对初始值为 0 的静态变量一个做自增,一个做自减,各做 5000 次,结果是 0 吗?

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

public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 5000; i++) {
count++;
}
}, "t1");

Thread t2 = new Thread(() -> {
for (int i = 0; i < 5000; i++) {
count--;
}
}, "t2");

t1.start();
t2.start();
t1.join();
t2.join();
log.debug("{}", count);
}

}

程序运行结果不唯一:

第三章 - 共享模型之管程(一)_synchronized_05

第三章 - 共享模型之管程(一)_juc_06

第三章 - 共享模型之管程(一)_多线程_07

问题分析

  • 以上的结果可能是正数、负数、零。为什么呢?因为 Java 中对静态变量的自增,自减并不是原子操作,要彻底理解,必须从字节码来进行分析
  • 例如对于 i++ 而言(i 为静态变量),实际会产生如下的 JVM 字节码指令:

第三章 - 共享模型之管程(一)_juc_08

  • 而对应 i-- 也是类似:

第三章 - 共享模型之管程(一)_多线程_09

  • 而 Java 的内存模型如下,完成静态变量的自增,自减需要在主存和工作内存中进行数据交换:

第三章 - 共享模型之管程(一)_线程安全_10

线程1从主内存把i的值读取进来,然后进行i++,再把i的值存入主内存

线程2从主内存把i的值读取进来,然后进行i–,再把i的值存入主内存

  • 如果是单线程以上 8 行代码是顺序执行(不会交错)没有问题:

第三章 - 共享模型之管程(一)_线程安全_11

但多线程下这 8 行代码可能交错运行:

  • 出现负数的情况:

第三章 - 共享模型之管程(一)_java_12

  • 出现正数的情况:

第三章 - 共享模型之管程(一)_juc_13

临界区 Critical Section

  • 一个程序运行多个线程本身是没有问题的
  • 问题出在多个线程访问共享资源
  • 多个线程读共享资源其实也没有问题
  • 在多个线程对共享资源读写操作时发生指令交错,就会出现问题
  • 一段代码块内如果存在对共享资源的多线程读写操作,称这段代码块为临界区

例如,下面代码中的临界区

static int counter = 0;

static void increment()
// 临界区
{
counter++;
}

static void decrement()
// 临界区
{
counter--;
}

竞态条件 Race Condition

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

synchronized 解决方案

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

  • 阻塞式的解决方案:synchronized,Lock
  • 非阻塞式的解决方案:原子变量

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

注意

虽然 java 中互斥和同步都可以采用 synchronized 关键字来完成,但它们还是有区别的:

  1. 互斥是保证临界区的竞态条件发生,同一时刻只能有一个线程执行临界区代码
  2. 同步是由于线程执行的先后、顺序不同、需要一个线程等待其它线程运行到某个点

synchronized

语法

synchronized(对象) // 线程1, 线程2(blocked)
{
临界区
}

解决

public class Test17 {
static int count = 0;
static final Object room = new Object();

public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 5000; i++) {
synchronized (room){
count++;
}
}
}, "t1");

Thread t2 = new Thread(() -> {
for (int i = 0; i < 5000; i++) {
synchronized (room){
count--;
}
}
}, "t2");

t1.start();
t2.start();
t1.join();
t2.join();
log.debug("{}", count);
}
}

无论运行多少次,结果都是 0

第三章 - 共享模型之管程(一)_多线程_14

synchronized 原理分析

第三章 - 共享模型之管程(一)_juc_15

可以做这样的类比:

  • ​synchronized(对象)​​中的对象,可以想象为一个房间(room),有唯一入口(门)房间只能一次进入一人进行计算,线程 t1,t2 想象成两个人
  • 当线程 t1 执行到​​synchronized(room)​​时就好比 t1 进入了这个房间,并锁住了门拿走了钥匙,在门内执行count++ 代码
  • 这时候如果 t2 也运行到了​​synchronized(room)​​ 时,它发现门被锁住了,只能在门外等待,发生了上下文切换,阻塞住了
  • 这中间即使 t1 的 cpu 时间片不幸用完,被踢出了门外(不要错误理解为锁住了对象就能一直执行下去哦),这时门还是锁住的,t1 仍拿着钥匙,t2 线程还在阻塞状态进不来,只有下次轮到 t1 自己再次获得时间片时才能开门进入
  • 当 t1 执行完​​synchronized{ }​​​ 块内的代码,这时候才会从 obj 房间出来并解开门上的锁,唤醒 t2 线程并把钥匙给他。t2 线程这时才可以进入 obj 房间,锁住了门拿上钥匙,执行它的​​count--​​ 代码

用图来表示

第三章 - 共享模型之管程(一)_juc_16

思考

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

为了加深理解,请思考下面的问题

  • 如果把 synchronized(obj) 放在 for 循环的外面,如何理解?-- 原子性
  • 对整个循环内5000次操作都上锁了。保证了原子性
  • 如果 t1 synchronized(obj1) 而 t2 synchronized(obj2) 会怎样运作?-- 锁对象
  • 对象不同,相当于拿到的锁不同,不能保证原子性。
  • 如果 t1 synchronized(obj) 而 t2 没有加会怎么样?如何理解?-- 锁对象
  • 对于同一个共享资源,所有对其的操作都要加锁,不然t1加锁,但是t2不加锁,那么t2运行到临界区时,就不会去尝试拿锁,自然不会被阻塞。

面向对象改进

把需要保护的共享变量放入一个类

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

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

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();
t1.join(); //等待t1线程结束
t2.join(); //等待t2线程结束
log.debug("{}", room.getCounter());
}

}

class Room {
private int counter = 0;

public void increment() {
synchronized (this) {
counter++;
}
}

public void decrement() {
synchronized (this) {
counter--;
}
}

public int getCounter() {
synchronized (this) {
return counter;
}
}

}

方法上的 synchronized

class Test{

public synchronized void test() {

}

}

// 等价于
class Test{

public void test() {
synchronized(this) { //锁住的是this对象

}
}

}
class Test{

public synchronized static void test() {

}

}

// 等价于
class Test{

public static void test() {
synchronized(Test.class) { //锁住的是Test类

}
}

}

不加 synchronized 的方法

不加 synchronzied 的方法就好比不遵守规则的人,不去老实排队(好比翻窗户进去的)

所谓的“线程八锁”

其实就是考察 synchronized 锁住的是哪个对象

情况1:12 或 21

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

public static void main(String[] args) {
Number n1 = new Number();

new Thread(() -> { //线程1
log.debug("begin");
n1.a();
}).start();

new Thread(() -> { //线程2
log.debug("begin");
n1.b();
}).start();
}

}

@Slf4j(topic = "c.Number")
class Number{

public synchronized void a() { //锁住的是this对象
log.debug("1");
}

public synchronized void b() { //锁住的是this对象
log.debug("2");
}

}

第三章 - 共享模型之管程(一)_java_17

情况2:​​1s后​​​ 1 2,或 2 ​​1s后​​ 1

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

public static void main(String[] args) {
Number n1 = new Number();

new Thread(() -> { //线程1
log.debug("begin");
n1.a();
}).start();

new Thread(() -> { //线程2
log.debug("begin");
n1.b();
}).start();
}

}

@Slf4j(topic = "c.Number")
class Number{

public synchronized void a() {
sleep(1);
log.debug("1");
}

public synchronized void b() {
log.debug("2");
}

}

第三章 - 共享模型之管程(一)_线程安全_18

第三章 - 共享模型之管程(一)_juc_19

  • a方法睡了1秒。
  • 可能是线程1先拿到锁,执行a方法,但是睡了1秒,然后打印1,接着线程2拿到锁马上打印2。所以结果 1s后 1 2
  • 可能线程2先拿到锁,执行b方法打印2,然后线程1拿到锁马上执行a方法,先睡1秒,然后打印1。所以结果2 1s后 1

情况3:3 ​​1s后​​​ 12 或 23 ​​1s后​​​ 1 或 32 ​​1s后​​ 1

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

public static void main(String[] args) {
Number n1 = new Number();

new Thread(() -> { //线程1
log.debug("begin");
n1.a();
}).start();

new Thread(() -> { //线程2
log.debug("begin");
n1.b();
}).start();

new Thread(() -> { //线程3
log.debug("begin");
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");
}

}

第三章 - 共享模型之管程(一)_线程安全_20

第三章 - 共享模型之管程(一)_线程安全_21

第三章 - 共享模型之管程(一)_多线程_22

  • c方法没有synchronized,不会被锁住,所以3一定会在1之前打印(因为1会先睡1秒)。
  • 打印2或3的顺序不一定,看谁先分到时间片执行

情况4:2 ​​1s后​​ 1

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

public static void main(String[] args) {
Number n1 = new Number();
Number n2 = new Number();

new Thread(() -> {
log.debug("begin");
n1.a();
}).start();

new Thread(() -> {
log.debug("begin");
n2.b();
}).start();

}

}

@Slf4j(topic = "c.Number")
class Number{

public synchronized void a() { //锁住的是this对象
sleep(1);
log.debug("1");
}

public synchronized void b() { //锁住的是this对象
log.debug("2");
}

}

第三章 - 共享模型之管程(一)_synchronized_23

  • 两个方法锁的不是同一个对象,线程1锁住的是n1对象,线程2锁住的是n2对象。
  • 由于线程1打印1之前始终要睡1s。而线程2由于不用等1的锁,所以可以直接打印2。所以始终是打印2的1s后打印1。

情况5:2 ​​1s后​​ 1

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

public static void main(String[] args) {
Number n1 = new Number();

new Thread(() -> {
log.debug("begin");
n1.a();
}).start();

new Thread(() -> {
log.debug("begin");
n1.b();
}).start();

}
}

@Slf4j(topic = "c.Number")
class Number{

public static synchronized void a() { //锁住的是Number类对象
sleep(1);
log.debug("1");
}

public synchronized void b() { //锁住的是this对象
log.debug("2");
}

}

第三章 - 共享模型之管程(一)_多线程_24

  • a方法是static静态方法,锁住的对象是Number.class
  • b方法是成员方法,锁住的对象的this
  • 两者锁的对象不同,所以两者是同时执行的,但由于a打印1之前始终要睡1s。所以结果为:2​​1s后​​ 1

情况6:​​1s后​​​12, 或 2 ​​1s后​​ 1

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

public static void main(String[] args) {
Number n1 = new Number();

new Thread(() -> {
log.debug("begin");
n1.a();
}).start();

new Thread(() -> {
log.debug("begin");
n1.b();
}).start();

}
}

@Slf4j(topic = "c.Number")
class Number{

public static synchronized void a() { //锁住的是Number类对象
sleep(1);
log.debug("1");
}

public static synchronized void b() { //锁住的是Number类对象
log.debug("2");
}

}

第三章 - 共享模型之管程(一)_java_25

第三章 - 共享模型之管程(一)_线程安全_26

  • a和b方法都是static静态方法,锁的对象都是Number.class
  • 所以两者拿的是同一把锁

情况7:2 ​​1s后​​ 1

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

public static void main(String[] args) {
Number n1 = new Number();
Number n2 = new Number();

new Thread(() -> {
log.debug("begin");
n1.a();
}).start();

new Thread(() -> {
log.debug("begin");
n2.b();
}).start();

}
}
@Slf4j(topic = "c.Number")
class Number{

public static synchronized void a() { //锁住的是Number类对象
sleep(1);
log.debug("1");
}

public synchronized void b() { //锁住的是this对象
log.debug("2");
}

}

第三章 - 共享模型之管程(一)_多线程_27

  • a方法的锁为Number.class
  • b方法的锁为n2对象
  • 两者的锁不同

情况8:​​1s后​​​12, 或 2 ​​1s后​​ 1

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

public static void main(String[] args) {
Number n1 = new Number();
Number n2 = new Number();

new Thread(() -> {
log.debug("begin");
n1.a();
}).start();

new Thread(() -> {
log.debug("begin");
n2.b();
}).start();

}
}
@Slf4j(topic = "c.Number")
class Number{

public static synchronized void a() { //锁住的是Number类对象
sleep(1);
log.debug("1");
}

public static synchronized void b() { //锁住的是Number类对象
log.debug("2");
}

}

第三章 - 共享模型之管程(一)_多线程_28

第三章 - 共享模型之管程(一)_juc_29

  • a方法的锁为Number.class,b方法的锁也为Number.class
  • 虽然是通过n1、n2两个不同的对象调用,但是类只有一种。所以还是同一把锁

变量的线程安全分析

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

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

局部变量是否线程安全?

  • 局部变量是线程安全的
  • 但局部变量引用的对象(也可以被其他引用)则未必
  • 如果该对象没有逃离方法的作用访问,它是线程安全的
  • 如果该对象逃离方法的作用范围,如return,需要考虑线程安全

局部变量线程安全分析

public static void test1() {
int i = 10;
i++;
}

每个线程调用 ​​test1( )​​ 方法时局部变量 i,会在每个线程的栈帧内存中被创建多份,因此不存在共享,局部变量是每个线程私有的

第三章 - 共享模型之管程(一)_java_30

如图:

第三章 - 共享模型之管程(一)_线程安全_31

局部变量的引用稍有不同,先看一个成员变量的例子

list是成员变量

public class TestThreadSafe {

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++) { //创建2个线程
new Thread(() -> {
test.method1(LOOP_NUMBER); //循环200次
}, "Thread" + (i+1)).start();
}

}

}

class ThreadUnsafe {

// 成员变量list
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); //往集合删除一个元素
}
}

其中一种情况是:线程2先抢到时间片执行method1,如果线程1 还未 add,线程2 remove 就会报错:

第三章 - 共享模型之管程(一)_线程安全_32

  • 无论哪个线程中的 method2 引用的都是堆中同一个对象中的 list 成员变量
  • method3 与 method2 分析相同

第三章 - 共享模型之管程(一)_synchronized_33

list 修改为局部变量

public class TestThreadSafe {

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++) { //创建2个线程
new Thread(() -> {
test.method1(LOOP_NUMBER); //循环200次
}, "Thread" + (i+1)).start();
}

}

}

class ThreadSafe {

public final void method1(int loopNumber) {
ArrayList<String> list = new ArrayList<>(); //局部变量list
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);
}
}

那么就不会有上述问题了

  • list 是局部变量,每个线程调用时会创建其不同的实例,没有共享
  • 而 method2 的参数是从 method1 中传递过来的,与 method1 中引用同一个对象
  • method3 的参数分析与 method2 相同

第三章 - 共享模型之管程(一)_线程安全_34

暴露list

方法访问修饰符带来的思考,如果把 method2 和 method3 的方法修改为 public 会不会代理线程安全问题?

  • 情况1:有其它线程调用 method2 和 method3
  • 其他线程调用method2,传过来的参数并不是method1的list,所以并不会产生线程安全问题
  • 情况2:在 情况1 的基础上,为 ThreadSafe 类添加子类,子类覆盖 method2 或 method3 方法,即
  • 子类重写method3后,线程1或者线程2来到重写的method3这里,会与线程3使用同一共享资源,所以可能会产生线程安全问题
public class TestThreadSafe {

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++) { //创建2个线程
new Thread(() -> {
test.method1(LOOP_NUMBER); //循环200次
}, "Thread" + (i+1)).start();
}

}

}

class ThreadSafe {

public void method1(int loopNumber) {
ArrayList<String> list = new ArrayList<>(); //局部变量list
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);
},"Thread3").start();
}

}

第三章 - 共享模型之管程(一)_线程安全_35

  • 从这个例子可以看出 private 或 final 提供【安全】的意义所在,请体会开闭原则中的【闭】
  • 可以给method1加上final防止被重写,给method2 和 method3加上private防止被子类重写
public class TestThreadSafe {

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++) { //创建2个线程
new Thread(() -> {
test.method1(LOOP_NUMBER); //循环200次
}, "Thread" + (i + 1)).start();
}

}

}

class ThreadSafe {

public final void method1(int loopNumber) {
ArrayList<String> list = new ArrayList<>(); //局部变量list
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);
}

}

class ThreadSafeSubClass extends ThreadSafe {

public void method3(ArrayList<String> list) {
new Thread(() -> {
list.remove(0);
}, "Thread3").start();
}

}
  • 加上private后,子类无法重写method3,子类的method3只是作为自己的一个成员方法。
  • 启动后线程1和线程2都会访问本类的method2和method3,所以各自有自己的局部变量list,也就不会存在共享资源,因此不会有线程安全问题

常见线程安全类

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

这里说它们是线程安全的是指,多个线程调用它们同一个实例的某个方法时,是线程安全的。也可以理解为

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

new Thread(()->{
table.put("key", "value2");
}).start();
  • 它们的每个方法是原子的(因为直接加了synchronized在方法上)
  • 注意它们多个方法的组合不是原子的,见后面分析

查看源码可以知道,Hashtable的put方法加上了synchronized

第三章 - 共享模型之管程(一)_java_36

线程安全类方法的组合

分析下面代码是否线程安全?

Hashtable table = new Hashtable();
// 线程1,线程2
if( table.get("key") == null) {
table.put("key", value);
}

第三章 - 共享模型之管程(一)_多线程_37

不可变类线程安全性

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

有同学或许有疑问,String 有 replace,substring 等方法【可以】改变值啊,那么这些方法又是如何保证线程安全的呢?

String的substring源码

第三章 - 共享模型之管程(一)_juc_38

第三章 - 共享模型之管程(一)_java_39

  • 直接new了一个新的String对象,保证原对象的不可变

实例分析

代码示例1

public class MyServlet extends HttpServlet {

// 是否安全?no HashTable才是线程安全的
Map<String,Object> map = new HashMap<>();
// 是否安全?yes
String S1 = "...";
// 是否安全?yes
final String S2 = "...";
// 是否安全?no
Date D1 = new Date();
// 是否安全?no
// D2的引用不会变,但是日期对象内的属性可以变
final Date D2 = new Date();

public void doGet(HttpServletRequest request, HttpServletResponse response) {
// 使用上述变量
}

}

代码示例2

public class MyServlet extends HttpServlet {

// 是否安全?no
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++;
}

}
  • userService为成员变量,是共享资源,多个线程调用会出现线程安全问题。

代码示例3

@Aspect
@Component
public class MyAspect {
// 是否安全?no
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));
}

}
  • spring中的对象,没有额外说明的话,都是单例的。说明这个类的对象会被共享,对象的成员变量也会被共享。
  • 解决方法,最好把前置、后置通知变为环绕通知,把成员变量做成局部变量。

代码示例4

public class MyServlet extends HttpServlet {

// 是否安全 yes
private UserService userService = new UserServiceImpl();
public void doGet(HttpServletRequest request, HttpServletResponse response) {
userService.update(...);
}

}

public class UserServiceImpl implements UserService {
// 是否安全 yes
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 = ?";
// 是否安全 yes
try (Connection conn = DriverManager.getConnection("","","")){
// ...
} catch (Exception e) {
// ...
}
}

}
  • UserDaoImpl是线程安全的,没有成员变量,资源变量Connection也是作为方法内局部变量出现
  • UserServiceImpl是线程安全的,成员变量UserDao是线程安全的,内部状态也不会改变。
  • UserService是线程安全的,并不会改变它的内部状态。

代码示例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 {
// 是否安全 no
private Connection conn = null;

public void update() throws SQLException {
String sql = "update user set password = ? where username = ?";
conn = DriverManager.getConnection("","","");
// ...
conn.close();
}
}
  • UserDaoImpl是线程不安全的,因为作为了成员变量,在多线程下,可能其中一个线程刚开启Connection,就被另一个给关了。
  • UserServiceImpl、UserService也变得线程不安全了。

代码示例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() {
UserDao userDao = new UserDaoImpl(); //局部变量
userDao.update();
}
}

public class UserDaoImpl implements UserDao {
// 是否安全
private Connection = null;
public void update() throws SQLException {
String sql = "update user set password = ? where username = ?";
conn = DriverManager.getConnection("","","");
// ...
conn.close();
}
}
  • 由于UserServiceImpl中每次都新创建userDao,且作为局部变量。而每次都创建新的,那么UserDaoImpl中的成员变量Connection也是新的。不会出现线程安全问题。
  • 但不建议这样写,建议把Connection变成局部变量,这样子才是最正确的做法

代码示例7

public abstract class Test {

public void bar() {
// 是否安全 no,虽然是局部变量,但是它在foo()里面作为参数可能会暴露给其他线程
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 的行为是不确定的,可能导致不安全的发生,被称之为外星方法
public void foo(SimpleDateFormat sdf) {
String dateStr = "1999-10-11 00:00:00";
for (int i = 0; i < 20; i++) {
new Thread(() -> {
try {
sdf.parse(dateStr);
} catch (ParseException e) {
e.printStackTrace();
}
}).start();
}
}
  • 不想暴露给外面使用的,建议都加上final或者private,这样子可以增强类的安全性

插播一道面试题

String类为什么要被设置成final的?

答:因为不设置成final,有可能被子类继承,破坏其中某个方法的行为

习题

卖票练习

测试下面代码是否存在线程安全问题,并尝试改正

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

public static void main(String[] args) throws InterruptedException {
// 模拟多人买票
TicketWindow window = new TicketWindow(1000);

// 所有线程的集合
List<Thread> threadList = new ArrayList<>();
// 卖出的票数统计,Vector是线程安全的
List<Integer> amountList = new Vector<>();
for (int i = 0; i < 2000; i++) {
Thread thread = new Thread(() -> {
// 买票
int amount = window.sell(random(5));
// 统计买票数
amountList.add(amount);
});
//虽然ArrayList是线程不安全的,但是这个threadList只被主线程使用
//不会被多个线程所共享,所以不用考虑线程安全问题
threadList.add(thread);
thread.start();
}

// 等待所有线程执行完成
for (Thread thread : threadList) {
thread.join();
}

// 统计卖出的票数和剩余票数
log.debug("余票:{}",window.getCount());
log.debug("卖出的票数:{}", amountList.stream().mapToInt(i-> i).sum());
}

// Random 为线程安全
static Random random = new Random();

// 随机 1~5
public static int random(int amount) {
return random.nextInt(amount) + 1;
}
}

// 售票窗口
class TicketWindow {
// 余票数量
private int count;

public TicketWindow(int count) {
this.count = count;
}

// 获取余票数量
public int getCount() {
return count;
}

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

第三章 - 共享模型之管程(一)_synchronized_40

  • 窗口是共享变量,所有线程都会访问,进行买票操作
// 模拟多人买票
TicketWindow window = new TicketWindow(1000);
  • sell操作中,涉及到余票变量的读写操作,属于临界区

第三章 - 共享模型之管程(一)_线程安全_41

第三章 - 共享模型之管程(一)_java_42

  • TicketWindow中的余票数count是共享变量

第三章 - 共享模型之管程(一)_synchronized_43

  • 每一个线程买票时,都是先读count,再修改count,在多线程情况下,容易发生指令交错,线程不安全

解决方法

  • 在sell方法上加synchronized,锁住TicketWindow的实例对象,也就是锁住count,就对count进行了保护,线程安全
// 售票
public synchronized int sell(int amount) {
if (this.count >= amount) {
this.count -= amount;
return amount;
} else {
return 0;
}
}

另外,用下面的代码行不行,为什么?

List<Integer> amountList = new ArrayList<>();
  • 不行,原例中是new Vector,Vector是线程安全的,换成ArrayList那么对票的相加操作也会变得线程不安全。

第三章 - 共享模型之管程(一)_多线程_44

两个方法分别都是线程安全的了,那么组合在一起了,也是线程安全的吗?

// 买票
int amount = window.sell(random(5));
// 统计买票数
amountList.add(amount);
  • 其实仍然是线程安全的,因为两个方法虽然组合了,但是没有在组合的方法上加synchronized,在多线程下可能会发生指令交错。但是即使发生了也不影响,因为两个方法操作的并不是同一个共享变量。是线程安全的。

转账练习

测试下面代码是否存在线程安全问题,并尝试改正

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

public static void main(String[] args) throws InterruptedException {
Account a = new Account(1000);
Account b = new Account(1000);

Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
a.transfer(b, randomAmount()); //模拟a给b转账
}
}, "t1");

Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
b.transfer(a, randomAmount()); //模拟b给a转账
}
}, "t2");

t1.start();
t2.start();
t1.join();
t2.join();

// 查看转账2000次后的总金额
log.debug("total:{}", (a.getMoney() + b.getMoney()));
}

// Random 为线程安全
static Random random = new Random();

// 随机 1~100
public static int randomAmount() {
return random.nextInt(100) + 1;
}
}

// 账户
class Account {

private int money; //成员变量

public Account(int money) {
this.money = money;
}

public int getMoney() {
return money;
}

public void setMoney(int money) {
this.money = money;
}

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

}

第三章 - 共享模型之管程(一)_java_45

  • 有两个账户对象,每个账户对象里有自己的余额变量money作为共享变量。
Account a = new Account(1000);
Account b = new Account(1000);

第三章 - 共享模型之管程(一)_线程安全_46

  • 账户里有一个transfer方法,涉及到对共享变量money的读写操作,属于临界区

第三章 - 共享模型之管程(一)_synchronized_47

  • 然后分别开1000个线程去让a给b转账,开1000个线程让b给a转账,调用transfer方法。
  • 即对共享变量money做读写的方法transfer,暴露在了多线程环境下。
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
a.transfer(b, randomAmount());
}
}, "t1");

Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
b.transfer(a, randomAmount());
}
}, "t2");
  • 在多线程下,发生指令交错,发生了线程安全问题,导致总金额为2054 > 2000
11:05:15.743 c.ExerciseTransfer [main] - total:2054

Process finished with exit code 0

解决方法

对transfer( )方法上锁

  • 直接对transfer( )方法加synchronized?很遗憾,这样做并不能解决问题。
// 转账
public synchronized void transfer(Account target, int amount) {
if (this.money >= amount) {
this.setMoney(this.getMoney() - amount);
target.setMoney(target.getMoney() + amount);
}
}
  • 结果,依然发生了线程安全问题
11:15:35.814 c.ExerciseTransfer [main] - total:423

Process finished with exit code 0
  • 这是因为,transfer( )方法中,并不只是操作了自己的共享变量this.money,还操作了转账对象的共享变量target.money。
  • 而synchronize直接加在成员方法上,等同于synchronized(this),对自己的成员变量this.money加锁。
  • 所以应该把两个共享变量都锁上,那么可以使用synchronized(Account.class),对​​Account类​​加锁,那么Account类所有的实例对象都会被加上锁,即实现了锁住了两个对象的money
// 转账
public void transfer(Account target, int amount) {
synchronized (Account.class) {
if (this.money >= amount) {
this.setMoney(this.getMoney() - amount);
target.setMoney(target.getMoney() + amount);
}
}
}
  • 测试多次结果都正确
11:24:38.288 c.ExerciseTransfer [main] - total:2000

Process finished with exit code 0