JAVA面试八股文之多线程基础知识

小鱼儿 2024-04-17 09:57 87阅读 0赞

#### Java多线程相关面试题 ####

*   *  1.线程的基础知识
     *   *  1.1 线程和进程的区别？
         *  1.2 并行和并发有什么区别？
         *  1.3 创建线程的四种方式
         *  1.4 runnable 和 callable 有什么区别
         *  1.5 线程的 run()和 start()有什么区别？
         *  1.6 线程包括哪些状态，状态之间是如何变化的
         *  1.7 新建 T1、T2、T3 三个线程，如何保证它们按顺序执行？
         *  1.8 notify()和 notifyAll()有什么区别？
         *  1.9 在 java 中 wait 和 sleep 方法的不同？
         *  1.10 如何停止一个正在运行的线程？

![在这里插入图片描述][d0249fcaf8014dda8acad3c9f6a8b4b6.png]

### 1.线程的基础知识 ###

#### 1.1 线程和进程的区别？ ####

> 难易程度：☆☆
> 
> 出现频率：☆☆☆

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

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

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

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

Java 中，线程作为最小调度单位，进程作为资源分配的最小单位。在 windows 中进程是不活动的，只是作为线程的容器。  
![在这里插入图片描述][c9b08dcd4dd44d59b0e236268199bdda.png]

**二者对比**

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

#### 1.2 并行和并发有什么区别？ ####

> 难易程度：☆
> 
> 出现频率：☆

单核CPU

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

一般会将这种线程轮流使用CPU的做法称为并发（concurrent）  
![在这里插入图片描述][d81a6a0bd4e343549c7cc1548cdab2ad.png]  
![在这里插入图片描述][7003c358a82c4399b29deb135c942760.png]

多核CPU

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

![在这里插入图片描述][9ad5f0db11cd46599ad965e2671137e9.png]

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

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

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

#### 1.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();
    
        }
    
    }

#### 1.4 runnable 和 callable 有什么区别 ####

> 难易程度：☆☆
> 
> 出现频率：☆☆☆

参考回答：

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

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

> 难易程度：☆☆
> 
> 出现频率：☆☆

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

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

#### 1.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;
        }

状态之间是如何变化的  
![在这里插入图片描述][4f4ee4d70a034d19b3cbc3fd88430526.png]

分别是

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

#### 1.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();
    
        }
    
    }

#### 1.8 notify()和 notifyAll()有什么区别？ ####

> 难易程度：☆☆
> 
> 出现频率：☆☆

notifyAll：唤醒所有wait的线程

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

package com.itheima.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();
    
        }
    
    }

#### 1.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...");
            }
        }
    }

#### 1.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方法中断线程**。

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();
    
        }
    }

**后记  
????美好的一天，到此结束，下次继续努力！欲知后续，请看下回分解，写作不易，感谢大家的支持！！ ???**

[d0249fcaf8014dda8acad3c9f6a8b4b6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/a2fa65fd13d645a782738e1d354503b4.png
[c9b08dcd4dd44d59b0e236268199bdda.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/1deda49ea4ac49498114bb4f54a0afde.png
[d81a6a0bd4e343549c7cc1548cdab2ad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/da30987e6c6c44b0a8cc04f6414c03d2.png
[7003c358a82c4399b29deb135c942760.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/b46b5f8cae7240699ebcd9921f5da05f.png
[9ad5f0db11cd46599ad965e2671137e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/b68d8ad561ba432f92da0ec7b540852d.png
[4f4ee4d70a034d19b3cbc3fd88430526.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/34433c04ce7e4cfabec881cae1a6c2c2.png