多线程相关面试题详解

最新推荐文章于 2022-06-23 15:39:53 发布

liusCoding

最新推荐文章于 2022-06-23 15:39:53 发布

阅读量764

点赞数

分类专栏： Java并发 Java JVM 文章标签：多线程 java 面试

本文链接：https://blog.csdn.net/liushuai52013/article/details/105684766

版权

1.为什么用多线程？

有时候，系统需要处理非常多的执行时间很短的需求，如果每一个请求都开启一个新线程的话，系统就要不断的进行线程的创建和销毁，有时花在创建和销毁线程上的时间会比线程真正执行的时间还长。
而且线程数量太多时，系统不一定能受得了。

使用线程池主要为了解决一下几个问题：
通过重用线程池中的线程，来减少每个线程创建和销毁的性能开销。
对线程进行一些维护和管理，比如定时开始，周期执行，并发数控制。

2.线程池参数什么意思？

比如去火车站买票，有10个售票窗口，但只有5个窗口对外开放，那么对外开放的5个窗口称为核心线程数。
而最大线程数是10个窗口。如果5个窗口都被占用，那么后来的人就必须在后面排队，但后来售票厅越来越多，已经人满为患，就类似线程队列已满，这时候火车站站长下令，把剩下的5个窗口也打开，也就是目前有10个窗口同时运行。后来又来了一批人。10个窗口也处理不过来了，而且售票厅人已经满了，这时候站长就下令封锁入口，不允许其他人再进来，这就是线程异常处理策略，而线程存活时间指的是，允许售票员休息的最长时间，以此限制售票员偷懒的行为。

3.讲一讲线程池中的ThreadPoolExecutor,每个参数是干什么的？

