多线程知识整理加面试题

最新推荐文章于 2024-07-31 18:35:11 发布

NY_Forever

最新推荐文章于 2024-07-31 18:35:11 发布

阅读量434

点赞数

分类专栏：多线程 java jvm 文章标签： java

本文链接：https://blog.csdn.net/qq_37530065/article/details/120703347

版权

java 同时被 3 个专栏收录

9 篇文章 1 订阅

订阅专栏

jvm

3 篇文章 0 订阅

订阅专栏

多线程

1 篇文章 0 订阅

订阅专栏

3.实现Callable接口，配合Future使用，可以获取子线程的执行结果（面试题🌟）

2.线程池的使用及问题（面试题🌟）

3.在Springboot中的使用

三、常见问题

前言

大家好，本篇文章将统一整理多线程相关的知识点，过程中会参考各种书籍、文章，并结合自己的实践，附上面试相关的面试题。

一、理论

1.何为线程

1.1概念及比较

进程：进程是程序向操作系统申请资源（如内存空间和文件句柄）的基本单位。

线程：是进程中可独立执行的最小单位

关系：一个进程可以包含多个线程。同一个进程中的所有线程共享该进程中的资源，如内存空间、文件句柄等。进程与线程之间的关系，好比一个营业中的饭店与其正在工作的员工之间的关系。一个营业中的饭店对外为顾客提供餐饮服务，而这种服务最终是通过该饭店的员工的工作实现的。这些工作中的员工有的在迎宾，有的在烹调，有的给顾客上菜。他们在其工作过程中共享该饭店的资源，如食材、餐具、清洁用具等。

1.2线程的生命周期（🌟面试题）

NEW：一个已创建而未启动的线程处于该状态。由于一个线程实例只能够被启动一次，因此一个线程只可能有一次处于该状态。

RUNNABLE：该状态可以被看成一个复合状态。它包括两个子状态：READY和RUNNING。前者表示处于该状态的线程可以被线程调度器（Scheduler）进行调度而使之处于RUNNING状态。后者表示处于该状态的线程正在运行，即相应线程对象的run方法所对应的指令正在由处理器执行。执行Thread.yield()的线程，其状态可能会由RUNNING转换为READY。处于READY子状态的线程也被称为活跃线程。

BLOCKED：一个线程发起一个阻塞式I/O（Blocking I/O）操作后 [12] ，或者申请一个由其他线程持有的独占资源（比如锁）时，相应的线程会处于该状态。处于BLOCKED状态的线程并不会占用处理器资源。当阻塞式I/O操作完成后，或者线程获得了其申请的资源，该线程的状态又可以转换为RUNNABLE。

WAITING：一个线程执行了某些特定方法之后就会处于这种等待其他线程执行另外一些特定操作的状态。能够使其执行线程变更为WAITING状态的方法包括：Object.wait()、Thread.join()和LockSupport.park(Object)。能够使相应线程从WAITING变更为RUNNABLE的相应方法包括：Object.notify()/notifyAll()和LockSupport.unpark(Object))

TIMED_WAITING：该状态和WAITING类似，差别在于处于该状态的线程并非无限制地等待其他线程执行特定操作，而是处于带有时间限制的等待状态。当其他线程没有在指定时间内执行该线程所期望的特定操作时，该线程的状态自动转换为RUNNABLE。

TERMINATED：已经执行结束的线程处于该状态。由于一个线程实例只能够被启动一次，因此一个线程也只可能有一次处于该状态。Thread.run()正常返回或者由于抛出异常而提前终止都会导致相应线程处于该状态。

一个线程在其整个生命周期中，只可能有一次处于NEW状态和TERMINATED状态。

2.多线程产生的安全问题

多线程编程类似于“和尚挑水”的故事：一个和尚挑水喝，两个和尚担水喝，三个和尚没水喝。

我们不难发现增加线程可能会增加单位时间内完成的任务量，即提高程序的计算效率；但它也可能降低程序的计算效率（如故事中最后大家没有水喝），那么为什么多线程的情况下可能会出现问题呢？

2.1JMM内存模型

2.2线程安全问题的影响因素

1.原子性：原子（Atomic）的字面意思是不可分割的（Indivisible）。对于涉及共享变量访问的操作，若该操作从其执行线程以外的任意线程来看是不可分割的，那么该操作就是原子操作，相应地我们称该操作具有原子性

2.内存可见性：在多线程环境下，一个线程对某个共享变量进行更新之后，后续访问该变量的线程可能无法立刻读取到这个更新的结果，甚至永远也无法读取到这个更新的结果。这就是线程安全问题的另外一个表现形式：可见性（Visibility）。

