Java高并发编程学习（一）多线程基础

谁借莪１个温暖的怀抱￠ 2023-07-07 05:51 1阅读 0赞

### 简介 ###

此篇主要是并发编程的一些基础知识，多线程编程本身就比较难，所以在了解基础知识之后，我们还要多加运用才能真正掌握

### 进程 ###

在计算机中，我们把一个任务称为一个进程，浏览器就是一个进程，视频播放器是另一个进程，类似的，音乐播放器和Word都是进程。一个进程中可能还有一些子任务，例如，Word可以让我们一边打字，一边进行拼写检查，同时还可以在后台进行打印，我们把子任务称为线程。**进程和线程的关系就是：一个进程可以包含一个或多个线程，但至少会有一个线程**。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5_size_16_color_FFFFFF_t_70]  
操作系统调度的最小任务单位其实不是进程，而是线程。**常用的Windows、Linux等操作系统都采用抢占式多任务，如何调度线程完全由操作系统决定，程序自己不能决定什么时候执行，以及执行多长时间**。  
因为同一个应用程序，既可以有多个进程，也可以有多个线程，因此，实现多任务的方法，有以下三种：

*  多进程模式（每个进程只有一个线程）：
 *  多线程模式（一个进程有多个线程）：
 *  多进程＋多线程模式（复杂度最高）：

### 进程 vs 线程 ###

#### 多进程的缺点在于： ####

*  创建进程比创建线程开销大，尤其是在Windows系统上；
 *  进程间通信比线程间通信要慢，因为线程间通信就是读写同一个变量，速度很快。

#### 多进程的优点在于： ####

**多进程稳定性比多线程高，因为在多进程的情况下，一个进程崩溃不会影响其他进程，而在多线程的情况下，任何一个线程都有可能影响其它线程，进而会直接导致整个进程崩溃**。

### 多线程 ###

Java语言内置了多线程支持：一个Java程序实际上是一个JVM进程，JVM进程用一个主线程来执行main()方法，在main()方法内部，我们又可以启动多个线程。此外，JVM还有负责垃圾回收的其他工作线程等。因此，对于大多数Java程序来说，我们说多任务，实际上是说如何使用多线程实现多任务。和单线程相比，多线程编程的特点在于：**多线程经常需要读写共享数据，并且需要同步。因此，多线程编程的复杂度高，调试更困难**。  
Java多线程编程的特点又在于：

*  多线程模型是Java程序最基本的并发模型
 *  后续读写网络、数据库、Web开发等都依赖Java多线程模型

### 创建新线程 ###

Java语言内置了多线程支持。当Java程序启动的时候，实际上是启动了一个JVM进程，然后，JVM启动主线程来执行main()方法。在main()方法中，我们又可以启动其他线程。创建线程主要有三种方式：

*  继承Thread类
 *  实现Runnable接口
 *  用Lambda实现Runnable（原理与第二种方式一致）

#### 继承Thread类 ####

从Thread派生一个自定义类，然后覆写run()方法：

public class Main {
        public static void main(String[] args) {
            Thread t = new MyThread();
            t.start(); // 这里要用start()方法，而不是run()，启动新线程
        }
    }
    
    class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("start new thread!");
        }
    }

行上述代码，注意到start()方法会在内部自动调用实例的run()方法。

#### 实现Runnable接口 ####

创建Thread实例时，传入一个Runnable实例：

public class Main {
        public static void main(String[] args) {
            Thread t = new Thread(new MyRunnable());
            t.start(); // 启动新线程
        }
    }
    
    class MyRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("start new thread!");
        }
    }

#### 用Lambda实现Runnable ####

Java8引了lambda语法，此时说是第三种方式，不如说是第种方式的变种，它可以让实现Runnable这种方式变得更简洁：

public class Main {
        public static void main(String[] args) {
            Thread t = new Thread(() -> {
                System.out.println("start new thread!");
            });
            t.start(); // 启动新线程
        }
    }

