线程和进程区别

曾经终败给现在 2023-10-10 23:14 15阅读 0赞

**什么是线程和进程?**

进程

一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间，一个进程可以有多个线程，比如在Windows系统中，一个运行的xx.exe就是一个进程。

线程  
进程中的一个执行任务（控制单元），负责当前进程中程序的执行。一个进程至少有一个线程，一个进程可以运行多个线程，多个线程可共享数据。

**进程与线程的区别**

线程具有许多传统进程所具有的特征，故又称为轻型进程(Light—Weight Process)或进程元；而把传统的进程称为重型进程(Heavy—Weight Process)，它相当于只有一个线程的任务。在引入了线程的操作系统中，通常一个进程都有若干个线程，至少包含一个线程。

**根本区别**：进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位  
**资源开销**：每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小。

**包含关系**：如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线（线程）共同完成的；线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。

**内存分配**：同一进程的线程共享本进程的地址空间和资源，而进程之间的地址空间和资源是相互独立的  
**影响关系**：一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。

**执行过程**：每个独立的进程有程序运行的入口、顺序执行序列和程序出口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制，两者均可并发执行

**什么是上下文切换?**

多线程编程中一般线程的个数都大于 CPU 核心的个数，而一个 CPU 核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU 采取的策略是为每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。概括来说就是：当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态，以便下次再切换回这个任务时，可以再加载这个任务的状态。**任务从保存到再加载的过程就是一次上下文切换**。

Linux 相比与其他操作系统（包括其他类 Unix 系统）有很多的优点，其中有一项就是，其上下文切换和模式切换的时间消耗非常少。

**守护线程和用户线程有什么区别呢？**

守护线程和用户线程

**用户 (User) 线程**：运行在前台，执行具体的任务，如程序的主线程、连接网

络的子线程等都是用户线程

**守护 (Daemon) 线程**：运行在后台，为其他前台线程服务。也可以说守护线程是 JVM 中非守护线程的 **“佣人”**。一旦所有用户线程都结束运行，守护线程

会随 JVM 一起结束工作

main 函数所在的线程就是一个用户线程啊，main 函数启动的同时在 JVM 内部同时还启动了好多守护线程，比如垃圾回收线程。

比较明显的区别之一是用户线程结束，JVM 退出，不管这个时候有没有守护线程运行。而守护线程不会影响 JVM 的退出。

**注意事项：**

1. setDaemon(true)必须在start()方法前执行，否则会抛出

IllegalThreadStateException 异常

2. 在守护线程中产生的新线程也是守护线程  
3. 不是所有的任务都可以分配给守护线程来执行，比如读写操作或者计算逻辑  
4. 守护 (Daemon) 线程中不能依靠 finally 块的内容来确保执行关闭或清理资源的逻辑。因为我们上面也说过了一旦所有用户线程都结束运行，守

护线程会随 JVM 一起结束工作，所以守护 (Daemon) 线程中的 finally 语句块可能无法被执行。

**如何在 Windows 和 Linux 上查找哪个线程cpu利用率最高？**

windows上面用任务管理器看，linux下可以用 top 这个工具看。

1. 找出cpu耗用厉害的进程pid， 终端执行top命令，然后按下shift+p 查找出cpu利用最厉害的pid号  
2. 根据上面第一步拿到的pid号，top -H -p pid 。然后按下shift+p，查找出cpu利用率最厉害的线程号，比如top -H -p 1328   
3. 将获取到的线程号转换成16进制，去百度转换一下就行  
4. 使用jstack工具将进程信息打印输出，jstack pid号 > /tmp/t.dat，比如jstack 31365 > /tmp/t.dat

5. 编辑/tmp/t.dat文件，查找线程号对应的信息

**什么是线程死锁**

百度百科：死锁是指两个或两个以上的进程（线程）在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程（线程）称为死锁进程（线程）。

多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。

如下图所示，线程 A 持有资源 2，线程 B 持有资源 1，他们同时都想申请对方的资源，所以这两个线程就会互相等待而进入死锁状态。

下面通过一个例子来说明线程死锁，代码模拟了上图的死锁的情况 (代码来源于《并发编程之美》)：

