终于把进程和线程学会了

前言

本篇文章保质保量，内容如下：关注我，不迷路，后续还会加餐哦！！！！
注：打开PC端，到我主页，可以扫面一侧的微信二维码，加我哦，方便交流问题。

一、进程和线程的概念

人人都说：进程（process）是资源分配的最小单位，线程（thread）是CPU调度的最小单位。

太抽象了，不好理解，我们来形象的理解一下。

（一）形象的例子1

这是阮一峰老师的一段比较有意思的介绍：

原地址在：http://www.ruanyifeng.com/blog/2013/04/processes_and_threads.html

为了防止连接失效，还是把原作者的给拿过来了：

1、计算机的核心是CPU，它承担了所有的计算任务。它就像一座工厂，时刻在运行。

2、假定工厂的电力是有限的，一次只能供给一个车间使用。也就是说，一个车间开工的时候，其他车间都必须停工。背后的含义就是，单个CPU一次只能运行一个任务。

3、进程就好比工厂的车间，它代表CPU所能处理的单个任务。任一时刻，CPU总是运行一个进程，其他进程处于非运行状态。

4、一个车间里，可以有很多工人。他们协同完成一个任务。

5、线程就好比车间里的工人。一个进程可以包括多个线程。

6、车间的空间是工人们共享的，比如许多房间是每个工人都可以进出的。这象征一个进程的内存空间是共享的，每个线程都可以使用这些共享内存。

7、可是，每间房间的大小不同，有些房间最多只能容纳一个人，比如厕所。里面有人的时候，其他人就不能进去了。这代表一个线程使用某些共享内存时，其他线程必须等它结束，才能使用这一块内存。

8、一个防止他人进入的简单方法，就是门口加一把锁。先到的人锁上门，后到的人看到上锁，就在门口排队，等锁打开再进去。这就叫"互斥锁"（Mutual exclusion，缩写 Mutex），防止多个线程同时读写某一块内存区域。

9、还有些房间，可以同时容纳n个人，比如厨房。也就是说，如果人数大于n，多出来的人只能在外面等着。这好比某些内存区域，只能供给固定数目的线程使用。

10、这时的解决方法，就是在门口挂n把钥匙。进去的人就取一把钥匙，出来时再把钥匙挂回原处。后到的人发现钥匙架空了，就知道必须在门口排队等着了。这种做法叫做"信号量"（Semaphore），用来保证多个线程不会互相冲突。

​ 不难看出，mutex是semaphore的一种特殊情况（n=1时）。也就是说，完全可以用后者替代前者。但是，因为mutex较为简单，且效率高，所以在必须保证资源独占的情况下，还是采用这种设计。

11、操作系统的设计，因此可以归结为三点：

• （1）以多进程形式，允许多个任务同时运行；
• （2）以多线程形式，允许单个任务分成不同的部分运行；
• （3）提供协调机制，一方面防止进程之间和线程之间产生冲突，另一方面允许进程之间和线程之间共享资源。

（二）形象的例子2

如果还不理解就看这个来自一位知乎的动感例子：

原文连接：https://www.zhihu.com/question/25532384

为了防止连接失效，还是把原作者的给拿过来了：

做个简单的比喻：进程=火车，线程=车厢

• 线程在进程下行进（单纯的车厢无法运行）
• 一个进程可以包含多个线程（一辆火车可以有多个车厢）
• 不同进程间数据很难共享（一辆火车上的乘客很难换到另外一辆火车，比如站点换乘）
• 同一进程下不同线程间数据很易共享（A车厢换到B车厢很容易）
• 进程要比线程消耗更多的计算机资源（采用多列火车相比多个车厢更耗资源）
• 进程间不会相互影响，一个线程挂掉将导致整个进程挂掉（一列火车不会影响到另外一列火车，但是如果一列火车上中间的一节车厢着火了，将影响到所有车厢）
• 进程可以拓展到多机，进程最多适合多核（不同火车可以开在多个轨道上，同一火车的车厢不能在行进的不同的轨道上）
• 进程使用的内存地址可以上锁，即一个线程使用某些共享内存时，其他线程必须等它结束，才能使用这一块内存。（比如火车上的洗手间）－"互斥锁"
• 进程使用的内存地址可以限定使用量（比如火车上的餐厅，最多只允许多少人进入，如果满了需要在门口等，等有人出来了才能进去）－“信号量”

（三）形象的例子3

我们打开QQ、微信、IDEA等运行起来就是在运行一个进程。