注意：Thread方法还有一个run()方法，但是直接调用run()方法，相当于调用了一个普通的Java方法，当前线程并没有任何改变，也不会启动新线程。还是在main线程中执行的，必须调用Thread实例的start()方法才能启动新线程，如果我们查看Thread类的源代码，会看到start()方法内部调用了一个private native void start0()方法，native修饰符表示这个方法是由JVM虚拟机内部的C代码实现的，不是由Java代码实现的。

private native void start0();

### 线程的优先级 ###

可以对线程设定优先级，设定优先级的方法是：

Thread.setPriority(int n) // 1~10, 默认值5

优先级高的线程被操作系统调度的优先级较高，操作系统对高优先级线程可能调度更频繁，但是要注意，程序并不能控制操作系统一定先调试高优先级的线程，高优先级只是参考，最终由操作系统决定先调谁！即我们决不能通过设置优先级来确保高优先级的线程一定会先执行。

### 线程的状态 ###

在Java程序中，一个线程对象只能调用一次start()方法启动新线程，并在新线程中执行run()方法。一旦run()方法执行完毕，线程就结束了。因此，Java线程的状态有以下几种：

*  New：新创建的线程，尚未执行；
 *  Runnable：运行中的线程，正在执行run()方法的Java代码；
 *  Blocked：运行中的线程，因为某些操作被阻塞而挂起；
 *  Waiting：运行中的线程，因为某些操作在等待中；
 *  Timed Waiting：运行中的线程，因为执行sleep()方法正在计时等待；
 *  Terminated：线程已终止，因为run()方法执行完毕。

如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5_size_16_color_FFFFFF_t_70 1]

**当线程启动后，它可以在Runnable、Blocked、Waiting和Timed Waiting这几个状态之间切换，直到最后变成Terminated状态，线程终止**。  
线程终止的原因可能有：

*  线程正常终止：run()方法执行到return语句返回；
 *  线程意外终止：run()方法因为未捕获的异常导致线程终止；
 *  对某个线程的Thread实例调用stop()方法强制终止（强烈不推荐使用），stop()方法已废弃

注意：**为什么stop()方法被废弃，因为它试图强行控制一个给定线程的行为**。当线程要终止另一个线程时，无法知道什么时候调用stop方法是安全的，什么时候导致对象被破坏。因此，该方法被弃用了。在希望停止线程的时候应该中断线程，被中断的线程会在安全的时候停止。  
一个线程还可以等待另一个线程直到其运行结束。例如，main线程在启动t线程后，可以通过t.join()等待t线程结束后再继续运行。

public class Main {
        public static void main(String[] args) throws InterruptedException {
            Thread t = new Thread(() -> { System.out.println("hello"); });
            System.out.println("start");
            t.start();
            t.join();
            System.out.println("end");
        }
    }

当main线程对线程对象t调用join()方法时，主线程将等待变量t表示的线程运行结束，即join就是指等待该线程结束，然后才继续往下执行自身线程。如果t线程已经结束，对实例t调用join()会立刻返回。此外，join(long)的重载方法也可以指定一个等待时间，超过等待时间后就不再继续等待。此外，对已经运行结束的线程调用join()方法会立刻返回。

### 中断线程 ###

如果线程需要执行一个长时间任务，就可能需要能中断线程。中断线程就是其他线程给该线程发一个信号，该线程收到信号后结束执行run()方法，使得自身线程能立刻结束运行。  
中断一个线程非常简单，只需要在其他线程中对目标线程调用interrupt()方法，目标线程需要反复检测自身状态是否是interrupted状态，如果是，就立刻结束运行。示例代码：

public class Main {
        public static void main(String[] args) throws InterruptedException {
            Thread t = new MyThread();
            t.start();
            Thread.sleep(10); // 暂停10毫秒
            t.interrupt(); // 中断t线程
            t.join(); // 等待t线程结束
            System.out.println("end");
        }
    }
    
    class MyThread extends Thread {
        public void run() {
            int n = 0;
            while (! isInterrupted()) {
                n ++;
                System.out.println(n + " hello!");
            }
        }
    }

