从零开始的并发世界生活-第五天

继续学习JUC并发~

1.线程状态：

（1）线程的五种状态

线程的五种状态是从操作系统的层面来描述的。

• 【初始状态】仅在语言层面创建了线程对象，还未与操作系统线程关联，比如只 new 了Thread对象，但是还没调用start方法
• 【可运行状态】也叫做【就绪状态】指线程已被创建并于操作系统线程进行了关联，可以由CPU调度执行
• 【运行状态】只获取了CPU时间片运行中的状态
  • 当CPU时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换
• 【阻塞状态】
  • 如果调用了阻塞API，如BIO读写文件，这时该线程实际不会用到CPU，会导致线程上下文切换，进入【阻塞状态】
  • 等BIO操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】

（2）线程的六种状态

这是从Java API的层面描述的
根据Thread.State枚举，分为六种状态

• 【NEW】线程刚被创建，但是还没有调用start方法

• 【RUNNABLE】当调用了start方法后，注意，Java API层面的RUNNABLE状态涵盖了操作系统层面的【可运行状态】、【运行状态】、【阻塞状态】（由于BIO导致的线程阻塞，在Java里无法区分，仍认为是可运行的）

• 【BLOCKED】、【WAITING】、【TIMED-WATING】（）都是Java API层面对【阻塞状态】的细分，后面会在状态转换一节讲述

• 【TEMINATED】当线程代码运行结束

2.线程安全问题

问题引出：
在程序中有一个静态变量，两个线程对这一个静态变量分别进行加一和减一操作：

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

      Thread t2 = new Thread("t2"){
         @Override
         public void run() {
            for(int j = 0;j<5000;j++){
               a--;
            }
         }
      };

      t1.start();
      t2.start();
      t1.join();
      t2.join();
      System.out.println(a);
   }
}

预想情况下，最后a的值应该是0，但是最后执行得出的结果往往不是0，这是为什么？
Java中对静态变量的自增、自减并不是原子操作，要从字节码来进行分析。

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

如果是单线程，则上面的代码是顺序执行的，就不会出现问题：

但是如果是多线程，由于分时系统，就会产生指令的交错：
比如出现负数的情况：

也就是，多线程场景下分时系统使得出现上述问题。

3.临界区 Critical Section

• 一个程序运行多个线程本身是没有问题的

• 问题出在多个线程访问共享资源

  • 多个线程读取共享资源也是没有问题的
  • 问题出在多个线程对共享资源读写操作是发生指令交错，导致出现问题

• 一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区 。

4.竞态条件Race Condition

多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之发生了竞态条件，比如我们之前举的那个+1和-1的例子，就是发生了竞态条件。

为了避免临界区的竞态条件发生，有多种解决方案：

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

5.synchronized 解决方案

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

synchronized(对象)
{
   临界区
}

括号里的对象就是要受保护的对象，当加了synchronized后，这段临界区就变成串行的了，只有当一个线程执行完后，另一个线程才能执行。
上面的例子经过synchronized解决后：

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

     Thread t2 = new Thread("t2"){
        @Override
        public void run() {
           synchronized (lock){
              for(int j = 0;j<5000;j++){
                 a--;
              }
           }
        }
     };

     t1.start();
     t2.start();
     t1.join();
     t2.join();
     System.out.println(a);
  }
}

synchronized类比解释：

synchronized逻辑解释：

思考：synchronized实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切换所打断。
思考一个问题：如果t1线程加了synchronized(obj)，但是t2线程没有加会怎么样？
那样就会出现一个问题，当t2线程临界区代码没有执行完就被剥夺了时间片后，虽然对象锁是t2持有的，但是t1根本就不获取对象锁，所以t1就不会被阻塞，所以t1可以畅通无阻的执行它的临界区代码，而当t2获得时间片后，继续执行自己没执行完的临界区代码，就可能导致t1执行的结果被t2后来覆盖了。

6.锁对象面向对象改进
上面的例子经过我们的synchronized解决方案修改后实际是面向过程的，这里我们对其修改为面向对象：

package com.hspedu.juc;

/**
 * @author StormArcita
 * @date 2023/8/14 22:46
 */
public class Test01 {
    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();
        System.out.println(room.getI());
    }
}

class Room {
    private int i = 0;

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

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

    /**
     * 由于i是私有的，所以我们要设置一个获取i的方法
     */
    public int getI() {
    //读最好也用synchronized 修饰，这样防止读的时候出现脏读
        synchronized (this) {
            return i;
        }
    }
}

之后我们将更加详细的讲解synchronized。