<table style="margin-left:19.4pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:26pt;"> 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 </td> 
 <td style="vertical-align:top;width:425pt;"> &nbsp;public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args)&nbsp;{ &nbsp;new&nbsp;Thread(()&nbsp;‐&gt;&nbsp;{ &nbsp;synchronized&nbsp;(resource1)&nbsp;{ &nbsp;System.out.println(Thread.currentThread()&nbsp;+&nbsp;"get resource1");&nbsp;try&nbsp;{ &nbsp;Thread.sleep(1000); &nbsp;}&nbsp;catch&nbsp;(InterruptedException e)&nbsp;{ &nbsp;e.printStackTrace(); &nbsp;} &nbsp;System.out.println(Thread.currentThread()&nbsp;+&nbsp;"waiting get resource2");&nbsp;synchronized&nbsp;(resource2)&nbsp;{ &nbsp;System.out.println(Thread.currentThread()&nbsp;+&nbsp;"get resource2"); &nbsp;} &nbsp;} &nbsp;},&nbsp;"线程&nbsp;1").start(); &nbsp;new&nbsp;Thread(()&nbsp;‐&gt;&nbsp;{ &nbsp;synchronized&nbsp;(resource2)&nbsp;{ &nbsp;System.out.println(Thread.currentThread()&nbsp;+&nbsp;"get resource2");&nbsp;try&nbsp;{ &nbsp;Thread.sleep(1000); &nbsp;}&nbsp;catch&nbsp;(InterruptedException e)&nbsp;{ &nbsp;e.printStackTrace(); &nbsp;} &nbsp;System.out.println(Thread.currentThread()&nbsp;+&nbsp;"waiting get resource1");&nbsp;synchronized&nbsp;(resource1)&nbsp;{ &nbsp;System.out.println(Thread.currentThread()&nbsp;+&nbsp;"get resource1"); &nbsp;} &nbsp;} &nbsp;},&nbsp;"线程&nbsp;2").start(); &nbsp;} } </td> 
 </tr> 
 </tbody> 
</table>

输出结果

<table style="margin-left:19.4pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:24pt;"> 1 </td> 
 <td style="vertical-align:top;width:320pt;"> Thread[线程&nbsp;1,5,main]get&nbsp;resource1 </td> 
 </tr> 
 </tbody> 
</table>

<table style="margin-left:31.3pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:444.2pt;"> 2 Thread[线程&nbsp;2,5,main]get&nbsp;resource2 3 Thread[线程&nbsp;1,5,main]waiting get&nbsp;resource2 4 Thread[线程&nbsp;2,5,main]waiting get&nbsp;resource1 </td> 
 <td style="vertical-align:top;width:4.1pt;"> </td> 
 </tr> 
 </tbody> 
</table>

线程 A 通过 synchronized (resource1) 获得 resource1 的监视器锁，然后通过Thread.sleep(1000)；让线程 A 休眠 1s 为的是让线程 B 得到CPU执行权，然后获取到 resource2 的监视器锁。线程 A 和线程 B 休眠结束了都开始企图请求获取对方的资源，然后这两个线程就会陷入互相等待的状态，这也就产生了死锁。上面的例子符合产生死锁的四个必要条件。

**形成死锁的四个必要条件是什么**

1. 互斥条件：线程(进程)对于所分配到的资源具有排它性，即一个资源只能被一个线程(进程)占用，直到被该线程(进程)释放  
2. 请求与保持条件：一个线程(进程)因请求被占用资源而发生阻塞时，对已获得的资源保持不放。

3. 不剥夺条件：线程(进程)已获得的资源在末使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。

4. 循环等待条件：当发生死锁时，所等待的线程(进程)必定会形成一个环路（类似于死循环），造成永久阻塞

**如何避免线程死锁**

我们只要破坏产生死锁的四个条件中的其中一个就可以了。

**破坏互斥条件**  
这个条件我们没有办法破坏，因为我们用锁本来就是想让他们互斥的（临界资源需要互斥访问）。

**破坏请求与保持条件**

一次性申请所有的资源。

**破坏不剥夺条件**  
占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。

**破坏循环等待条件**

靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。破坏循环等待条件。

我们对线程 2 的代码修改成下面这样就不会产生死锁了。

输出结果

<table style="margin-left:19.4pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:24pt;"> 1 2 3 4 5 6 </td> 
 <td style="vertical-align:top;width:345pt;"> Thread[线程&nbsp;1,5,main]get&nbsp;resource1 Thread[线程&nbsp;1,5,main]waiting get&nbsp;resource2 Thread[线程&nbsp;1,5,main]get&nbsp;resource2 Thread[线程&nbsp;2,5,main]get&nbsp;resource1 Thread[线程&nbsp;2,5,main]waiting get&nbsp;resource2 Thread[线程&nbsp;2,5,main]get&nbsp;resource2 </td> 
 </tr> 
 </tbody> 
</table>

我们分析一下上面的代码为什么避免了死锁的发生?

线程 1 首先获得到 resource1 的监视器锁，这时候线程 2 就获取不到了。然后线程 1 再去获取 resource2 的监视器锁，可以获取到。然后线程 1 释放了对 resource1、resource2 的监视器锁的占用，线程 2 获取到就可以执行了。这样就破坏了破坏循环等待条件，因此避免了死锁。

**创建线程的四种方式**

**创建线程有哪几种方式？**

创建线程有四种方式：

继承 Thread 类；

实现 Runnable 接口；

实现 Callable 接口；

使用 Executors 工具类创建线程池

**继承 Thread 类**

步骤  
1. 定义一个Thread类的子类，重写run方法，将相关逻辑实现，run()方法就是线程要执行的业务逻辑方法

2. 创建自定义的线程子类对象

3. 调用子类实例的star()方法来启动线程

行...");

