多线程编程1

一、线程的引入

上节，我们介绍了进程的概念，以及操作系统内核是如何管理进程的（描述+组织），PCB中的核心属性有哪些，

引入进程这个概念，最主要的目的，就是为了解决“并发编程”这样的问题。

为什么我们需要并发编程？

这是因为CPU进入了多核心时代，为了进一步提高程序的执行速度，就需要充分利用CPU的多核资源，这就需要“并发编程”。

多进程编程让大量进程可以在多个CPU核心上运行，程序代码已经能够把CPU的多核资源利用起来了，已经可以解决“并发编程”的问题了。

我们为什么又要学习多线程编程呢？

线程又是什么呢？和进程又有什么关系？

带着这些疑问，我慢慢进行介绍。

二、线程和进程的关系

（1）进程包含线程。一个进程可以包含一个线程，也可以包含多个线程。进程中至少有一个线程，不能没有。

（2）一个线程是通过一个PCB来描述的，PCB对应的是线程，一个线程对应一个PCB，一个进程对应1个或多个PCB。

（3）进程是操作系统资源分配的基本单位，线程是操作系统调度执行的基本单位。同一进程里的多个线程之间共享进程资源。

PCB中的核心属性：pid、内存指针、文件描述符表，这些是进程中的线程共用的。处于同一个进程中的线程，pid相同，内存指针和文件描述符表也是一样的。

PCB中与调度相关的属性：状态、优先级、上下文、记账信息，是每个线程自己有自己的，各自记录各自的。

对于第三点，我再啰嗦几句，希望能加深大家的理解：

同一个进程里的多个线程之间，共用了进程的同一份资源。这里共用的资源主要指的是内存指针和文件描述符表。比如：线程1里new的对象，在线程2,3,4里都可以直接使用（共用内存指针），线程1打开的文件，在线程2,3,4里都可以直接使用（共用文件描述符表）。

操作系统，实际调度的时候，是以线程为单位进行调度的。并不关系进程，只关心线程。谈到调度，就和进程无关了！！上节提到的进程调度，指的是这里的进程只包含一个线程的情况。如果进程中有多个线程，那么每个线程是独立在CPU上调度的。比如，线程1可能在核心A上执行，线程2可能在核心B上执行。线程是操作系统调度执行的基本单位。每个线程都有自己的执行逻辑，我们称为执行流。

三、为什么要使用多线程编程？

多进程和多线程都可以解决并发编程问题，为什么更倾向于使用多线程编程呢？

因为，

进程，太“重”了。创建/销毁/调度一个进程，都需要很大的资源消耗，速度慢。

线程，又叫“轻量级进程”。创建/销毁/调度一个线程，消耗资源少，速度快。

使用多线程编程，会提高效率。

为什么线程比较“轻”？

因为只有在创建第一个线程时，操作系统会进行资源分配（主要指内存指针，文件描述符表），之后创建的第2,3,4...个线程，复用之前的分配的资源，基本不需要操作系统再分配资源。销毁一个线程，也基本不需要释放资源。除非这个进程中只有这一个线程了，才需要释放资源。

而进程就不一样了，创建一个进程，操作系统会进行资源分配，销毁一个进程，要释放资源。创建第二个进程，还需要申请资源，销毁第二个进进程，同样需要释放资源。消耗资源多，速度慢。

因此，由于进程和线程各自的特点，我们一般使用多线程编程，减少资源消耗，提高速度。

四、线程越多越好？多线程会有安全问题吗？

增加线程数量并不是可以一直提高速度。 CPU的核心数量是有限的。线程太多，核心数目有限，不少的开销反而浪费在线程调度上。所以，并不是线程越多越好。

多线程容易出现线程安全问题。

（1）多线程中，共享同一份资源，可能会出现多个线程同时都需要同一个资源的现象（如同一个变量），出现争抢

（2）如果一个线程抛异常，处理不好的话，可能会把整个进程都带走，其它线程也就挂了。