3.有序性：有序性（Ordering）指在什么情况下一个处理器上运行的一个线程所执行的内存访问操作在另外一个处理器上运行的其他线程看来是乱序的（Out of order）。所谓乱序，是指内存访问操作的顺序看起来像是发生了变化。

2.3常见锁的概念

1.可重入锁：可重入性（Reentrancy）描述这样一个问题：一个线程在其持有一个锁的时候能否再次（或者多次）申请该锁。如果一个线程持有一个锁的时候还能够继续成功申请该锁，那么我们就称该锁是可重入的（Reentrant），否则我们就称该锁为非可重入的（Non-reentrant）。

2.排他锁：锁具有排他性（Exclusive），即一个锁一次只能被一个线程持有。因此，这种锁被称为排他锁或者互斥锁（Mutex）

3.显示锁：显式锁（Explicit Lock）是java.util.concurrent.lcoks.Lock接口的实例。显式锁是自JDK 1.5开始引入的排他锁。作为一种线程同步机制，其作用与内部锁相同。它提供了一些内部锁所不具备的特性，但并不是内部锁的替代品。

内部锁：Java平台中的任何一个对象都有唯一一个与之关联的锁。这种锁被称为监视器（Monitor）或者内部锁（Intrinsic Lock）。内部锁是一种排他锁，它能够保障原子性、可见性和有序性。

内部锁是通过synchronized关键字实现的。synchronized关键字可以用来修饰方法以及代码块

4.公平锁、非公平锁

5.读写锁（共享排他锁）：

读写锁的功能是通过其扮演的两种角色——读锁（Read Lock）和写锁（Write Lock）实现的。读线程在访问共享变量的时候必须持有相应读写锁的读锁。读锁是可以同时被多个线程持有的，即读锁是共享的（Shared），一个读线程持有一个读锁的时候并不妨碍其他读线程获得该读锁。写线程在访问共享变量的时候必须持有相应读写锁的写锁。写锁是排他的（Exclusive），即一个线程持有写锁的时候其他线程无法获得相应锁的写锁或读锁。因此，写锁保障了写线程对共享变量的访问（包括更新）是独占的。读锁实际上只是在读线程之间是共享的，任何一个线程持有一个读锁的时候，其他任何线程都无法获得相应锁的写锁。这就保障了读线程在读取共享变量期间没有其他线程能够对这些变量进行

二、实践

1.创建线程的方式

1.继承Thread

2.实现Runnable接口

3.实现Callable接口，配合Future使用，可以获取子线程的执行结果（面试题🌟）

（面试题🌟：开启子线程执行一个任务后，如何获取其执行结果）

future.get();阻塞等待，获取线程的执行结果

future.get(long timeout, TimeUnit unit);阻塞等待，超过timeout时间则不再等待

future.cancel(true);子线程不再继续执行，放弃子任务


public class TestThread {

    public static void main(String[] args) {

        ExecutorService executorService = Executors.newCachedThreadPool();
        MyTask myTask = new MyTask();
        Future<String> future = executorService.submit(myTask);

        try {
            //获取子线程执行结果
            //System.out.println(submit.get());
            //获取子线程执行结果，超过1秒没获取到，则不再获取
            System.out.println(future.get(1, TimeUnit.SECONDS));
        } catch (Exception e) {
            //超时不再执行子任务
            future.cancel(true);
        }
        System.out.println("over");

    }
}

class MyTask implements Callable<String> {

    @Override
    public String call() throws Exception {

        System.out.println(1);
        Thread.sleep(1000l);
        System.out.println(2);
        Thread.sleep(1000l);
        System.out.println(3);
        Thread.sleep(1000l);
        System.out.println(4);
        return "任务完成";
    }
}

4.使用线程池

2.线程池的使用及问题（面试题🌟）

1.线程池核心参数介绍

corePoolSize：核心线程数。创建了线程池时，默认核心线程数为0，当有任务需要处理时才会创建线程（面试题🌟）

maximumPoolSize：最大线程数

keepAliveTime：表示线程没有执行任务时最多保持多久会被回收

unit：时间单位

workQueue：阻塞队列，一般使用LinkedBlockingQueue和SynchronousQueue

threadFactory：线程工厂，主要用来创建线程

handler：拒绝策略

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 默认
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

2.整体运行流程--面试题🌟 （假设：核心线程数：10，最大线程数：15，队列：1000）

线程池创建完成后，核心线程数为0，当有任务需要处理时，则创建线程进行处理，不断的有任务过来，10个核心线程都用完了，此时会将没处理的任务放入等待队列，如果队列中也放不下任务，此时会重新创建线程，当创建的线程数大于15，则对应的任务会根据handle来处理，如丢弃任务、抛出异常，或尝试让主线程处理任务