**仔细看上述代码，main线程通过调用t.interrupt()方法中断t线程，但是要注意，interrupt()方法仅仅向t线程发出了“中断请求”，至于t线程是否能立刻响应，要看具体代码**。而t线程的while循环会检测isInterrupted()，所以上述代码能正确响应interrupt()请求，使得自身立刻结束运行run()方法。  
如果线程处于等待状态，例如，t.join()会让main线程进入等待状态，此时，如果对main线程调用interrupt()，join()方法会立刻抛出InterruptedException，因此，目标线程只要捕获到join()方法抛出的InterruptedException，就说明有其他线程对其调用了interrupt()方法，通常情况下该线程应该立刻结束运行。  
另一个常用的中断线程的方法是设置标志位。我们通常会用一个running标志位来标识线程是否应该继续运行，在外部线程中，通过把HelloThread.running置为false，就可以让线程结束：

public class Main {
        public static void main(String[] args)  throws InterruptedException {
            HelloThread t = new HelloThread();
            t.start();
            Thread.sleep(1);
            t.running = false; // 标志位置为false
        }
    }
    
    class HelloThread extends Thread {
        public volatile boolean running = true;
        public void run() {
            int n = 0;
            while (running) {
                n ++;
                System.out.println(n + " hello!");
            }
            System.out.println("end!");
        }
    }

注意到HelloThread的标志位boolean running是一个线程间共享的变量。**线程间共享变量需要使用volatile关键字标记，确保每个线程都能读取到更新后的变量值**。如果这里如果不加volatile关键字，将影响线程间的可见性，即：**每个线程都有一个高速缓冲副本，在t线程中running值一直为true，这样，上面的例子将一直循环下去**！  
volatile关键字的目的是告诉虚拟机：

*  每次访问变量时，总是获取主内存的最新值；
 *  每次修改变量后，立刻回写到主内存。

volatile关键字解决的是可见性问题：**当一个线程修改了某个共享变量的值，其他线程能够立刻看到修改后的值**。

### 守护线程 ###

当所有线程都运行结束时，JVM退出，进程结束。如果有一个线程没有退出，JVM进程就不会退出。所以，必须保证所有线程都能及时结束。但是有一种线程的目的就是无限循环，例如，一个定时触发任务的线程，如果这个线程不结束，JVM进程就无法结束。问题是，由谁负责结束这个线程？答案是使用守护线程（Daemon Thread）。  
**守护线程是指为其他线程服务的线程。在JVM中，所有非守护线程都执行完毕后，无论有没有守护线程，虚拟机都会自动退出**。  
只要在调用start()方法前，调用setDaemon(true)就把该线程标记为了守护线程：

Thread t = new MyThread();
    t.setDaemon(true);
    t.start();

在守护线程中，编写代码要注意：守护线程不能持有任何需要关闭的资源，例如打开文件等，因为虚拟机退出时，守护线程没有任何机会来关闭文件，这会导致数据丢失。

### 参考资料 ###

**Java核心技术 卷1 基础知识**  
**[https://www.liaoxuefeng.com/wiki/1252599548343744][https_www.liaoxuefeng.com_wiki_1252599548343744]**

### 接下来 ###

#### [Java高并发编程学习（一）多线程基础][Java] ####

#### [Java高并发编程学习（二）线程同步][Java 1] ####

#### [Java高并发编程学习（三）java.util.concurrent包][Java_java.util.concurrent] ####

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200221140557667.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200223170415554.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5,size_16,color_FFFFFF,t_70
[https_www.liaoxuefeng.com_wiki_1252599548343744]: https://www.liaoxuefeng.com/wiki/1252599548343744
[Java]: https://blog.csdn.net/qq_22136439/article/details/104427003
[Java 1]: https://blog.csdn.net/qq_22136439/article/details/104427259
[Java_java.util.concurrent]: https://blog.csdn.net/qq_22136439/article/details/104444867