JUC并发编程——线程安全问题

- 一、共享问题
- - 1.1 共享带来的问题
  - 1.2 临界区与竞态条件
- 二、解决方案
- - 2.1 上下文切换——synchronized-解决
  - 2.2 上下文切换——synchronized-理解
  - 2.3 上下文切换——synchronized-思考
  - 2.4 锁面向对象改进
  - 2.5 方法上的 synchronized
- 三、synchronized习题
- - 3.1 synchronized-加在方法上
- 三、线程安全分析
- 四、Monitor
- 五、wait/notify
- 六、线程状态转换
- 七、活跃性
- 八、Lock

一、共享问题

1.1 共享带来的问题

Java的体现（由于分时系统造成线程切换而导致的安全问题）

import lombok.extern.slf4j.Slf4j;

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

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

两个线程对初始值为 0 的静态变量一个做自增，一个做自减，各做 5000 次，结果是 0 吗？
对于静态变量而言，++、--草所并非一条指令

问题分析

以上的结果可能是正数、负数、零。为什么呢？因为 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

而 Java 的内存模型如下，完成静态变量的自增，自减需要在主存和工作内存中进行数据交换：
在这里插入图片描述
静态变量而言存在于主存中，多个线程都可以读取到它的值；而计算是在线程内进行的，计算后再写回主存

若为单线程进行i++、i–操作不会产生指令间的交错
在这里插入图片描述
但多线程由于分时系统会产生指令交错

① 出现负数的情况：
在这里插入图片描述
② 出现正数的情况：

根本原因：线程上下文切换引起的指令交错导致多线程访问共享变量时的线程安全问题

1.2 临界区与竞态条件

临界区 Critical Section

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

static int counter = 0;
static void increment() 
// 临界区
{ 
 counter++;    // 既有读又有写的操作
}
static void decrement() 
// 临界区
{ 
 counter--;    // 既有读又有写的操作
}

竞态条件 Race Condition

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

二、解决方案

2.1 上下文切换——synchronized-解决

* 应用之互斥

为了避免临界区的竞态条件发生，有多种手段可以达到目的。
● 阻塞式的解决方案：synchronized，Lock
● 非阻塞式的解决方案：原子变量

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

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

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

synchronized语法

synchronized（对象）     同一时刻只能有一个对象持有锁
   {                    （若此时对象锁的持有者线线程1，
        临界区                 那么线程2会陷入阻塞状态===>blocked）
}

使用synchronized关键字加锁时需要配合一个由多个线程共享的对象完成

2.2 上下文切换——synchronized-理解

在这里插入图片描述
可以做这样的类比：
● synchronized 中的对象，可以想象为一个房间（room），有唯一入口（门）房间只能一次进入一人进行计算，线程 t1，t2 想象成两个人

● 当线程 t1 执行到 synchronized(room) 时就好比 t1 进入了这个房间，并锁住了门拿走了钥匙，在门内执行count++ 代码

● 这时候如果 t2 也运行到了 synchronized(room) 时，它发现门被锁住了，只能在门外等待，发生了上下文切换（由运行状态切换至阻塞状态），阻塞住了

● 这中间即使 t1 的 cpu 时间片不幸用完，被踢出了门外（不要错误理解为锁住了对象就能一直执行下去哦），这时门还是锁住的，t1 仍拿着钥匙，t2 线程还在阻塞状态进不来，只有下次轮到 t1 自己再次获得时间片时才能开门进入

● 当 t1 执行完 synchronized{} 块内的代码，这时候才会从 obj 房间出来并解开门上的锁，唤醒 t2 线程把钥匙给他。t2 线程这时才可以进入 obj 房间，锁住了门拿上钥匙，执行它的 count-- 代码

用图来表示：
在这里插入图片描述

2.3 上下文切换——synchronized-思考

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

为了加深理解，可以思考下面的问题
● 如果把 synchronized(obj) 放在 for 循环的外面，如何理解？——【将5000*4=20000条指令作为一个整体】原子性
● 如果 t1 synchronized(obj1) 而 t2 synchronized(obj2) 会怎样运作？——【不会保护临界区中代码的安全执行，多个线程锁住的不为同一个对象】
● 如果 t1 synchronized(obj) 而 t2 没有加会怎么样？如何理解？——【线程发生上下文切换时不会获取对象锁，进而不会被阻塞住】

2.4 锁面向对象改进

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

import lombok.extern.slf4j.Slf4j;

@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();
        t2.join();
        log.debug("{}", room.getCounter());
    }
}

// 创建保护counter变量的对象（创建room类）
class Room {

