共享模型之管程

lalala / 2023-07-16 / 原文

一共享带来的问题

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

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

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

以上的结果可能是正数、负数、零。为什么呢？因为 Java 中 对静态变量的自增，自减并不是原子操作。

例如对于 i++ 而言（i 为静态变量），实际会产生如下的 JVM 字节码指令：

getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
iadd // 自增
putstatic i // 将修改后的值存入静态变量i

而对应 i-- 也是类似：

getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
isub // 自减
putstatic i // 将修改后的值存入静态变量i

出现负数的情况：

出现正数的情况：

临界区 Critical Section

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

竞态条件 Race Condition

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

二 synchronized

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

阻塞式的解决方案：synchronized，Lock
非阻塞式的解决方案：原子变量

注意

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

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

解决

注意为了保护同一个资源，应该对同一个对象加锁

static int counter = 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) {
 　　　　counter++;
 　　}
 }
 }, "t1");

 Thread t2 = new Thread(() -> {
 　　for (int i = 0; i < 5000; i++) {
 　　　　synchronized (room) {
 　　　　counter--;
 　　}
 }
 }, "t2");
 
 t1.start();
 t2.start();
 t1.join();
 t2.join();
 log.debug("{}",counter);
}

优化面向对象改进

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

class Room {
 int value = 0;
 public void increment() {
 　　synchronized (this) {
 　　　　value++;
 　　}
 }
 public void decrement() {
 　　synchronized (this) {
 　　　　value--;
 　　}
 }
 public int get() {
 　　synchronized (this) {
 　　　　return value;
 　　}
 }
}

@Slf4j
public class Test1 {
 
 public static void main(String[] args) throws InterruptedException {
 　　Room room = new Room();
 
　　　Thread t1 = new Thread(() -> {
 　　　　for (int j = 0; j < 5000; j++) {
 　　　　　　room.increment();
　　　　}
 　　}, "t1");
 
　　Thread t2 = new Thread(() -> {
 　　　　for (int j = 0; j < 5000; j++) {
 　　　　　room.decrement();
 　　}
 　　}, "t2");
 　　t1.start();
 　　t2.start();
 　　t1.join();
 　　t2.join();
 　　log.debug("count: {}" , room.get());
 }
}

方法上的 synchronized

sychronized 只能锁对象。加再方法上，等于锁住了 this 对象

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

加在静态方法上的 synchronized

sychronized 只能锁对象。加在静态方法上，等于锁住了类对象（类对象只有一个）

静态方法：是使用static关键字修饰的方法，又叫类方法.属于类的，不属于对象，在实例化对象之前就可以通过类名.方法名调用静态方法。（静态属性，静态方法都是属于类的，可以直接通过类名调用）。
非静态方法：是不含有static关键字修饰的普通方法，又称为实例方法，成员方法。属于对象的，不属于类的。（成员属性，成员方法是属于对象的，必须通过new关键字创建对象后，再通过对象调用）。

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

例子： n1 和 n2 虽然是两个不同的对象，但是 a 和 b 都是静态方法被修饰。所以 n1.a() 和 n2.b() 锁住的都是同一个类对象 Number.class , 有互斥

class Number{
 　　public static synchronized void a() {
 　　　　sleep(1);
 　　　　log.debug("1");
 　　}
 　　public static synchronized void b() {
 　　　　log.debug("2");
 　　}
}

public static void main(String[] args) {
 　　Number n1 = new Number();
 　　Number n2 = new Number();
 　　new Thread(()->{ n1.a(); }).start();
 　　new Thread(()->{ n2.b(); }).start();
}

三变量的线程安全分析

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

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

局部变量是否线程安全？

局部变量是线程安全的
但局部变量引用的对象则未必
- 如果该对象没有逃离方法的作用访问，它是线程安全的
- 如果该对象逃离方法的作用范围，需要考虑线程安全

局部变量线程安全分析

相比静态变量一般都是安全的，因为是每个线程创建一个新对象

图一：List 作为 static 全局变量，对其进行读写操作（add remove）

图一：List 作为方法内的局部变量，对其进行读写操作（add remove）

局部变量不安全的情况

新起了线程对局部变量进行操作，这样这个局部变量对于原线程和新线程来说是共享资源，就带来了线程安全的问题

class ThreadSafe {
 　　public final 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);
 　　}
}
class ThreadSafeSubClass extends ThreadSafe{
 　　@Override
 　　public void method3(ArrayList<String> list) {
 　　　　new Thread(() -> {
 　　　　　　list.remove(0);
 　　　　}).start();
 　　}
}

常见线程安全类

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

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

它们的每个方法是原子的

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

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

线程安全类方法的组合

它们多个方法的组合不是原子的

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

不可变类线程安全性