当你用QQ打开多个窗口与多人聊天时，这时会QQ这个进程会创建几个线程。

如上图所示，我就用QQ打开了三个窗口进行在聊天中。

（四）进程和线程的概念

进程（process）是资源分配的最小单位，线程（thread）是CPU调度的最小单位

进程（Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。

线程（thread）是操作系统能够进行运算调度的最小单位。它被包含在[进程]之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。

二、进程和线程的特征

• 动态性：进程是程序的执行；
• 并发性：多个进程可同存于内存中，能在一段时间内同时运行；
• 独立性：独立运行的基本单位，独立获得资源和调度的基本单位；
• 异步性：各进程按各自独立的不可预知的速度向前推进；
• 结构特征：由程序段 、数据段、进程控制块（PCB）三部组成。

三、进程一点通

我们要知道：进程有三种基本状态： 进程在生命消亡前处于且仅处于三种基本状态之一；

不同系统设置的进程状态数目不同(但都基于三种基本状态)

（一）进程的三种基本状态

1、就绪状态（Ready）：存在于处理机调度队列中的那些进程，它们已经准备就绪，一旦得到CPU，就立即可以运行。这些进程所处的状态为就绪状态。

2、运行状态（Running）：正在运行的进程所处的状态为运行状态。

3、等待状态（Wait / Blocked ）：若一进程正在等待某一事件发生（如等待输入输出工作完成），这时，即使给它CPU，它也无法运行，称该进程处于等待状态、阻塞、 睡眠、封锁状态。

（二）进程的三种基本状态的转换

三种基本状态的转换如下：

从就绪态–>到运行态；

从运行态–>到就绪态;

从运行态–>到阻塞态;

从阻塞态–>到就绪态。

一般了解到三状态就够了。当然了，还有五状态、七状态、九状态。这些都是在三状态的基础上扩展的，所以是三状态是最重要的。

（三）扩展：进程的五状态模型

除此之外还有2种状态，创建状态和终止状态。

• 新状态（创建）与退出（僵死）状态。
• 新状态（创建状态）是指利用fork系统调用来创建于进程时，被创建的新进程所处的状态；
• 退出状态（僵死状态）是在进程执行了exit系统调用后所处的状态，此时该进程实际上已不存在，但还留下一些信息供父进程搜集。

五状态图如下：

（四）扩展：进程的七状态模型

进程的挂起状态：

引起挂起的原因:终端用户的请求—程序运行期间用户发现问题，希望程序暂停执行，以便研究执行情况或修改程序

父进程的请求：以便考察和修改该子进程，或者协调各子进程间的活动

负荷调节的需要：实时系统的工作负荷重时，挂起一些不重要的进程，保证系统正常运行

操作系统的需要：检查运行中资源使用情况或者进行记帐

引入挂起后的状态转换：

活动就绪—静止就绪

活动阻塞—静止阻塞

静止就绪—活动就绪

静止阻塞—活动阻塞

状态如下：

（五）扩展：进程的九状态模型

被抢占的就绪状态：

“被抢占”状态，也称为“被剥夺状态”。当正在核心态执行的进程要从核心态返回到用户态执行时，如果此时已有一优先级更高的进程在等待处理机，则此时内核可以抢占(剥夺)已分配给正在执行进程的处理机，去调度该优先级更高的进程执行。

这时，被抢占了处理机的进程便转换为“被抢占”状态。处于“被抢占”状态的进程与处于“内存中就绪”状态的进程是等效的，它们都被排列在同一就绪队列中等待再次被调度。

四、线程一点通

（一）有了进程为什么还要线程？

线程的引入

1、引入进程的目的是为了使多个程序并发执行，以改善资源利用率、提高系统吞吐量。

2、引入线程则是为了减少程序并发执行时的所付出的时空开销。

进程是一个可拥有资源的基本单位。

进程同时又是一个可独立调度和分派的基本单位。

进程作为一个资源拥有者，在创建、撤消、切换中，系统必须为之付出较大时空开销。所以系统中进程的数量不宜过多，进程切换的频率不宜过高，但这也就限制了并发程度的进一步提高。

为解决此问题，人们想到将进程的上述两个属性分开，即对作为调度和分派的基本单位，不同时作为独立分配资源的单位；对拥有资源的单位，不对之进行频繁切换。

（二）引入线程的好处

• 1、创建一个新线程花费时间少（结束亦如此）；
• 2、两个线程的切换花费时间少；
• 3、因为同一进程内的线程共享内存和文件，因此它们之间相互通信无须调用内核；
• 4、适合多处理机系统。

