JavaEE-进程与线程

1.进程

1.1什么是进程

每个应⽤程序运⾏于现代操作系统之上时，操作系统会提供⼀种抽象，好像系统上只有这个程序在运⾏，所有的硬件资源都被这个程序在使⽤。这种假象是通过抽象了⼀个进程的概念来完成的，进程可以说是计算机科学中最重要和最成功的概念之⼀。

进程是操作系统对⼀个正在运⾏的程序的⼀种抽象，换⾔之，可以把进程看做程序的⼀次运⾏过程；同时，在操作系统内部，进程⼜是操作系统进⾏资源分配的基本单位。

1.2进程控制块抽象(PCB Process Control Block)

计算机内部要管理任何现实事物，都需要将其抽象成⼀组有关联的、互为⼀体的数据。在 Java 语⾔中，我们可以通过类/对象来描述这⼀特征。

// 以下代码是 Java 代码的伪码形式，重在说明，⽆法直接运⾏
class PCB {
 // 进程的唯⼀标识 —— pid;
 // 进程关联的程序信息，例如哪个程序，加载到内存中的区域等
 // 分配给该资源使⽤的各个资源
 // 进度调度信息（留待下⾯讲解）
 }

这样，每⼀个 PCB 对象，就代表着⼀个实实在在运⾏着的程序，也就是进程。

操作系统再通过这种数据结构，例如线性表、搜索树等将 PCB 对象组织起来，⽅便管理时进⾏增删查改的操作。

1.3CPU 分配⸺进程调度（Process Scheduling）

为了便于讨论和理解，我们⼤部分的场景下假设是单CPU单核的计算机。

操作系统对CPU资源的分配，采⽤的是时间模式⸺不同的进程在不同的时间段去使⽤ CPU 资源。

1.4内存分配⸺内存管理（Memory Manage）

操作系统对内存资源的分配，采⽤的是空间模式⸺不同进程使⽤内存中的不同区域，互相之间不会⼲扰。

1.5进程间通信(Inter Process Communication)

如上所述，进程是操作系统进⾏资源分配的最⼩单位，这意味着各个进程互相之间是⽆法感受到对⽅存在的，这就是操作系统抽象出进程这⼀概念的初衷，这样便带来了进程之间互相具备”隔离性

（Isolation）“。

但现代的应⽤，要完成⼀个复杂的业务需求，往往⽆法通过⼀个进程独⽴完成，总是需要进程和进程进⾏配合地达到应⽤的⽬的，如此，进程之间就需要有进⾏“信息交换“的需求。进程间通信的需求就应运⽽⽣。

⽬前，主流操作系统提供的进程通信机制有如下：

1. 管道

2. 共享内存

3. ⽂件

4. ⽹络

5. 信号量

6. 信号

其中，⽹络是⼀种相对特殊的 IPC 机制，它除了⽀持同主机两个进程间通信，还⽀持同⼀⽹络内部⾮同⼀主机上的进程间进⾏通信。

2.认识线程（Thread）

2.1概念

（1）线程是什么

⼀个线程就是⼀个 "执⾏流". 每个线程之间都可以按照顺序执⾏⾃⼰的代码. 多个线程之间 "同时" 执⾏着多份代码.

⼀家公司要去银⾏办理业务，既要进⾏财务转账，⼜要进⾏福利发放，还得进⾏缴社保。

如果只有张三⼀个会计就会忙不过来，耗费的时间特别⻓。为了让业务更快的办理好，张三⼜找来两位同事李四、王五⼀起来帮助他，三个⼈分别负责⼀个事情，分别申请⼀个号码进⾏排队，⾃此就有了三个执⾏流共同完成任务，但本质上他们都是为了办理⼀家公司的业务。

此时，我们就把这种情况称为多线程，将⼀个⼤任务分解成不同⼩任务，交给不同执⾏流就分别排队执⾏。其中李四、王五都是张三叫来的，所以张三⼀般被称为主线程（Main Thread）。

（2）为啥要有线程

⾸先, "并发编程" 成为 "刚需".

• 单核 CPU 的发展遇到了瓶颈. 要想提⾼算⼒, 就需要多核 CPU. ⽽并发编程能更充分利⽤多核 CPU资源.

• 有些任务场景需要 "等待 IO", 为了让等待 IO 的时间能够去做⼀些其他的⼯作, 也需要⽤到并发程.

其次, 虽然多进程也能实现并发编程, 但是线程⽐进程更轻量.

• 创建线程⽐创建进程更快.

• 销毁线程⽐销毁进程更快.

• 调度线程⽐调度进程更快.

最后, 线程虽然⽐进程轻量, 但是⼈们还不满⾜, 于是⼜有了 "线程池"(ThreadPool) 和 "协程"

(Coroutine)

(3)进程与线程的区别

• 进程是包含线程的. 每个进程⾄少有⼀个线程存在，即主线程。

• 进程和进程之间不共享内存空间. 同⼀个进程的线程之间共享同⼀个内存空间.

⽐如，每个客⼾来银⾏办理各⾃的业务，但他们之间的票据肯定是不想让别⼈知道的，否则钱不就被其他⼈取⾛了么。⽽上⾯我们的公司业务中，张三、李四、王五虽然是不同的执⾏流，但因为办理的都是⼀家公司的业务，所以票据是共享着的。这个就是多线程和多进程的最⼤区别。

• 进程是系统分配资源的最⼩单位，线程是系统调度的最⼩单位。

