Java常见面试题（一）多线程相关

1、一个线程两次调用 start() 方法会出现什么情况？谈谈线程的生命周期。
Java 的线程是不允许启动两次的，第二次调用必然会抛出 IllegalThreadStateException，这是一种运行时异常，多次调用 start 被认为是编程错误。

在第二次调用 start() 方法的时候，线程可能处于终止或者其他（非 NEW）状态，但是不论如何，都是不可以再次启动的。

线程生命周期

• 新建（NEW），表示线程被创建出来还没真正启动的状态，可以认为它是个 Java 内部状态。
• 就绪（RUNNABLE），表示该线程已经在 JVM 中执行，当然由于执行需要计算资源，它可能是正在运行，也可能还在等待系统分配给它 CPU 片段，在就绪队列里面排队。
• 阻塞（BLOCKED），这个状态和我们前面两讲介绍的同步非常相关，阻塞表示线程在等待 Monitor lock。比如，线程试图通过 synchronized 去获取某个锁，但是其他线程已经独占了，那么当前线程就会处于阻塞状态。
• 等待（WAITING），表示正在等待其他线程采取某些操作。一个常见的场景是类似生产者消费者模式，发现任务条件尚未满足，就让当前消费者线程等待（wait），另外的生产者线程去准备任务数据，然后通过类似 notify 等动作，通知消费线程可以继续工作了。Thread.join() 也会令线程进入等待状态。
• 计时等待（TIMED_WAIT），其进入条件和等待状态类似，但是调用的是存在超时条件的方法，比如 wait 或 join 等方法。
• 终止（TERMINATED），不管是意外退出还是正常执行结束，线程已经完成使命，终止运行，也有人把这个状态叫作死亡。
  

2、Java程序什么情况下会产生死锁？。
死锁是一种特定的程序状态，在实体之间，由于循环依赖导致彼此一直处于等待之中，没有任何个体可以继续前进。死锁不仅会发生在线程之间会，存在资源独占的进程之间同样也可能出现死锁。
定位死锁常用工具：

• jstack
• jconsole

*如何在编程中尽量预防死锁

• 尽量避免使用多个锁，并且只有需要时才持有锁。
• 如果必须使用多个锁，尽量设计好锁的获取顺序。
• 使用带超时的方法，类似 Object.wait(…) 或者 CountDownLatch.await(…)，都支持 timed_wait，我们完全可以就不假定该锁一定会获得，指定超时时间，并为无法得到锁时准备退出逻辑。

死锁代码示例

public class DeadLockSample extends Thread{
    private String first;
    private String second;
    public DeadLockSample(String name, String first, String second) {
        super(name);
        this.first = first;
        this.second = second;
    }

    public  void run() {
        synchronized (first) {
            System.out.println(this.getName() + " obtained: " + first);
            try {
                Thread.sleep(1000L);
                synchronized (second) {
                    System.out.println(this.getName() + " obtained: " + second);
                }
            } catch (InterruptedException e) {
                /// TODO
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        String lockA = "lockA";
        String lockB = "lockB";
        DeadLockSample t1 = new DeadLockSample("Thread1", lockA, lockB);
        DeadLockSample t2 = new DeadLockSample("Thread2", lockB, lockA);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

3、wait和sleep方法的区别。

• 属于不同的两个类，sleep()方法是线程类（Thread）的静态方法，wait()方法是Object类里的方法。
• sleep()方法不会释放锁，wait()方法释放对象锁，一旦一个对象调用了wait方法，必须要采用notify()和notifyAll()方法唤醒该进程。
• sleep()方法可以在任何地方使用，wait()方法则只能在同步方法或同步块中使用。
• sleep()必须捕获异常，wait()方法、notify()方法和notiftAll()方法不需要捕获异常。
• sleep()使线程进入阻塞状态（线程睡眠），wait()方法使线程进入等待队列（线程挂起），也就是阻塞类别不同。

4、synchronized与Lock的区别

• 首先synchronized是java内置关键字，在jvm层面，Lock是个java。
• synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁。
• synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁。
• .用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了。
• synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）
• Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。

参考：详解synchronized与Lock的区别与使用

5、谈一下线程池类ThreadPoolExecutor各个参数以及参数之间的关系？

public ThreadPoolExecutor(int corePoolSize,

​ int maximumPoolSize,

​ long keepAliveTime,

​ TimeUnit unit,

​ BlockingQueue<Runnable> workQueue,

​ ThreadFactory threadFactory,

​ RejectedExecutionHandler handler)

• corePoolSize：线程池中核心线程数的最大值
• maximumPoolSize：线程池中能拥有最多线程数
• workQueue：用于缓存任务的阻塞队列

我们现在通过向线程池添加新的任务来说明着三者之间的关系。

​ （1）如果没有空闲的线程执行该任务且当前运行的线程数少于corePoolSize，则添加新的线程执行该任务。

​ （2）如果没有空闲的线程执行该任务且当前的线程数等于corePoolSize同时阻塞队列未满，则将任务入队列，而不添加新的线程。

​ （3）如果没有空闲的线程执行该任务且阻塞队列已满同时池中的线程数小于maximumPoolSize，则创建新的线程执行任务。

​ （4）如果没有空闲的线程执行该任务且阻塞队列已满同时池中的线程数等于maximumPoolSize，则根据构造函数中的handler指定的策略来拒绝新的任务。

keepAliveTime：表示空闲线程的存活时间。

• keepAliveTime：表示空闲线程的存活时间。
• 表示keepAliveTime的单位。
• handler：表示当workQueue已满，且池中的线程数达到maximumPoolSize时，线程池拒绝添加新任务时采取的策略。
• threadFactory：指定创建线程的工厂

参考：https://blog.csdn.net/jubaoquan/article/details/79198780 http://www.crazyant.net/2124.html

[ThreadPoolExecutor策略配置以及应用场景](https://segmentfault.com/a/1190000008394155)

6、Executors 提供的线程池有哪几种？ 分别有什么特点？

• newCachedThreadPool()，它是一种用来处理大量短时间工作任务的线程池，具有几个鲜明特点：它会试图缓存线程并重用，当无缓存线程可用时，就会创建新的工作线程；如果线程闲置的时间超过 60 秒，则被终止并移出缓存；长时间闲置时，这种线程池，不会消耗什么资源。其内部使用 SynchronousQueue 作为工作队列。

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

• newFixedThreadPool(int nThreads)，重用指定数目（nThreads）的线程，其背后使用的是无界的工作队列，任何时候最多有 nThreads 个工作线程是活动的。这意味着，如果任务数量超过了活动队列数目，将在工作队列中等待空闲线程出现；如果有工作线程退出，将会有新的工作线程被创建，以补足指定的数目 nThreads。

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

• newSingleThreadExecutor()，它的特点在于工作线程数目被限制为 1，操作一个无界的工作队列，所以它保证了所有任务的都是被顺序执行，最多会有一个任务处于活动状态，并且不允许使用者改动线程池实例，因此可以避免其改变线程数目。

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

• newSingleThreadScheduledExecutor() 和 newScheduledThreadPool(int corePoolSize)，创建的是个 ScheduledExecutorService，可以进行定时或周期性的工作调度， newSingleThreadScheduledExecutor() 是单一工作线程， newScheduledThreadPool(int corePoolSize)是多个工作线程。