（三）线程的五种状态

• 1、创建（new）状态: 准备好了一个多线程的对象，即执行了new Thread(); 创建完成后就需要为线程分配内存
• 2、就绪（runnable）状态: 调用了start()方法, 等待CPU进行调度
• 3、运行（running）状态: 执行run()方法
• 4、阻塞（blocked）状态: 暂时停止执行线程，将线程挂起(sleep()、wait()、join()、没有获取到锁都会使线程阻塞), 可能将资源交给其它线程使用
• 5、死亡（terminated）状态: 线程销毁(正常执行完毕、发生异常或者被打断interrupt()都会导致线程终止)

（四）线程的状态转换模型

五、Java中线程的创建与运行

（一）由Thread的子类创建线程（小朋友数数字）

创建一个类作为Thread类的子类，由它通过继承Thread类并重写其中的run()方法来定义线程体以实现线程的具体行为。

1、创建一个学生类：

/**
 * @Auther: truedei
 * @Date: 2020 /20-7-24 22:56
 * @Description:
 */
public class Student {

    private String name;

    public Student() {
    }

    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

2、创建学生类的线程类：

/**
 * @Auther: truedei
 * @Date: 2020 /20-7-24 22:56
 * @Description:
 */
public class StudentThread extends Thread {

    private Student student;

    public StudentThread(Student student) {
        this.student = student;
    }

    public StudentThread() {

    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("【"+this.student.getName()+"】在查数-->"+i);
        }
    }

}

3、创建测试类：

/**
 * @Auther: truedei
 * @Date: 2020 /20-7-24 23:02
 * @Description:
 */
public class StudentThreadTest {

    public static void main(String[] args) {

        Student xiaohong = new Student("小红");
        Student xiaoming = new Student("小明");

        StudentThread st1 = new StudentThread(xiaohong);
        StudentThread st2 = new StudentThread(xiaoming);

        st1.start();
        st2.start();
    }
}

4、结果：

从结果中可以看出小红和小明是交替着在执行的，而且每一次运行该程序都会有不同的结果。

（二）由Runnable接口实现多线程

1、创建一个StudentRunnable类实现Runnable接口

/**
 * @Auther: truedei
 * @Date: 2020 /20-7-24 23:12
 * @Description:
 */
public class StudentRunnable implements  Runnable {


    private Student student;

    public StudentRunnable(Student student) {
        this.student = student;
    }

    public StudentRunnable() {

    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("【"+this.student.getName()+"】在查数-->"+i);
        }
    }
}

2、创建测试类：

/**
 * @Auther: truedei
 * @Date: 2020 /20-7-24 23:02
 * @Description:
 */
public class StudentRunnableTest {

    public static void main(String[] args) {

        Student xiaohong = new Student("小红");
        Student xiaoming = new Student("小明");

        StudentRunnable st1 = new StudentRunnable(xiaohong);
        StudentRunnable st2 = new StudentRunnable(xiaoming);

        Thread t1 = new Thread(st1);
        t1.start();

        Thread t2 = new Thread(st2);
        t2.start();

    }
}

执行结果都是和第一种是差不多的。

六、进程和多线程面试题总结

（一）来源阿里巴巴(Java方向面经)

1、进程和线程的概念

答：

进程（process）是资源分配的最小单位；

线程（thread）是CPU调度的最小单位。

2、进程或者线程的三个状态

答：

我们要知道：进程有三种基本状态： 进程在生命消亡前处于且仅处于三种基本状态之一；

不同系统设置的进程状态数目不同(但都基于三种基本状态)

（1）进程的三种基本状态

1、就绪状态（Ready）：存在于处理机调度队列中的那些进程，它们已经准备就绪，一旦得到CPU，就立即可以运行。这些进程所处的状态为就绪状态。

2、运行状态（Running）：正在运行的进程所处的状态为运行状态。

3、等待状态（Wait / Blocked ）：若一进程正在等待某一事件发生（如等待输入输出工作完成），这时，即使给它CPU，它也无法运行，称该进程处于等待状态、阻塞、 睡眠、封锁状态。

（2）进程的三种基本状态的转换

三种基本状态的转换如下：

从就绪态–>到运行态；

从运行态–>到就绪态;

从运行态–>到阻塞态;

从阻塞态–>到就绪态。

一般了解到三状态就够了。当然了，还有五状态、七状态、九状态。这些都是在三状态的基础上扩展的，所以是三状态是最重要的。