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

2024-01-03 16:58
文章标签 第三章 模型 共享 管程

本文主要是介绍第三章 - 共享模型之管程(一)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

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

本章内容

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

共享带来的问题

小故事

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

Untitled

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

Untitled

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

Untitled

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

Untitled

  • 小南和小女都觉得自己没做错，但笔记本里的结果是 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);}}

程序运行结果不唯一：

Untitled

Untitled

Untitled

问题分析

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

Untitled

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

Untitled

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

Untitled

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

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

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

Untitled

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

  • 出现负数的情况：

Untitled

  • 出现正数的情况：

Untitled

临界区 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

Untitled

synchronized 原理分析

Untitled

可以做这样的类比：

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

用图来表示

Untitled

思考

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(() -> { //线程1log.debug("begin");n1.a();}).start();new Thread(() -> { //线程2log.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");}}

Untitled

情况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(() -> { //线程1log.debug("begin");n1.a();}).start();new Thread(() -> { //线程2log.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");}}

Untitled

Untitled

  • 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(() -> { //线程1log.debug("begin");n1.a();}).start();new Thread(() -> { //线程2log.debug("begin");n1.b();}).start();new Thread(() -> { //线程3log.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");}}

Untitled

Untitled

Untitled

  • 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");}}

Untitled

  • 两个方法锁的不是同一个对象，线程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");}}

Untitled

  • 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");}}

Untitled

Untitled

  • 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");}}

Untitled

  • 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");}}

Untitled

Untitled

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

变量的线程安全分析

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

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

局部变量是否线程安全？

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

局部变量线程安全分析

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

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

Untitled

如图：

Untitled

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

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 {// 成员变量listArrayList<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 就会报错：

Untitled

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

Untitled

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<>(); //局部变量listfor (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 相同

Untitled

暴露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<>(); //局部变量listfor (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);},"Thread3").start();}}

Untitled

  • 从这个例子可以看出 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<>(); //局部变量listfor (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

Untitled

线程安全类方法的组合

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

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

Untitled

不可变类线程安全性

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

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

String的substring源码

Untitled

Untitled

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

实例分析

代码示例1

public class MyServlet extends HttpServlet {// 是否安全？no	HashTable才是线程安全的Map<String,Object> map = new HashMap<>();// 是否安全？yesString S1 = "...";// 是否安全？yesfinal String S2 = "...";// 是否安全？noDate D1 = new Date();// 是否安全？no// D2的引用不会变，但是日期对象内的属性可以变final Date D2 = new Date();public void doGet(HttpServletRequest request,	HttpServletResponse response) {// 使用上述变量}}

代码示例2

public class MyServlet extends HttpServlet {// 是否安全？noprivate 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 {// 是否安全？noprivate 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 {// 是否安全 yesprivate UserService userService = new UserServiceImpl();public void doGet(HttpServletRequest request, HttpServletResponse response) {userService.update(...);}}public class UserServiceImpl implements UserService {// 是否安全 yesprivate 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 = ?";// 是否安全 yestry (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 {// 是否安全 noprivate 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~5public 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;}}
}

Untitled

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

Untitled

Untitled

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

Untitled

  • 每一个线程买票时，都是先读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那么对票的相加操作也会变得线程不安全。

Untitled

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

// 买票
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~100public 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);}}}

Untitled

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

Untitled

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

Untitled

  • 然后分别开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:2054Process 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:423Process 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:2000Process finished with exit code 0

这篇关于第三章 - 共享模型之管程(一)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/566416。

相关文章

NFS实现多服务器文件的共享的方法步骤

NFS实现多服务器文件的共享的方法步骤

《NFS实现多服务器文件的共享的方法步骤》NFS允许网络中的计算机之间共享资源,客户端可以透明地读写远端NFS服务器上的文件,本文就来介绍一下NFS实现多服务器文件的共享的方法步骤,感兴趣的可以了解一... 目录一、简介二、部署1、准备1、服务端和客户端：安装nfs-utils2、服务端：创建共享目录3、服
阅读更多...
Golang的CSP模型简介(最新推荐)

Golang的CSP模型简介(最新推荐)

《Golang的CSP模型简介(最新推荐)》Golang采用了CSP（CommunicatingSequentialProcesses,通信顺序进程）并发模型,通过goroutine和channe... 目录前言一、介绍1. 什么是 CSP 模型2. Goroutine3. Channel4. Channe
阅读更多...
使用Nginx来共享文件的详细教程

使用Nginx来共享文件的详细教程

《使用Nginx来共享文件的详细教程》有时我们想共享电脑上的某些文件,一个比较方便的做法是,开一个HTTP服务,指向文件所在的目录,这次我们用nginx来实现这个需求,本文将通过代码示例一步步教你使用... 在本教程中，我们将向您展示如何使用开源 Web 服务器 Nginx 设置文件共享服务器步骤 0 —
阅读更多...
Python基于火山引擎豆包大模型搭建QQ机器人详细教程(2024年最新)

Python基于火山引擎豆包大模型搭建QQ机器人详细教程(2024年最新)

《Python基于火山引擎豆包大模型搭建QQ机器人详细教程(2024年最新)》：本文主要介绍Python基于火山引擎豆包大模型搭建QQ机器人详细的相关资料,包括开通模型、配置APIKEY鉴权和SD... 目录豆包大模型概述开通模型付费安装 SDK 环境配置 API KEY 鉴权Ark 模型接口Prompt
阅读更多...
Python使用pysmb库访问Windows共享文件夹的详细教程

Python使用pysmb库访问Windows共享文件夹的详细教程

《Python使用pysmb库访问Windows共享文件夹的详细教程》本教程旨在帮助您使用pysmb库,通过SMB（ServerMessageBlock）协议,轻松连接到Windows共享文件夹,并列... 目录前置条件步骤一：导入必要的模块步骤二：配置连接参数步骤三：实例化SMB连接对象并尝试连接步骤四：
阅读更多...
Linux使用粘滞位 (t-bit)共享文件的方法教程

Linux使用粘滞位 (t-bit)共享文件的方法教程

《Linux使用粘滞位(t-bit)共享文件的方法教程》在Linux系统中,共享文件是日常管理和协作中的常见任务,而粘滞位（StickyBit或t-bit）是实现共享目录安全性的重要工具之一,本文将... 目录文件共享的常见场景基础概念linux 文件权限粘滞位 (Sticky Bit)设置共享目录并配置粘
阅读更多...
大模型研发全揭秘：客服工单数据标注的完整攻略

大模型研发全揭秘：客服工单数据标注的完整攻略

在人工智能（AI）领域，数据标注是模型训练过程中至关重要的一步。无论你是新手还是有经验的从业者，掌握数据标注的技术细节和常见问题的解决方案都能为你的AI项目增添不少价值。在电信运营商的客服系统中，工单数据是客户问题和解决方案的重要记录。通过对这些工单数据进行有效标注，不仅能够帮助提升客服自动化系统的智能化水平，还能优化客户服务流程，提高客户满意度。本文将详细介绍如何在电信运营商客服工单的背景下进行
阅读更多...
Andrej Karpathy最新采访：认知核心模型10亿参数就够了，AI会打破教育不公的僵局

Andrej Karpathy最新采访：认知核心模型10亿参数就够了，AI会打破教育不公的僵局

夕小瑶科技说 原创  作者 | 海野 AI圈子的红人，AI大神Andrej Karpathy，曾是OpenAI联合创始人之一，特斯拉AI总监。上一次的动态是官宣创办一家名为 Eureka Labs 的人工智能+教育公司 ，宣布将长期致力于AI原生教育。 近日，Andrej Karpathy接受了No Priors（投资博客）的采访，与硅谷知名投资人 Sara Guo 和 Elad G
阅读更多...
Retrieval-based-Voice-Conversion-WebUI模型构建指南

Retrieval-based-Voice-Conversion-WebUI模型构建指南

一、模型介绍 Retrieval-based-Voice-Conversion-WebUI（简称 RVC）模型是一个基于 VITS（Variational Inference with adversarial learning for end-to-end Text-to-Speech）的简单易用的语音转换框架。 具有以下特点 简单易用：RVC 模型通过简单易用的网页界面，使得用户无需深入了
阅读更多...
透彻！驯服大型语言模型（LLMs）的五种方法，及具体方法选择思路

透彻！驯服大型语言模型（LLMs）的五种方法，及具体方法选择思路

引言 随着时间的发展，大型语言模型不再停留在演示阶段而是逐步面向生产系统的应用，随着人们期望的不断增加，目标也发生了巨大的变化。在短短的几个月的时间里，人们对大模型的认识已经从对其zero-shot能力感到惊讶，转变为考虑改进模型质量、提高模型可用性。 「大语言模型(LLMs)其实就是利用高容量的模型架构（例如Transformer）对海量的、多种多样的数据分布进行建模得到，它包含了大量的先验
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2