• ⼀个进程挂了⼀般不会影响到其他进程. 但是⼀个线程挂了, 可能把同进程内的其他线程⼀起带⾛(整个进程崩溃).

（4） Java 的线程和操作系统线程的关系

线程是操作系统中的概念. 操作系统内核实现了线程这样的机制, 并且对⽤⼾层提供了⼀些 API 供⽤⼾使⽤(例如 Linux 的 pthread 库).

Java 标准库中 Thread 类可以视为是对操作系统提供的 API 进⾏了进⼀步的抽象和封装.

2.2 第⼀个多线程程序

感受多线程程序和普通程序的区别:

• 每个线程都是⼀个独⽴的执⾏流

• 多个线程之间是 "并发" 执⾏的.

import java.util.Random;

public class ThreadDemo {
 private static class MyThread extends Thread {
     @Override
     public void run() {
         Random random = new Random();
         while (true) {
         // 打印线程名称
             System.out.println(Thread.currentThread().getName());
             try {
                 // 随机停⽌运⾏ 0-9 秒
                 Thread.sleep(random.nextInt(10));
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 }

     public static void main(String[] args) {
         MyThread t1 = new MyThread();
         t1.start();
         Random random = new Random();
         while (true) {
             // 打印线程名称
             System.out.println(Thread.currentThread().getName());
             try {
                 Thread.sleep(random.nextInt(10));
             } catch (InterruptedException e) {
                 // 随机停⽌运⾏ 0-9 秒
                 e.printStackTrace();
             }
         }
     }

}

使⽤ jconsole 命令观察线程

2.3 创建线程

⽅法1 继承 Thread 类

继承 Thread 来创建⼀个线程类.

class MyThread extends Thread {
     @Override
     public void run() {
         System.out.println("这⾥是线程运⾏的代码");
     }
}

创建 MyThread 类的实例

 MyThread t = new MyThread();

调⽤ start ⽅法启动线程

 t.start(); // 线程开始运⾏

⽅法2 实现 Runnable 接⼝

1. 实现 Runnable 接⼝

class MyRunnable implements Runnable {
     @Override
     public void run() {
         System.out.println("这⾥是线程运⾏的代码");
     }
}

2. 创建 Thread 类实例, 调⽤ Thread 的构造⽅法时将 Runnable 对象作为 target 参数.

Thread t = new Thread(new MyRunnable());

3. 调⽤ start ⽅法

t.start(); // 线程开始运⾏

对⽐上⾯两种⽅法:

• 继承 Thread 类, 直接使⽤ this 就表⽰当前线程对象的引⽤.

• 实现 Runnable 接⼝, this 表⽰的是 MyRunnable 的引⽤. 需要使⽤Thread.currentThread()

其他变形

• 匿名内部类创建 Thread ⼦类对象

// 使⽤匿名类创建 Thread ⼦类对象
Thread t1 = new Thread() {
     @Override
     public void run() {
         System.out.println("使⽤匿名类创建 Thread ⼦类对象");
     }
};

• 匿名内部类创建 Runnable ⼦类对象

// 使⽤匿名类创建 Runnable ⼦类对象
Thread t2 = new Thread(new Runnable() {
     @Override
     public void run() {
         System.out.println("使⽤匿名类创建 Runnable ⼦类对象");
     }
});

• lambda 表达式创建 Runnable ⼦类对象

// 使⽤ lambda 表达式创建 Runnable ⼦类对象
Thread t3 = new Thread(() -> System.out.println("使⽤匿名类创建 Thread ⼦类对象"));
Thread t4 = new Thread(() -> {
     System.out.println("使⽤匿名类创建 Thread ⼦类对象");
});

2.4 多线程的优势-增加运⾏速度

可以观察多线程在⼀些场合下是可以提⾼程序的整体运⾏效率的。

• 使⽤ System.nanoTime() 可以记录当前系统的纳秒级时间戳.

• serial 串⾏的完成⼀系列运算. concurrency 使⽤两个线程并⾏的完成同样的运算.

public class ThreadAdvantage {
     // 多线程并不⼀定就能提⾼速度，可以观察，count 不同，实际的运⾏效果也是不同的
     private static final long count = 10_0000_0000;

     public static void main(String[] args) throws InterruptedException {
         // 使⽤并发⽅式
         concurrency();
         // 使⽤串⾏⽅式
         serial();
     }

     private static void concurrency() throws InterruptedException {
         long begin = System.nanoTime();
 
         // 利⽤⼀个线程计算 a 的值
         Thread thread = new Thread(new Runnable() {
             @Override
             public void run() {
                 int a = 0;
                 for (long i = 0; i < count; i++) {
                     a--;
                 }
             }
         });

         thread.start();
         // 主线程内计算 b 的值
         int b = 0;
         for (long i = 0; i < count; i++) {
             b--;
         }
         // 等待 thread 线程运⾏结束
         thread.join();
 
         // 统计耗时
         long end = System.nanoTime();
         double ms = (end - begin) * 1.0 / 1000 / 1000;
         System.out.printf("并发: %f 毫秒%n", ms);
     }


     private static void serial() {
         // 全部在主线程内计算 a、b 的值
         long begin = System.nanoTime();
         int a = 0;
         for (long i = 0; i < count; i++) {
             a--;
         }
         int b = 0;
         for (long i = 0; i < count; i++) {
             b--;
         }
         long end = System.nanoTime();
         double ms = (end - begin) * 1.0 / 1000 / 1000;
         System.out.printf("串⾏: %f 毫秒%n", ms);
     }
}

并发: 399.651856 毫秒

串⾏: 720.616911 毫秒