一、线程与进程

进程是计算机中执行中的程序的实例。它是操作系统进行管理和调度的基本单位。

线程，有时被称为轻量级进程，是程序中的一个单独的执行流。它是操作系统调度的最小单位。与进程相比，线程之间的上下文切换通常更为迅速和高效。一个线程就是一个 “执行流”。每个线程之间都可以按照顺讯执行自己的代码、多个线程之间 “同时” 执行着多份代码。

• 进程是操作系统能独立调度的最小单位，而线程是进程中可并发执行的单元；
• 一个应用程序至少包括1个进程，而1个进程包括1个或多个线程；
• 每个进程在执行过程中拥有独立的内存单元，而一个进程的多个线程在执行过程中共享内存。

做一个简单的内比：计算机的CPU就像一个工厂，而进程就是工厂里面的车间，线程就是车间里面的工人。

我们能够发现，多核CPU对应多个工厂，这些工厂可以从事不同的生产任务。比如有炼铁的、炼油的、食品加工等等。在一个工厂中，又可以包含一个或多个车间（进程），但是由于电力资源有限，同一时间就只能有一个车间在运行。换句话说，对于单核CPU，同一时间只能处理一个进程，其他进程处在等待状态。而一个车间中，可以有一个或多个工人（线程）协同工作，他们共享内部资源，共同完成任务。

同一个进程中，这些线程共用同一份资源（内存 + 硬盘…），但是每个线程独立去CPU上调度（状态、上下文、优先级、记账信息…）各自有各自的一份

所以，进程是操作系统进行分配的基本单位。而线程是操作系统进行调度执行的基本单位。

【面试题】谈谈进程和线程的区别和联系

• 进程是包含线程的，都是实现并发编程的方式，但是线程比进程更轻量。

• 进程是系统分配资源的基本单位，线程是系统调度的基本单位。创建进程的时候，把分配资源（虚拟地址空间、文件描述符表）的工作给做了，后面创建线程，直接共用资源即可。

• 进程有独立的地址空间，彼此之间不会相互影响到，进程的独立性。多个线程共用这份地址空间，一个线程一旦抛出异常，就可能会导致进程异常结束。

• 进程和进程之间不共享内存空间，同一个进程的线程之间共享同一个内存空间。

二、创建线程方法

在 Java 中，有两种创建多线程的方式，分别是继承 Thread 类和实现 Runnable 接口。下面让我们一起来学习下这两种创建多线程的方法吧。

1、继承Thread类

1
2
3
4
5
6
7
8
9
10
11
12
13

class Mythread extends Thread{
    public void run() {
        System.out.println("这是线程运行代码!");
    }
}

public class Main {
    public static void main(String[] args) {
    
        Mythread mythread = new Mythread();
        mythread.start();
    }
}

创建一个类，继承 Thread ，重写run方法，该方法包含线程的实际执行逻辑。

start()方法：start() 方法是Thread类的一个方法，它用于启动线程并调用线程的run()方法。
在这个例子中，myThread.start() 会启动一个新的线程，并在新线程中执行 run() 方法中定义的代码。

如果把myThread.start();改成myThread.run();后，运行的结果也是hello world。这两个有什么不一样呢？

run只是上面的入口方法，并没有调用系统api也没有创建真正的线程来。

2、实现Runnable接口

1
2
3
4
5
6
7
8
9
10
11
12
13

class Myrunnable implements Runnable{
    public void run() {
        System.out.println("这是线程运行代码!");
    }
}

public class Main {
    public static void main(String[] args) {

        Thread thread = new Thread(new Myrunnable());
        thread.start();
    }
}

该方法主要是创建一个类，实现 Runnable 接口，重写run方法。

3、两者区别

Thread这里是直接把要完成的工作，放到了Thread的Run方法中

Runnable这里，则是分开了，把要完成的工作放到了Runnable中，再让Runnable和Thread配合。

把线程要执行的任务和线程本身进一步解耦合了。并发编程中，来完成某个工作，使用Runnable描述这个工作的具体细节。这样使用多线程的方式，就可以使用Runnable来搭配线程使用。使用线程池的方式，就可以使用Runnable来搭配线程池使用，使用协议的方式，也可以使用Runnable搭配协程。

4、举个栗子

回到上面的问题。把myThread.start();改成myThread.run();后，运行的结果也是hello world。这两个有什么不一样呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class MyThread extends Thread{
    @Override
    public void run() {
        while(true){
            System.out.println("hello thread");
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        //myThread.run();
        while(true){
            System.out.println("hello main");
        }
    }
}

使用myThread.start();运行的程序，会同时打印hello thread 和 hello main

两个循环都在执行，两个线程分别执行自己的循环，并发性的执行。

而使用myThread.run();运行的程序，只会打印hello main

只执行了一个循环。

5、简洁写法

我们可以通过匿名内部类来Thread和Runnable这两种写法。
什么是匿名内部类？

匿名内部类是一种在声明和创建类的对象同时进行的特殊形式，它没有显式的类名称。这种方式通常用于在使用类的地方定义类的实例，尤其是在创建接口的实现或继承抽象类的实例时。

Ⅰ、Thread匿名内部类写法

1
2
3
4
5
6
7
8
9

public static void main(String[] args) {
    Thread thread = new Thread(){
        @Override
        public void run() {
            System.out.println("这是线程运行代码!");
        }
    };
    thread.start();
}

Ⅱ、Runnable匿名内部类写法

1
2
3
4
5
6
7
8
9

public static void main(String[] args) {
    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
        System.out.println("这是线程运行代码!");
        }
    });
    thread.start();
}

Ⅲ、使用Lambda表达式

Lambda表达式主要用于实现函数式接口，Lambda表达式本质上就是一个匿名函数，像这样的匿名函数可以做回调函数来使用。

匿名函数，就是没有命名的函数。它具有传递函数体的能力，却无需提前声明整个函数的结构。

回调函数则是在程序执行中，不需要程序员主动调用的函数。相反，它会在特定的时机或条件下，由系统或其他代码自动触发执行。程序员通过将函数传递给其他代码，实现了一种回调机制，使得在适当的时候，这个函数会被调用，完成特定的操作。

好了，废话不多说，先用Lambda表达式写一下吧。

1
2
3
4
5
6

public static void main(String[] args) {
    Thread thread = new Thread(() -> {
        System.out.println("这是线程运行代码!");
    });
    thread.start();
}

Thread thread = new Thread(() -> {
这里使用Lambda表达式创建了一个新的Thread对象，构造方法接受一个Runnable接口的实现作为参数。Lambda表达式的内容在大括号中，用于定义线程运行时执行的代码块。