Java多线程(2)---线程控制和线程安全的详细讲解

我会带着你远行 2024-04-20 14:29 0阅读 0赞

**目录**

前言

一.线程控制方法

1.1启动线程--start()

1.2线程睡眠---sleep()方法

1.3中断线程--interrupt() 方法

1.4等待线程---join()

二.线程安全

2.1数据不安全---数据共享

⭐不安全的演示和原因

⭐不安全的处理方法

⭐synchronized的使用

2.2数据不安全---内存可见性

⭐不安全的演示和原因

⭐不安全的处理方法

2.3 synchronized和volatile的区别

三.认识wait()、notify()

3.1wait()方法

3.2notify()方法

3.3wait()方法和sleep()方法的对比

四.总结

--------------------

> 🎁[个人主页][Link 1]：[tq02的博客\_CSDN博客-C语言,Java,Java数据结构领域博主][tq02_CSDN_-C_Java_Java]  
> 🎥 本文由 tq02 原创，首发于 CSDN🙉  
> 🎄 本章讲解内容：**多****线程的控制、安全讲解**
> 
> ![55ae5fe7ab844842896947993d3eb222.png][]
> 
> 🎥学习专栏： [ C语言][C] [JavaSE][] [MySQL基础][MySQL]

## 前言 ##

JavaEE的多线程知识点，我们在[ 多线程(1) ][_1_]中学习到了如何创建多线程、多线程的运行状态等，而本章主要讲解多线程的线程控制手段以及线程安全。

## 一.线程控制方法 ##

线程控制：就是控制线程的执行速率，让某某线程先执行等。 根据生命周期，我们可以知道线程控制方法大概有：start()、sleep()、interrupt()、join()、wait()、yield()、notify()、

### 1.1启动线程--start() ###

class MyThread extends Thread {
        @Override
        public void run() {
        System.out.println("这里是线程运行的代码");
        }
    }
     
    public class Text{
         public static void main(String[] args) {
            //创建MyThread实例
          MyThread t1=new MyThread();
           //调用start方法启动线程
         t1.start();
            //t1.run();  虽然也是执行run函数当中的操作，但是并不是启动线程，而是调用方法
        }
    }

通过覆写 run 方法创建一个线程对象，但线程对象被创建出来并不意味着线程就开始运行了。并且不是指调用run方法就可以使用线程运行，而是单纯的执行方法run，并不能达到并行的机制，只有使用start()方法才可以使线程运行

### 1.2线程睡眠---sleep()方法 ###

线程会暂停运行，并且可以设置暂停运行的时间，例如：sleep(1000),是休眠了1秒。

注：是暂停运行，而不是停止运行，而时间的设置长度更像是闹钟，时间一到，就开始运行。

### 1.3中断线程--interrupt() 方法 ###

> 线程一旦开始运行，想让线程强制停止，目前有2种方法。
> 
> 1.  通过**共享的标记**来进行沟通
> 2.  调用 **interrupt()** 方法来通知

**1.通过共享的标记来进行沟通：**

使用自定义的变量来作为标志位.并且给标志位上并且final修饰，后期会讲解volatile 关键字，使用它也可以执行操作。

public class Text{
         // 写作成员变量就不是触发变量捕获的逻辑了. 而是 "内部类访问外部类的成员" , 
         //本身就是 ok 的~~
        public static boolean isQuit = false;
    
        public static void main(String[] args) throws InterruptedException {
            //或者 final boolean isQuit = false；
    
            Thread t = new Thread(() -> {
                while (!isQuit) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            t.start();
    
            // 主线程这里执行一些其他操作之后, 要让 t 线程结束.
            Thread.sleep(3000);
    
            // 这个代码就是在修改前面设定的标志位.
            isQuit = true;
            System.out.println("把 t 线程终止");
        }
    }

从上面的代码当中，我们可以发现isQuit变量用于lambda表达式，因此会有一个变量捕获的环节，而在变量捕获当中，捕获到的外部变量isquit不可以修改，因此需要使用final修饰，主线程执行完毕时，将isQuit修改为true;导致子线程强行结束。

**2.调用 interrupt() 方法来通知**

> Thread.interrupted() 或者 Thread.currentThread().isInterrupted() 代替自定义标志位.
> 
> **Thread.currentThread():**获取当前对象的引用，isInterrupted()方法是指提供一个标志位。
> 
> **Thread.interrupted():**将标志位改为true

public static void main(String[] args) throws InterruptedException {
            Thread t = new Thread(() -> {
                // Thread.currentThread 就是 t .
                // 但是 lambda 表达式是在构造 t 之前就定义好的. 编译器看到的 lambda 里的 t 就会认为这是一个还没初始化的对象.因此wile的括号里不可以使用t.
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // e.printStackTrace();
                        break;
                    }
                }
            });
    
            t.start();
            Thread.sleep(3000);
            // 把上述的标志位给设置成 true
            t.interrupt();
        }

