常见面试题之线程基础知识

1. 线程和进程的区别？

程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理IO的。

当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。

一个进程之内可以分为一到多个线程。

一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给CPU执行。

Java中，线程作为最小调度单位，进程作为资源分配的最小单位。在windows中进程是不活动的，只是作为线程的容器。

在这里插入图片描述

二者对比

进程是正在运行程序的实例，进程中包含了线程，每个线程执行不同的任务；
不同的进程使用不同的内存空间，在当前进程下的所有线程可以共享内存空间；
线程更轻量，线程上下文切换成本一般上要比进程上下文切换低(上下文切换指的是从一个线程切换到另一个线程)。

2. 并行和并发有什么区别？

单核CPU

单核CPU下线程实际还是串行执行的。
操作系统中有一个组件叫做任务调度器，将cpu的时间片（windows下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于cpu在线程间（时间片很短）的切换非常快，人类感觉是同时运行的。
总结为一句话就是：微观串行，宏观并行。

一般会将这种线程轮流使用CPU的做法称为并发（concurrent）。

在这里插入图片描述

多核CPU

每个核（core）都可以调度运行线程，这时候线程可以是并行的。

在这里插入图片描述

并发（concurrent）是同一时间应对（dealing with）多件事情的能力。

并行（parallel）是同一时间动手做（doing）多件事情的能力。

举例：

家庭主妇做饭、打扫卫生、给孩子喂奶，她一个人轮流交替做这多件事，这时就是并发

家庭主妇雇了个保姆，她们一起这些事，这时既有并发，也有并行（这时会产生竞争，例如锅只有一口，一个人用锅时，另一个人就得等待）

雇了3个保姆，一个专做饭、一个专打扫卫生、一个专喂奶，互不干扰，这时是并行

3. 创建线程的四种方式？

共有四种方式可以创建线程，分别是：继承Thread类、实现runnable接口、实现Callable接口、线程池创建线程。

详细创建方式参考下面代码：

① 继承Thread类

