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

偏执的太偏执、 2024-03-16 22:29 51阅读 0赞

### 1. 线程和进程的区别？ ###

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

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

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

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

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

![在这里插入图片描述][b427f87609f04f50ada2557e9778aa8f.png_pic_center]

**二者对比**

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

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

**单核`CPU`**

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

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

![在这里插入图片描述][d67ce980adf04b7cbb07ee0306010bce.png_pic_center]

![在这里插入图片描述][ed20ac1134984d06aa29233724c4bc40.png_pic_center]

**多核`CPU`**

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

![在这里插入图片描述][4d93bba6a0dd4c70925a307855101e6e.png_pic_center]

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

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

> 举例：
> 
>  *  家庭主妇做饭、打扫卫生、给孩子喂奶，她一个人轮流交替做这多件事，这时就是并发
>  *  家庭主妇雇了个保姆，她们一起这些事，这时既有并发，也有并行（这时会产生竞争，例如锅只有一口，一个人用锅时，另一个人就得等待）
>  *  雇了3个保姆，一个专做饭、一个专打扫卫生、一个专喂奶，互不干扰，这时是并行

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

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

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

① **继承`Thread`类**

public class MyThread extends Thread {
        
    
        @Override
        public 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{
        
    
        @Override
        public 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> {
        
    
        @Override
        public 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() ;
    
            // 创建F
            FutureTask<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{
        
    
        @Override
        public 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`有什么区别？ ###

1.  `Runnable`接口run方法没有返回值；`Callable`接口`call`方法有返回值，是个泛型，和`Future`、`FutureTask`配合可以用来获取异步执行的结果。
2.  `Callalbe`接口支持返回执行结果，需要调用`FutureTask.get()`得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。
3.  `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;
        }

状态之间是如何变化的。

![在这里插入图片描述][b4199ff1bdc249f089ae755ff3e6a3cb.png_pic_center]

分别是：

*  新建
    
     *  当一个线程对象被创建，但还未调用`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 ;     // 线程执行的退出标记
    
        @Override
        public 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);
    
            // 更改标记为true
            t1.flag = true ;
    
        }
    }

② **使用stop方法强行终止**

public class MyInterrupt2 extends Thread {
        
    
        volatile boolean flag = false ;     // 线程执行的退出标记
    
        @Override
        public 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();
    
        }
    }

[b427f87609f04f50ada2557e9778aa8f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/1727447fa05c49d3a1c84c871836ecf7.png
[d67ce980adf04b7cbb07ee0306010bce.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/b64f59976e1c4b47acf485f926f3398c.png
[ed20ac1134984d06aa29233724c4bc40.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/48252345ebe945cb93dbfccc9e1b08cc.png
[4d93bba6a0dd4c70925a307855101e6e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/38badbd71efd4a27810ce5e2745bea1e.png
[b4199ff1bdc249f089ae755ff3e6a3cb.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/307a600405eb4b8f9c52fd9108e203a7.png