什么时候会出现安全问题？多个执行流访问同一个共享资源的时候。

线程模型，天然就是资源共享的，多线程争抢同一个资源（如同一个变量）非常容易触发。

进程模型，天然就是资源隔离的，不容易触发。只有进行进程间通信时，多个进程访问同一个资源，这时才可能会出问题。

也就是说，多线程会提高效率，但是不如多进程安全。当然，代码写的靠谱，线程安全问题也不怕

五、在Java中如何进行多线程编程？

操作系统提供了操作线程的一系列API。

而Java是一个跨平台的语言，很多操作系统提供的功能，都被JVM给封装好了。我们不需要学习操作系统提供的原生API，只需要学习Java提供的API就行啦。

Java操作多线程，最核心的类是Thread（在java.lang下，不用import）

创建线程，是希望线程成为一个独立的执行流，能执行一段代码。我们可以这样理解，

创建线程，就相当于雇了个人来干活，我们得告诉他要干啥活，他才能去执行。

如何告诉他要干啥活呢？

我们有如下方法，java中创建线程的写法有很多种，如下所示：

继承Thread，重写run方法
实现Runnable接口
使用匿名内部类，继承Thread
使用匿名内部类，实现Runnable接口
使用Lambda表达式

下面分别进行介绍：

1、继承Thread，重写run方法

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

t.start();

start方法是线程中的一个特殊方法，作用是创建一个线程。

在上面代码中，start这个方法创建了一个新的线程，新的线程负责执行run方法，并不是start方法里面调用了run方法，是新的线程调用的run方法。当run方法执行完时，新的线程自然销毁。

那么start是如何创建一个新线程的？

调用操作系统提供的API（系统调用），通过操作系统内核创建新线程的PCB，并且把要执行的指令交给这个PCB，当PCB被调度到CPU上执行的时候，也就执行到了线程run方法中的代码了。

在main方法中直接打印hello world，和在main方法中调用start方法的上述做法有啥区别？

如果只是在main方法中直接打印hello world，这个java进程就只有一个线程（调用main方法的线程），也就是主线程。

在main方法中调用t.start()，是主线程调用start方法创建出一个新的线程，新的线程调用run方法执行其中的代码。这个java进程中有两个线程。

如果把 t.start(); 改成 t.run(); 有什么区别吗？

有很大区别。

是 t.run(); 的话，这个java进程中还是只有一个主线程。所有的活都是主线程一个人干的。因为new Thread对象的操作并不创建线程，只有调用了start方法才是真正创建了PCB，才真正有个货真价实的线程。

2、实现Runnable接口

解耦合，目的是让线程和线程要干的活之间分离开。

未来如果要改代码，不用多线程了，使用多进程，或者线程池，协程......此时代码改动比较小。

//Runnable 作用：描述一个”要执行的任务“， run方法就是执行任务的细节
class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println("hello world");
    }
}
public class ThreadDemo2 {
    public static void main(String[] args) {
        //这只是描述了个任务，就是线程要干的活
        Runnable runnable = new MyRunnable();
        //把任务交给线程来执行
        Thread t = new Thread(runnable);
        t.start();
    }
}

3、使用匿名内部类，继承Thread

public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                System.out.println("hello world");
            }
        };
        t.start();
    }
}

红框框里是一个匿名内部类对象，这里做了两件事：

1、创建了一个Thread的子类，继承Thread类，（子类没有名字，所以才叫“匿名”）。

2、对子类进行实例化（new），让 t 引用指向该实例。

4、使用匿名内部类，实现Runnable接口

public class ThreadDemo4 {
    public static void main(String[] args) {
        Thread t = new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("hello world");
                    }
                }
        );
        t.start();
    }
}

5、使用Lambda表达式

直接把 lambda 传给 Thread 的构造方法

lambda 就是个匿名方法

public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread(
                () -> {
                    System.out.println("hello world");
                }
        );
        t.start();
    }
}