Executor是一个接口，跟线程池有关的基本都要跟它打交道。ThreadPoolExecutor的关系：
![image.png](
Executor接口很简单，只有一个execute方法。
ExecutorService是Executor的子接口，增加了一些常用的对线程的控制方法，之后使用线程池主要也是使用这些方法。
AbstractExecutorService是一个抽象类。ThreadPoolExecutor就是继承了这个类。

ThreadPoolExecutor的参数：

ThreadPoolExecutor mExecutor = new ThreadPoolExecutor(corePoolSize,// 核心线程数
						maximumPoolSize, // 最大线程数
						keepAliveTime, // 闲置线程存活时间
						TimeUnit.MILLISECONDS,// 时间单位
						new LinkedBlockingDeque<Runnable>(),// 线程队列
						Executors.defaultThreadFactory(),// 线程工厂
						new AbortPolicy()// 队列已满,而且当前线程数已经超过最大线程数时的异常处理策略
				);

corePoolSize:
核心线程数，默认情况下核心线程会一直存活，即使处于闲置状态也不会受存keepAliveTime限制。除非allowCoreThreadTimeOut设置为true。

maximumPoolSize：
线程池所能容纳的最大线程数。超过这个数的线程将被阻塞。当任务队列为没有设置大小的LinkedBlockingDeque时，这个值无效。

keepAliveTime:
非核心线程的闲置超时时间，超过这个时间就会被回收。

unit：
指定keepAliveTime的单位，如TimeUnit.SECONDS。当allowCoreThreadTim他Out，设置为ture时对corePoolSize生效。

woreQueue：
线程池中的任务队列，常有的有三种队列：

SynchronousQueue
LinkedBlockingDeque
ArrayBlockingQueue

**threadFactory:**
线程工厂，提供创建新线程的功能。ThreadFactory是一个接口，只有一个方法： ```java public interface ThreadFactory { Thread newThread(Runnable r); } ``` 通过线程工厂可以对线程的一些属性进行定制。

默认的工厂： ```java static class DefaultThreadFactory implements ThreadFactory { private static final AtomicInteger poolNumber = new AtomicInteger(1); private final ThreadGroup group; private final AtomicInteger threadNumber = new AtomicInteger(1); private final String namePrefix;

DefaultThreadFactory() {
SecurityManager var1 = System.getSecurityManager();
this.group = var1 != null?var1.getThreadGroup():Thread.currentThread().getThreadGroup();
this.namePrefix = “pool-” + poolNumber.getAndIncrement() + “-thread-”;
}

public Thread newThread(Runnable var1) {
Thread var2 = new Thread(this.group, var1, this.namePrefix + this.threadNumber.getAndIncrement(), 0L);
if(var2.isDaemon()) {
var2.setDaemon(false);
}
if(var2.getPriority() != 5) {
var2.setPriority(5);
}
return var2;
}
}


<br />**RejectedExecutionHandler：**<br />RejectedExcutionHandler也是一个接口，只有一个方法：
```java
public interface RejectedExecutionHandler {
  void rejectedExecution(Runnable var1, ThreadPoolExecutor var2);
}

当线程池中的资源已经全部使用，添加新线程被拒绝时，会调用RejectedExcutionHandler的rejectExecution方法。

4.说下线程池内部使用规则？

线程池的线程规则执行跟任务队列有很大的关系：
下面都假设任务队列没有大小限制：

如果线程数量<=核心线程数量，那么直接启动一个核心线程来执行任务，不会放入队列中。

如果线程数量>核心线程数量，但<=最大线程数，并且任务队列是LinkedBlockingDeque的时候，超过核心线程数量的任务会放在任务队列中排队。

如果线程数量>核心线程数，但<=最大线程数，并且任务队列是SynchronousQueue队列的时候，线程池会创建新的线程执行任务，这些任务也不会被放在任务队列中。这些线程属于非核心线程，在任务完成后，闲置时间达到了超时时间就会清除。

如果线程数量>核心线程数，并且>最大线程数，当任务队列是LinkedBlockingDeque，会将超过核心线程的任务放在任务队列中排队。也就是当任务队列是LinkedBlockingDeque并且没有大小限制的时候，线程池的最大线程数设置是无效的，它的线程数最多不会超过核心线程数。

如果线程数量>核心线程数，并且>最大线程数，当任务队列是SynchronousQueue 的时候，会因为线程池拒绝添加任务而抛出异常。

任务队列大小有限时：
当LinkedBlockingDeque 塞满时，新增的任务会直接创建新线程来执行，当创建的线程数量超过最大线程数量时会抛异常。
SynchronousQueue 没有数量限制，因为它根本不保持这些任务，而是直接交给线程池去执行。当任务数量超过最大线程数时会直接抛出异常。

5.用过AtomicInteger吗？怎么用的？

AtomicInteger是Integer类型的原子操作类型，对于全局全量的数值类型操作num++，若没有加synchronized关键字则是线程不安全的，num++,解析为num=num+1,明显，这个操作不具备原子性，多线程操作必然会出现问题。

看代码：

public class AtomicIntegerTest1 {
   
    public static  int  count = 0;

    public static void main(String[] args) throws InterruptedException {
   
        for (int i = 0; i < 10000; i++) {
   
            new Thread(() ->  count ++ ).start();
        }

        TimeUnit.SECONDS.sleep(3);
        System.out.println("count:" + count);
    }
}

**要是换成volatile修饰count变量呢？**
volatile修饰的变量能够在多线程间保持可见性，能被多个线程同时读但是又能保证只被单个线程写，并且不会读取到过期值（由JMM模型中的happen-before原则决定的）volatile修饰字段的写入操作总是由于读操作，即使多个线程同时修改volatile变量字段，总能获取到最新的值。

但是volatile 仅仅保证变量在线程间保持可见性，却依然不能保证非原子性操作。 ```java

/**

@description: volatile 仅仅保证变量在线程间保持可见性，却依然不能保证非原子性操作。
@author: liushuai
@create: 2020-04-17 18:36
**/

public class AtomicIntegerTest2 {
public static volatile int count =0;

public static void main(String[] args) throws InterruptedException {
    for (int i = 0; i < 10000; i++) {
        new Thread(() -> count++).start();
    }

    TimeUnit.SECONDS.sleep(2);
    System.out.println("volatile count:" + count);
}

}


<br />atomicnteger常用方法：
```java
public final int getAndSet(int newValue)       //给AtomicInteger设置newValue并返回加oldValue
public final boolean compareAndSet(int expect, int update)    //如果输入的值和期望值相等就set并返回true/false
public final int getAndIncrement()     //对AtomicInteger原子的加1并返回当前自增前的value
public final int getAndDecrement()   //对AtomicInteger原子的减1并返回自减之前的的value
public final int getAndAdd(int delta)   //对AtomicInteger原子的加上delta值并返加之前的value
public final int incrementAndGet()   //对AtomicInteger原子的加1并返回加1后的值
public final int decrementAndGet()    //对AtomicInteger原子的减1并返回减1后的值
public final int addAndGet(int delta)   //给AtomicInteger原子的加上指定的delta值并返回加后的值

6.用过ThreadLocal吗？怎么用的？

早在JDK1.2的版本中就提供java.lang.ThreadLocal，ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁编写出优美的多线程程序。

ThreadLocal很容易让人望文生义，想当然的认为是一个"本地线程"。

其实，ThreadLocal并不是一个Thread，而是Thread的局部变量，也许把它命名为为ThreadLocalVariable更容易让人理解一些。

ThreadLocal为变量在每个线程中都创建了一个副本，那个每个线程可以访问自己内部的局部变量。

ThreadLocal是一个本地线程副本变量工具类。主要用于将私有线程和该线程存放的副本对象做一个映射，各个线程之间的变量各不干扰，在高并发的场景下，可以实现无状态的调用&#

最低0.47元/天解锁文章

liusCoding

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
多线程相关面试题详解

1.为什么用多线程？有时候，系统需要处理非常多的执行时间很短的需求，如果每一个请求都开启一个新线程的话，系统就要不断的进行线程的创建和销毁，有时花在创建和销毁线程上的时间会比线程真正执行的时间还长。而且线程数量太多时，系统不一定能受得了。使用线程池主要为了解决一下几个问题：通过重用线程池中的线程，来减少每个线程创建和销毁的性能开销。对线程进行一些维护和管理，比如定时开始，周期执行，并发数控制...
复制链接

扫一扫