<table style="margin-left:19.4pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:24pt;"> 5 6 1 2 3 4 5 </td> 
 <td style="vertical-align:top;width:432pt;"> &nbsp;} } public&nbsp;class&nbsp;TheadTest&nbsp;{ &nbsp;public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args)&nbsp;{ &nbsp;MyThread myThread =&nbsp;newMyThread(); &nbsp;myThread.start(); &nbsp;System.out.println(Thread.currentThread().getName()&nbsp;+&nbsp;" main()方法执行结 </td> 
 </tr> 
 </tbody> 
</table>

束");

运行结果

**实现 Runnable 接口**

步骤  
1. 定义Runnable接口实现类MyRunnable，并重写run()方法  
2. 创建MyRunnable实例myRunnable，以myRunnable作为target创建Thead对象，**该Thread对象才是真正的线程对象**  
3. 调用线程对象的start()方法

<table style="margin-left:19.4pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:24pt;"> 1 </td> 
 <td style="vertical-align:top;width:354pt;"> public&nbsp;class&nbsp;MyRunnable&nbsp;implements&nbsp;Runnable&nbsp;{ </td> 
 </tr> 
 </tbody> 
</table>

中...");

<table style="margin-left:19.4pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:24pt;"> 5 6 1 2 3 4 5 6 </td> 
 <td style="vertical-align:top;width:425pt;"> &nbsp;} } public&nbsp;class&nbsp;RunnableTest&nbsp;{ &nbsp;public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args)&nbsp;{ &nbsp;MyRunnable myRunnable =&nbsp;new&nbsp;MyRunnable(); &nbsp;Thread thread =&nbsp;new&nbsp;Thread(myRunnable); &nbsp;thread.start(); &nbsp;System.out.println(Thread.currentThread().getName()&nbsp;+&nbsp;" main()方法执行完 </td> 
 </tr> 
 </tbody> 
</table>

成");

执行结果

**实现 Callable 接口**

步骤

1. 创建实现Callable接口的类myCallable

2. 以myCallable为参数创建FutureTask对象

3. 将FutureTask作为参数创建Thread对象

4. 调用线程对象的start()方法

中...");

<table style="margin-left:19.4pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:24pt;"> 3 </td> 
 <td style="vertical-align:top;width:400pt;"> &nbsp;FutureTask&lt;Integer&gt;&nbsp;futureTask =&nbsp;new&nbsp;FutureTask&lt;Integer&gt;(new </td> 
 </tr> 
 </tbody> 
</table>

MyCallable());

成");

执行结果

**使用 Executors 工具类创建线程池**  
Executors提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。

主要有newFixedThreadPool，newCachedThreadPool，  
newSingleThreadExecutor，newScheduledThreadPool，后续详细介绍这四种线程池

中...");

执行结果

<table style="margin-left:19.4pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:24pt;"> 1 2 3 4 5 6 </td> 
 <td style="vertical-align:top;width:322pt;"> 线程任务开始执行 pool‐1‐thread‐1&nbsp;run()方法执行中... pool‐1‐thread‐1&nbsp;run()方法执行中... pool‐1‐thread‐1&nbsp;run()方法执行中... pool‐1‐thread‐1&nbsp;run()方法执行中... pool‐1‐thread‐1&nbsp;run()方法执行中... </td> 
 </tr> 
 </tbody> 
</table>

**说一下 runnable 和 callable 有什么区别？**

相同点

都是接口

都可以编写多线程程序

都采用Thread.start()启动线程

主要区别

Runnable 接口 run 方法无返回值；Callable 接口 call 方法有返回值，是个泛型，和Future、FutureTask配合可以用来获取异步执行的结果  
Runnable 接口 run 方法只能抛出运行时异常，且无法捕获处理；Callable 接口 call 方法允许抛出异常，可以获取异常信息

**注**：Callalbe接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

**线程的 run()和 start()有什么区别？**

每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，run()方法称为线程体。通过调用Thread类的start()方法来启动一个线程。start() 方法用于启动线程，run() 方法用于执行线程的运行时代码。run() 可以重复调用，而 start() 只能调用一次。

start()方法来启动一个线程，真正实现了多线程运行。调用start()方法无需等待run方法体代码执行完毕，可以直接继续执行其他的代码； 此时线程是处于就绪状态，并没有运行。 然后通过此Thread类调用方法run()来完成其运行状态， run()方法运行结束， 此线程终止。然后CPU再调度其它线程。

run()方法是在本线程里的，只是线程里的一个函数，而不是多线程的。 如果直接调用run()，其实就相当于是调用了一个普通函数而已，直接待用run()方法必须等待run()方法执行完毕才能执行下面的代码，所以执行路径还是只有一条，根本就没有线程的特征，所以在多线程执行时要使用start()方法而不是run()方法。

**为什么我们调用 start() 方法时会执行 run() 方法，为什么我们**

**不能直接调用 run() 方法？**

这是另一个非常经典的 java 多线程面试问题，而且在面试中会经常被问到。很简单，但是很多人都会答不上来！

new 一个 Thread，线程进入了新建状态。调用 start() 方法，会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了。 start() 会执行线程的相应准备工作，然后自动执行 run() 方法的内容，这是真正的多线程工作。

而直接执行 run() 方法，会把 run 方法当成一个 main 线程下的普通方法去执行，并不会在某个线程中执行它，所以这并不是多线程工作。

总结： 调用 start 方法方可启动线程并使线程进入就绪状态，而 run 方法只是 thread 的一个普通方法调用，还是在主线程里执行。

**什么是 Callable 和 Future?**

Callable 接口类似于 Runnable，从名字就可以看出来了，但是 Runnable 不会返回结果，并且无法抛出返回结果的异常，而 Callable 功能更强大一些，被线程执行后，可以返回值，这个返回值可以被 Future 拿到，也就是说，Future 可以拿到异步执行任务的返回值。

Future 接口表示异步任务，是一个可能还没有完成的异步任务的结果。所以说 Callable用于产生结果，Future 用于获取结果。

**什么是 FutureTask**

FutureTask 表示一个异步运算的任务。FutureTask 里面可以传入一个   
Callable 的具体实现类，可以对这个异步运算的任务的结果进行等待获取、判断是否已经完成、取消任务等操作。只有当运算完成的时候结果才能取回，如果运算尚未完成 get 方法将会阻塞。一个 FutureTask 对象可以对调用了   
Callable 和 Runnable 的对象进行包装，由于 FutureTask 也是Runnable 接口的实现类，所以 FutureTask 也可以放入线程池中。