public class MyThread extends Thread {@Overridepublic void run() {System.out.println("MyThread...run...");}public static void main(String[] args) {// 创建MyThread对象MyThread t1 = new MyThread() ;MyThread t2 = new MyThread() ;// 调用start方法启动线程t1.start();t2.start();}}

② 实现runnable接口

public class MyRunnable implements Runnable{@Overridepublic void run() {System.out.println("MyRunnable...run...");}public static void main(String[] args) {// 创建MyRunnable对象MyRunnable mr = new MyRunnable() ;// 创建Thread对象Thread t1 = new Thread(mr) ;Thread t2 = new Thread(mr) ;// 调用start方法启动线程t1.start();t2.start();}}

③ 实现Callable接口

public class MyCallable implements Callable<String> {@Overridepublic String call() throws Exception {System.out.println("MyCallable...call...");return "OK";}public static void main(String[] args) throws ExecutionException, InterruptedException {// 创建MyCallable对象MyCallable mc = new MyCallable() ;// 创建FFutureTask<String> ft = new FutureTask<String>(mc) ;// 创建Thread对象Thread t1 = new Thread(ft) ;Thread t2 = new Thread(ft) ;// 调用start方法启动线程t1.start();// 调用ft的get方法获取执行结果String result = ft.get();// 输出System.out.println(result);}}

④ 线程池创建线程

public class MyExecutors implements Runnable{@Overridepublic void run() {System.out.println("MyRunnable...run...");}public static void main(String[] args) {// 创建线程池对象ExecutorService threadPool = Executors.newFixedThreadPool(3);threadPool.submit(new MyExecutors()) ;// 关闭线程池threadPool.shutdown();}}

4. `runnable`和`callable`有什么区别？

Runnable接口run方法没有返回值；Callable接口call方法有返回值，是个泛型，和Future、FutureTask配合可以用来获取异步执行的结果。
Callalbe接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。
Callable接口的call()方法允许抛出异常；而Runnable接口的run()方法的异常只能在内部消化，不能继续上抛。

5. 线程的`run()`和`start()`有什么区别？

start(): 用来启动线程，通过该线程调用run方法执行run方法中所定义的逻辑代码。start方法只能被调用一次。

run(): 封装了要被线程执行的代码，可以被调用多次。

6. 线程包括哪些状态，状态之间是如何变化的？

线程的状态可以参考JDK中的Thread类中的枚举State。

public enum State {/*** 尚未启动的线程的线程状态*/NEW,/*** 可运行线程的线程状态。处于可运行状态的线程正在 Java 虚拟机中执行，但它可能正在等待来自		 * 操作系统的其他资源，例如处理器。*/RUNNABLE,/*** 线程阻塞等待监视器锁的线程状态。处于阻塞状态的线程正在等待监视器锁进入同步块/方法或在调          * 用Object.wait后重新进入同步块/方法。*/BLOCKED,/*** 等待线程的线程状态。由于调用以下方法之一，线程处于等待状态：* Object.wait没有超时* 没有超时的Thread.join* LockSupport.park* 处于等待状态的线程正在等待另一个线程执行特定操作。* 例如，一个对对象调用Object.wait()的线程正在等待另一个线程对该对象调用Object.notify()			* 或Object.notifyAll() 。已调用Thread.join()的线程正在等待指定线程终止。*/WAITING,/*** 具有指定等待时间的等待线程的线程状态。由于以指定的正等待时间调用以下方法之一，线程处于定          * 时等待状态：* Thread.sleep* Object.wait超时* Thread.join超时* LockSupport.parkNanos* LockSupport.parkUntil* </ul>*/TIMED_WAITING,/*** 已终止线程的线程状态。线程已完成执行*/TERMINATED;}

状态之间是如何变化的。

在这里插入图片描述

分别是：

新建
- 当一个线程对象被创建，但还未调用start方法时处于新建状态；
- 此时未与操作系统底层线程关联；
可运行
- 调用了start方法，就会由新建进入可运行；
- 此时与底层线程关联，由操作系统调度执行；
终结
- 线程内代码已经执行完毕，由可运行进入终结；
- 此时会取消与底层线程关联；
阻塞
- 当获取锁失败后，由可运行进入Monitor的阻塞队列阻塞，此时不占用cpu时间；
- 当持锁线程释放锁时，会按照一定规则唤醒阻塞队列中的阻塞线程，唤醒后的线程进入可运行状态；
等待
- 当获取锁成功后，但由于条件不满足，调用了wait()方法，此时从可运行状态释放锁进入Monitor等待集合等待，同样不占用cpu时间；
- 当其它持锁线程调用notify()或notifyAll()方法，会按照一定规则唤醒等待集合中的等待线程，恢复为可运行状态；
有时限等待
- 当获取锁成功后，但由于条件不满足，调用了wait(long)方法，此时从可运行状态释放锁进入 Monitor等待集合进行有时限等待，同样不占用cpu时间；
- 当其它持锁线程调用notify()或notifyAll()方法，会按照一定规则唤醒等待集合中的有时限等待线程，恢复为可运行状态，并重新去竞争锁；
- 如果等待超时，也会从有时限等待状态恢复为可运行状态，并重新去竞争锁；
- 还有一种情况是调用sleep(long)方法也会从可运行状态进入有时限等待状态，但与Monitor无关，不需要主动唤醒，超时时间到自然恢复为可运行状态；

7. 新建`T1`、`T2`、`T3`三个线程，如何保证它们按顺序执行？

在多线程中有多种方法让线程按特定顺序执行，你可以用线程类的**join()**方法在一个线程中启动另一个线程，另外一个线程完成该线程继续执行。

代码举例：

为了确保三个线程的顺序你应该先启动最后一个(T3调用T2，T2调用T1)，这样T1就会先完成而T3最后完成。

public class JoinTest {public static void main(String[] args) {// 创建线程对象Thread t1 = new Thread(() -> {System.out.println("t1");}) ;Thread t2 = new Thread(() -> {try {t1.join();                          // 加入线程t1,只有t1线程执行完毕以后，再次执行该线程} catch (InterruptedException e) {e.printStackTrace();}System.out.println("t2");}) ;Thread t3 = new Thread(() -> {try {t2.join();                              // 加入线程t2,只有t2线程执行完毕以后，再次执行该线程} catch (InterruptedException e) {e.printStackTrace();}System.out.println("t3");}) ;// 启动线程t1.start();t2.start();t3.start();}}

8. `notify()`和`notifyAll()`有什么区别？

notifyAll：唤醒所有wait的线程；

notify：只随机唤醒一个wait线程；

package com.dcxuexi.basic;public class WaitNotify {static boolean flag = false;static Object lock = new Object();public static void main(String[] args) {Thread t1 = new Thread(() -> {synchronized (lock){while (!flag){System.out.println(Thread.currentThread().getName()+"...wating...");try {lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(Thread.currentThread().getName()+"...flag is true");}});Thread t2 = new Thread(() -> {synchronized (lock){while (!flag){System.out.println(Thread.currentThread().getName()+"...wating...");try {lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(Thread.currentThread().getName()+"...flag is true");}});Thread t3 = new Thread(() -> {synchronized (lock) {System.out.println(Thread.currentThread().getName() + " hold lock");lock.notifyAll();flag = true;try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}});t1.start();t2.start();t3.start();}}

9. 在`java`中`wait`和`sleep`方法的不同？

共同点：

wait() ，wait(long)和sleep(long)的效果都是让当前线程暂时放弃CPU的使用权，进入阻塞状态；

不同点：

方法归属不同
- sleep(long)是Thread的静态方法；
- 而wait()，wait(long)都是Object的成员方法，每个对象都有；
醒来时机不同
- 执行sleep(long)和wait(long)的线程都会在等待相应毫秒后醒来；
- wait(long)和wait()还可以被notify唤醒，wait()如果不唤醒就一直等下去；
- 它们都可以被打断唤醒
锁特性不同（重点）
- wait方法的调用必须先获取wait对象的锁，而sleep则无此限制；
- wait方法执行后会释放对象锁，允许其它线程获得该对象锁（我放弃cpu，但你们还可以用）；
- 而sleep如果在synchronized代码块中执行，并不会释放对象锁（我放弃cpu，你们也用不了）；

代码示例：

public class WaitSleepCase {static final Object LOCK = new Object();public static void main(String[] args) throws InterruptedException {sleeping();}private static void illegalWait() throws InterruptedException {LOCK.wait();}private static void waiting() throws InterruptedException {Thread t1 = new Thread(() -> {synchronized (LOCK) {try {get("t").debug("waiting...");LOCK.wait(5000L);} catch (InterruptedException e) {get("t").debug("interrupted...");e.printStackTrace();}}}, "t1");t1.start();Thread.sleep(100);synchronized (LOCK) {main.debug("other...");}}private static void sleeping() throws InterruptedException {Thread t1 = new Thread(() -> {synchronized (LOCK) {try {get("t").debug("sleeping...");Thread.sleep(5000L);} catch (InterruptedException e) {get("t").debug("interrupted...");e.printStackTrace();}}}, "t1");t1.start();Thread.sleep(100);synchronized (LOCK) {main.debug("other...");}}
}

10. 如何停止一个正在运行的线程？

有三种方式可以停止线程：

使用退出标志，使线程正常退出，也就是当run方法完成后线程终止；
使用stop方法强行终止（不推荐，方法已作废）；
使用interrupt方法中断线程；

代码参考如下：

① 使用退出标志，使线程正常退出。

public class MyInterrupt1 extends Thread {volatile boolean flag = false ;     // 线程执行的退出标记@Overridepublic void run() {while(!flag) {System.out.println("MyThread...run...");try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) throws InterruptedException {// 创建MyThread对象MyInterrupt1 t1 = new MyInterrupt1() ;t1.start();// 主线程休眠6秒Thread.sleep(6000);// 更改标记为truet1.flag = true ;}
}

② 使用stop方法强行终止

public class MyInterrupt2 extends Thread {volatile boolean flag = false ;     // 线程执行的退出标记@Overridepublic void run() {while(!flag) {System.out.println("MyThread...run...");try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) throws InterruptedException {// 创建MyThread对象MyInterrupt2 t1 = new MyInterrupt2() ;t1.start();// 主线程休眠2秒Thread.sleep(6000);// 调用stop方法t1.stop();}
}

③ 使用interrupt方法中断线程。

package com.dcxuexi.basic;public class MyInterrupt3 {public static void main(String[] args) throws InterruptedException {//1.打断阻塞的线程/*Thread t1 = new Thread(()->{System.out.println("t1 正在运行...");try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}}, "t1");t1.start();Thread.sleep(500);t1.interrupt();System.out.println(t1.isInterrupted());*///2.打断正常的线程Thread t2 = new Thread(()->{while(true) {Thread current = Thread.currentThread();boolean interrupted = current.isInterrupted();if(interrupted) {System.out.println("打断状态："+interrupted);break;}}}, "t2");t2.start();Thread.sleep(500);
//        t2.interrupt();}
}