    private int counter = 0;
    // 每次执行++/--只能有一个线程===>使用synchronized对room中的共享资源(counter)进行保护
    public  void increment() {
        synchronized (this) {
            counter++;
        }
    }

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

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

上述做法也可之间将synchronized加在方法上：

@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();
        t2.join();
        log.debug("{}", room.getCounter());
    }
}

// 创建保护counter变量的对象（创建room类）
class Room {
    
    private int counter = 0;
    // 每次执行++/--只能有一个线程===>使用synchronized对room中的共享资源(counter)进行保护
    public synchronized void increment() {
        counter++;
    }

    public synchronized void decrement() {
        counter--;
    }
    // 获取值的时候也需加锁（以上方法均为修改值，为了保证获取值时得到的为
    public synchronized int getCounter() {         // 一个准确的结果而不是一个中间的结果）
        return counter;
    }
}

2.5 方法上的 synchronized

① synchronized写在成员方法上（非static方法）

class Test{
    public synchronized void test() {
 
   }
}
等价于锁住的为this对象（synchronized只能锁对象）
class Test{
   public void test() {
        synchronized(this) {
 
   }
  }
}

synchronized写在静态方法上

class Test{
 public synchronized static void test() {
 }
}
等价于锁住的为类对象
class Test{
   public static void test() {
      synchronized(Test.class) {
 
   }
 }
}

不加synchronized的方法
不加 synchronzied 的方法就好比不遵守规则的人，不去老实排队（好比翻窗户进去的）

三、synchronized习题

3.1 synchronized-加在方法上

1. 所谓的“线程八锁（其实就是考察 synchronized 锁住的是哪个对象）

情况1 ：12 （线程1先启动被调度的机会稍微大些）或 21（并不容易出现）【锁住的为同一个对象，具有互斥效果】

@Slf4j(topic = "c.Number")
class Number{
   public synchronized void a() {
      log.debug("1");
 }
   public synchronized void b() {
      log.debug("2");
    }
}
public static void main(String[] args) {
   Number n1 = new Number();
   new Thread(()->{ n1.a(); }).start();
   new Thread(()->{ n1.b(); }).start();
}

情况2 ：1s后1 2，或 2 1s后 1（也不是很容易出现）【CPU先调度线程2，线程2先获得锁】

@Slf4j(topic = "c.Number")
class Number{
    public synchronized void a() {
       sleep(1);
       log.debug("1");
 }
 public synchronized void b() {
       log.debug("2");
   }
}
public static void main(String[] args) {
     Number n1 = new Number();
     new Thread(()->{ n1.a(); }).start();
     new Thread(()->{ n1.b(); }).start();
}

情况3 ：（加入C方法，C方法由第三个线程启动但其方法上并未加synchronized）3 1s 12 或 23 1s 1 或 32 1s 1

@Slf4j(topic = "c.Number")
class Number{
    public synchronized void a() {
       sleep(1);
       log.debug("1");
 }
 public synchronized void b() {
       log.debug("2");
 }
 /* 加入C方法，但并未采用synchronized关键字，
     因此C方法调用时不会产生互斥的效果。
     会并行执行（a与b锁住的均为n1对象）
 */
 public void c() {
       log.debug("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();
}

情况4 ：2 1s 后 1

@Slf4j(topic = "c.Number")
class Number{
   public synchronized void a() {
        sleep(1);
        log.debug("1");
 }
   public synchronized void b() {
        log.debug("2");
   }
}
//  锁住的不为同一个对象（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();
}

情况5 ：2 1s 后 1【调用a()时锁住的为类对象，调用b()时锁住的为n1对象】

// 锁住的为不同对象，意味着不存在互斥现象
@Slf4j(topic = "c.Number")
class Number{
// a方法为静态方法（锁住的为Number类对象）
  public static synchronized void a() {
      sleep(1);
      log.debug("1");
 }
 public synchronized void b() {
      log.debug("2");
    }
 }
public static void main(String[] args) {
     Number n1 = new Number();
     // 调用a()时锁住的为类对象
     new Thread(()->{ n1.a(); }).start();
     // 调用b()时锁住的为n1对象
     new Thread(()->{ n1.b(); }).start();
}

情况6 ：1s 后12，或 2 1s后 1【都对类对象加锁，锁住的为同一个对象】类对象整个内存中只有一份

@Slf4j(topic = "c.Number")
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();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

情况7 ：2 1s 后 1

@Slf4j(topic = "c.Number")
class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
 }
 public 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();
}

情况8 ：1s 后12，或 2 1s后 1【锁住的均为类对象】

@Slf4j(topic = "c.Number")
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();
}