大家看下下面这段简历，基于对他人的保护打码了无关的内容。
就是这一句"掌握多线程编程知识"，如果自己不是对线程相关的知识有一定了解的话，就会把自己带入无限的深渊。下面咱们就分析一下针对线程，目前都会有哪些高频的面试题。
下面这些问题大家简单看一下，自己先考虑一下怎么回答，最后咱们在给出一些参考。
-
线程的实现方式有哪些？
-
每种线程实现方式创建的线程是怎样启动的？
-
线程的状态都有什么？
-
创建线程池的方式有哪些？
-
说说线程池的状态？
-
说一下线程池的参数？
-
线程池的工作原理聊一下？
-
说一下项目上使用线程池的场景，怎么配的线程池的参数？
-
线上环境有没有出现过一些和线程使用相关的一些问题，怎么排查的？
-
其中还会穿插问一些并发、多线程同步以及限流的问题。
先说一下，上面这几个问题是层层递进，逐渐提高了深度。有一些基本的问题，也有一些较深入的问题。针对初中级，可能有些问题答不太好，但把这些问题抛给一个高开，基本无压力。
1. 线程的实现方式有哪些呢？
其实答出来继承Thread和实现Runnable基本问题不大。如果说大家想把
实现Callable和线程池也说出来的话就更好了。
但是大家一定要对自己说的话负责，就是说能够针对后两种说出来些东西。
比如Callable和Runnable的有哪些不同。
强烈建议大家了解一下这四种方式的使用上的区别
2. 每种线程实现方式创建的线程是怎样启动的
这个问题简单提一下：
继承Thread：创建线程类的对象，然后调用对象的start()方法启动线程；
实现Runnable：创建实现类的对象，再将该对象作为Thread类的构造方法参数
创建Thread类对象，然后调用Thread类对象的start()方法启动线程；
实现Callable：创建实现类的对象，将实现类的对象作为参数传递到FutureTask
构造器中创建FutureTask的对象，将FutureTask的对象作为参数传递到Thread类
的构造器中创建Thread对象，然后调用Thread类对象的start()方法启动线程；3. 线程的状态
下面咱们贴出来一段源码，这些就是线程的状态。大家看一下注释，会对这些状态
有深入的了解
public enum State {
/**
* Thread state for a thread which has not yet started.
*/
NEW,
/**
* Thread state for a runnable thread. A thread in the runnable
* state is executing in the Java virtual machine but it may
* be waiting for other resources from the operating system
* such as processor.
*/
RUNNABLE,
/**
* Thread state for a thread blocked waiting for a monitor lock.
* A thread in the blocked state is waiting for a monitor lock
* to enter a synchronized block/method or
* reenter a synchronized block/method after calling
* {@link Object#wait() Object.wait}.
*/
BLOCKED,
/**
* Thread state for a waiting thread.
* A thread is in the waiting state due to calling one of the
* following methods:
* <ul>
* <li>{@link Object#wait() Object.wait} with no timeout</li>
* <li>{@link #join() Thread.join} with no timeout</li>
* <li>{@link LockSupport#park() LockSupport.park}</li>
* </ul>
*
* <p>A thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called <tt>Object.wait()</tt>
* on an object is waiting for another thread to call
* <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
* that object. A thread that has called <tt>Thread.join()</tt>
* is waiting for a specified thread to terminate.
*/
WAITING,
/**
* Thread state for a waiting thread with a specified waiting time.
* A thread is in the timed waiting state due to calling one of
* the following methods with a specified positive waiting time:
* <ul>
* <li>{@link #sleep Thread.sleep}</li>
* <li>{@link Object#wait(long) Object.wait} with timeout</li>
* <li>{@link #join(long) Thread.join} with timeout</li>
* <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
* <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
* </ul>
*/
TIMED_WAITING,
/**
* Thread state for a terminated thread.
* The thread has completed execution.
*/
TERMINATED;
}
4. 创建线程池的方式
大家自行了解Executors和ThreadPoolExecutor,在此不做赘述。5. 线程池的状态
上源码：
// runState is stored in the high-order bits
private static final int RUNNING = -1 << COUNT_BITS;
private static final int SHUTDOWN = 0 << COUNT_BITS;
private static final int STOP = 1 << COUNT_BITS;
private static final int TIDYING = 2 << COUNT_BITS;
private static final int TERMINATED = 3 << COUNT_BITS;
// 来说一下这些状态：
RUNNABLE：能接受新提交的任务，并且也能处理阻塞队列中的任务；
SHUTDOWN：关闭状态。不在接受新提交的任务，但却可以继续处理阻塞队列中以保存的任务；
STOP：不能接受新任务，也不处理队列中的任务，会中断正在处理任务的线程；
TIDYING：所有的任务都已经终止了，workCount（有效线程数）为0；
TERMINATED：在terminated()方法执行之后进入该状态。线程池的参数和工作原理我们放在一起来说，这里也是我们此篇重点要说内容。
6-7. 线程池的参数和工作原理
上源码：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
// 当前工作的线程数小于核心线程数
if (workerCountOf(c) < corePoolSize) {
// 创建新的线程执行此任务
if (addWorker(command, true))
return;
c = ctl.get();
}
// 检查线程池是否处于运行状态，如果是则把任务添加到队列
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
// 再次检查线程池是否处于运行状态，防止在第一次校验通过后线程池关闭
// 如果是非运行状态，则将刚加入队列的任务移除
if (! isRunning(recheck) && remove(command))
reject(command);
// 如果线程池的线程数为 0 时（当 corePoolSize 设置为 0 时会发生）
else if (workerCountOf(recheck) == 0)
addWorker(null, false); // 新建线程执行任务
}
// 核心线程都在忙且队列都已爆满，尝试新启动一个线程执行失败
else if (!addWorker(command, false))
// 执行拒绝策略
reject(command);
}
1. 自定义线程池的参数：
corePoolSize：表示线程池的常驻核心线程数。如果设置为 0，则表示在没有任何任务时，销毁线程池；如果大于 0，即使没有任务时也会保证线程池的线程数量等于此值。但需要注意，此值如果设置的比较小，则会频繁的创建和销毁线程；如果设置的比较大，则会浪费系统资源，所以需要根据自己的实际业务来调整此值。
maximumPoolSize：表示线程池在任务最多时，最大可以创建的线程数。官方规定此值必须大于 0，也必须大于等于 corePoolSize，此值只有在任务比较多，且不能存放在任务队列时，才会用到。
keepAliveTime：表示线程的存活时间，当线程池空闲时并且超过了此时间，多余的线程就会销毁，直到线程池中的线程数量销毁的等于 corePoolSize 为止，如果 maximumPoolSize 等于 corePoolSize，那么线程池在空闲的时候也不会销毁任何线程。
unit：表示存活时间的单位，它是配合 keepAliveTime 参数共同使用的。
workQueue：表示线程池执行的任务队列，当线程池的所有线程都在处理任务时，如果来了新任务就会缓存到此任务队列中排队等待执行。
threadFactory：表示线程的创建工厂，此参数一般用的比较少，我们通常在创建线程池时不指定此参数，它会使用默认的线程创建工厂的方法来创建线程。
RejectedExecutionHandler：表示指定线程池的拒绝策略，当线程池的任务已经在缓存队列 workQueue 中存储满了之后，并且不能创建新的线程来执行此任务时，就会用到此拒绝策略，它属于一种限流保护的机制。
2. workQueue:
ArrayBlockingQueue：一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。新元素插入到队列的尾部，队列获取操作则是从队列头部开始获得元素。一旦创建了这样的缓存区，就不能再增加其容量。试图向已满队列中放入元素会导致操作受阻塞；试图从空队列中提取元素将导致类似阻塞。
LinkedBlockingQueue：LinkedBlockingQueue的实现是基于链表结构，不是类似ArrayBlockingQueue那样的数组。它可以指定容量也可以不指定容量。由于它具有“无限容量”的特性，所以我还是将它归入了无限队列的范畴（实际上任何无限容量的队列/栈都是有容量的，这个容量就是Integer.MAX_VALUE）。实际使用过程中，不需要关心它的内部实现，如果指定了LinkedBlockingQueue的容量大小，那么它反映出来的使用特性就和ArrayBlockingQueue类似了。
SynchronousQueue：这是一个内部没有任何容量的阻塞队列，任何一次插入操作的元素都要等待相对的删除/读取操作，否则进行插入操作的线程就要一直等待，反之亦然。
PriorityBlockingQueue：一个按照优先级进行内部元素排序的无限队列。存放在PriorityBlockingQueue中的元素必须实现Comparable接口，这样才能通过实现compareTo()方法进行排序。优先级最高的元素将始终排在队列的头部，但并不保证除了队列头部以外的元素排序一定是正确的。
LinkedTransferQueue：是一个无限队列，它除了具有一般队列的操作特性外（先进先出），还具有一个阻塞特性。当生产者将一个新的元素插入队列后，生产者线程将会一直等待，直到某一个消费者线程将这个元素取走，反之亦然。
3. RejectedExecutionHandler:
ThreadPoolExecutor.AbortPolicy：。默认策略。丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.CallerRunsPolicy：由调用线程（提交任务的线程）处理该任务。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列里最前面的一个任务，并执行当前任务。
ThreadPoolExecutor.DiscardPolicy：丢弃任务，不抛异常。
也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化不能处理的任务。
扫一扫
986
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