当线程正在sleep()休眠当中，如果使用interrupt()唤醒，则会唤醒，继续运行

### 1.4等待线程---join() ###

等待线程，是指两个线程进行时，一个线程等待另一个线程执行结束，才可以执行结束。

public static void main(String[] args) {
            Thread b = new Thread(() -> {
                for (int i = 0; i < 5; i++) {
                    System.out.println("张三工作");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                 System.out.println("张三工作结束了");
            });
    
            Thread a = new Thread(() -> {
                for (int i = 0; i < 3; i++) {
                    System.out.println("李四工作");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    // 如果 b 此时还没执行完毕, b.join 就会产生阻塞的情况
                    b.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("李四工作结束了");
            });
    
            b.start();
        
            a.start();
        }

例如，原本李四工作比张三工作要快，可是我使用了join()方法，然后让李四等待张三结束，才能结束。方法还可以使用其他参数用于不同意思。

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>方法</td> 
   <td>作用</td> 
  </tr> 
  <tr> 
   <td>join()</td> 
   <td>等待线程结束</td> 
  </tr> 
  <tr> 
   <td>jion(long millis)</td> 
   <td>等待线程结束，或者等待一定时间自动结束</td> 
  </tr> 
 </tbody> 
</table>

而除了这些操作方法之外，我们还有wait()、notify()方法，但是需要先学习线程安全才能更好的学习。

## 二.线程安全 ##

线程安全指：多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的。

**线程不安全出现的根本原因：**

1.  线程是抢占式执行
2.  多个线程同时对共享数据进行操作，产生数据覆盖
3.  内存可见性
4.  指令重排序

### 2.1数据不安全---数据共享 ###

#### ⭐不安全的演示和原因 ####

class Counter {
        public int count = 0;
            
        void increase() {
            count++;
        }
    }
    public static void main(String[] args) throws InterruptedException {
        final Counter counter = new Counter();
            Thread t1 = new Thread(() -> {
                for (int i = 0; i < 50000; i++) {
                        counter.increase();
                 }
            });
            Thread t2 = new Thread(() -> {
                for (int i = 0; i < 50000; i++) {
                        counter.increase();
                }
            });
                t1.start();
                t2.start();
            t1.join();
            t2.join();
    System.out.println(counter.count);
    }

例如：以上2个线程，都执行50000次的count++，按理而言count最后的结果是100000次，可是执行之后却不足100000次。数据会存放在堆区，多个线程都可以访问。

**出现的原因**

count++实际上操作：

1.  内存的数据加载到CPU寄存器中
2.  寄存器中的数据执行++
3.  返回给内存。

![20ffb7c5e3034143bdf39d4fe8b7a147.png][]

由于count在堆上，会被多个线程共享访问， t1和t2线程同时获取count元素，进行自增，然后将结果返回内存器当中，t1返回2，t2页返回2，将t1返回的值覆盖，因此少了一次自增

--------------------

#### ⭐不安全的处理方法 ####

线程不安全的原因主要是多个线程会共享访问数据，导致数据的原子性被破坏，因此我们可以使用一种方法，让其他线程知晓该数据正在被其他线程使用(可见性)。

**方法**：加锁

当一个线程在执行操作时，对需要操作的数据或者方法进行加锁，这样其他线程使用不到了。

![db52816ffd6049d2aff08de3008f57c2.png][]

例如，需要操作的方法或者数据是一个房间，线程一进去时，将门锁了，只有线程一操作结束，出来时，线程二才能进去

使用**关键字synchronized**，加锁操作：

class Counter {
        public int count = 0;
            
       synchronize void increase() {
            count++;
        }
    }
    public static void main(String[] args) throws InterruptedException {
        final Counter counter = new Counter();
            Thread t1 = new Thread(() -> {
                for (int i = 0; i < 50000; i++) {
                        counter.increase();
                 }
            });
            Thread t2 = new Thread(() -> {
                for (int i = 0; i < 50000; i++) {
                        counter.increase();
                }
            });
                t1.start();
                t2.start();
            t1.join();
            t2.join();
    System.out.println(counter.count);
    }

将increase()方法进行加锁，当一个线程进入时，就会进行加锁，其他线程只能等待该线程释放。

--------------------

#### ⭐synchronized的使用 ####

synchronized关键字进行加锁时，是需要对**相同的对象**展开。

加锁的目的：为了互斥使用资源，而加锁的对象也是需要相同的，两个线程对同一个对象进行加锁时，会产生锁竞争/锁冲突。

class Counter {
        public int count = 0;
            
        void increase() {
            synchronized(this){
               count++;
            }
        }
    }

this是目前对象，而我们也可以使用其他对象。

### 2.2数据不安全---内存可见性 ###

#### ⭐不安全的演示和原因 ####

static class Counter {
        public int flag = 0;
    }
        public static void main(String[] args) {
            Counter counter = new Counter();
            Thread t1 = new Thread(() -> {
                while (counter.flag == 0) {
                    //代码操作
                }
        System.out.println("循环结束!");
        });
            Thread t2 = new Thread(() -> {
                Scanner scanner = new Scanner(System.in);
                System.out.println("输入一个整数:");
                counter.flag = scanner.nextInt();
            });
                t1.start();
                t2.start();
    }

在这个代码中，我们只需要输入非零数，按逻辑而言，线程t1也应该会结束，可事实上，t1不会结束，**原因：**t1读取自己工作内存中的内容，而t2对flag进行修改，t1却无法得知他的修改。

问题产生的原因：

1.  counter.flag==0；实际上的指令：load(读指令）jcmp(比较指令)
2.  编译器发现这个这个逻辑是一样的，每一次都是需要读取指令，结果却是一样的，因此，编译器会将逻辑优化掉，直接进行jcmp指令。
3.  因此即使flag发生了改变，t1也无法得知。

--------------------

#### **⭐不安全的处理方法** ####

使用volatile关键字，使用volatile关键字修饰变量之后，编译器就会禁止优化。

static class Counter {
        public volatile int flag = 0;
    }
        public static void main(String[] args) {
            Counter counter = new Counter();
            Thread t1 = new Thread(() -> {
                while (counter.flag == 0) {
                    //代码操作
                }
        System.out.println("循环结束!");
        });
            Thread t2 = new Thread(() -> {
                Scanner scanner = new Scanner(System.in);
                System.out.println("输入一个整数:");
                counter.flag = scanner.nextInt();
            });
                t1.start();
                t2.start();
    }

本质上保证修饰的变量的内存可见性，禁止编译器的优化

### 2.3 synchronized和volatile的区别 ###

1.  volatile不保证原子性，只保证了内存可见性
2.  synchronized保证了原子性、也保证了内存可见性

## 三.认识wait()、notify() ##

由于线程之间是抢占式执行的，因此线程之间执行的先后顺序难以预知。但是实际开发中，我们希望可以协调控制多个线程的执行先后顺序。

而涉及到协调控制方法：

1.  wait() / wait(long timeout)：让线程进入等待状态
2.  notify() / notifyAll(): 唤醒在当前对象上等待的线程

### 3.1wait()方法 ###

> 线程进入等待状态，如果没有唤醒，则会一直一直等待，并且需要搭配synchronized 来使用. 脱离 synchronized 使用 wait 会直接抛出异常.  
> wait()结束等待的条件：
> 
> 1.  其他线程调用该对象的 notify 方法.
> 2.  wait 等待时间超时 (wait 方法提供一个带有 timeout 参数的版本, 来指定等待时间).
> 3.  其他线程调用该等待线程的 interrupted 方法, 导致 wait 抛出 InterruptedException 异常.

代码示例：

public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
            synchronized (object) {
                System.out.println("等待中");
                object.wait();
            System.out.println("等待结束");
            }
    }

### 3.2notify()方法 ###

用于唤醒wait()进入等待的线程。在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出同步代码块之后才会释放对象锁。  
**notifyAll()方法**:则是唤醒所有等待的线程。注：虽然是同时唤醒，但是需要竞争锁，因此并不是同时执行，依然有先来后到的执行

### **3.3wait()方法和sleep()方法的对比** ###

理论上 wait 和 sleep 完全是没有可比性的，因为一个是用于线程之间的通信的，一个是让线程阻塞一段时间，唯一的相同点就是都可以让线程放弃执行一段时间

wait 需要搭配 synchronized 使用. sleep 不需要.  
wait 是 Object 的方法 sleep 是 Thread 的静态方法.

## 四.总结 ##

volatile 能够保证内存可见性. 强制从主内存中读取数据，synchronize既可以保证原子性也可以保证内存可见性。

**Java多线程实现数据共享的原理：**

JVM 把内存分成了这几个区域:  
方法区, 堆区, 栈区, 程序计数器.  
其中堆区这个内存区域是多个线程之间共享的.  
只要把某个数据放到堆内存中, 就可以让多个线程都能访问到

[Link 1]: https://so.csdn.net/so/search?q=%E4%B8%AA%E4%BA%BA%E4%B8%BB%E9%A1%B5&spm=1001.2101.3001.7020
[tq02_CSDN_-C_Java_Java]: https://blog.csdn.net/m0_74097410?spm=1010.2135.3001.5343
[55ae5fe7ab844842896947993d3eb222.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/e771471742c648eea0429e5d8f0b397b.png
[C]: http://t.csdn.cn/3A5e9
[JavaSE]: http://t.csdn.cn/TBH4P
[MySQL]: http://t.csdn.cn/2FRvG
[_1_]: http://t.csdn.cn/mXyR4
[20ffb7c5e3034143bdf39d4fe8b7a147.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/d1572eca431742858d6e780483173331.png
[db52816ffd6049d2aff08de3008f57c2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/d1c1c9f3b94c4379a8afa63102195bac.png