Java笔试面试题整理第六波（修正版）

本系列整理Java相关的笔试面试知识点，其他几篇文章如下：

 Java笔试面试题整理第八波

 Java笔试面试题整理第七波

 Java笔试面试题整理第六波

 Java笔试面试题整理第五波

 Java笔试面试题整理第四波

 Java笔试面试题整理第三波

 Java笔试面试题整理第二波

 Java笔试面试题整理第一波

1、线程池ThreadPool相关

在java.util.concurrent包下，提供了一系列与线程池相关的类。合理的使用线程池，可以带来多个好处：

（1）降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗；

（2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行；

（3）提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

线程池可以应对突然大爆发量的访问，通过有限个固定线程为大量的操作服务，减少创建和销毁线程所需的时间。

与线程执行、线程池相关类的关系如图：

我们一般通过工具类Executors的静态方法（如newFixedThreadPool()）来获取ThreadPoolExecutor线程池或静态方法（如newScheduledThreadPool()）来获取ScheduleThreadPoolExecutor线程池。如下使用：

ExecutorService threadpool= Executors.newFixedThreadPool(10);

我们指定了获取10个数量的固定线程池，Executors中有很多重载的获取线程池的方法，比如可以通过自定义的ThreadFactory来为每个创建出来的Thread设置更为有意义的名称。Executors创建线程池的方法内部也就是new出新的ThreadPoolExecutor或ScheduleThreadPoolExecutor，给我们配置了很多默认的设置。如下：

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

上面通过ThreadPoolExecutor的构造方法，为我们创建了一个线程池，很多参数Executors工具类自动为我们配置好了。创建一个ThreadPoolExecutor线程池一般需要以下几个参数：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) 

（1）corePoolSize（线程池的基本大小）：当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建。如果调用了线程池的prestartAllCoreThreads方法，线程池会提前创建并启动所有基本线程。

（2）maximumPoolSize（线程池最大大小）：线程池允许创建的最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。值得注意的是如果使用了无界的任务队列这个参数就没什么效果。

（3）keepAliveTime（线程活动保持时间）：线程池的工作线程空闲后，保持存活的时间。所以如果任务很多，并且每个任务执行的时间比较短，可以调大这个时间，提高线程的利用率。

（4）TimeUnit（线程活动保持时间的单位）：可选的单位有天（DAYS），小时（HOURS），分钟（MINUTES），毫秒(MILLISECONDS)等。

（5）workQueue（任务队列）：用于保存等待执行的任务的阻塞队列。 可以选择以下几个阻塞队列：ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue、PriorityBlockingQueue

（6）threadFactory：用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更有意义的名字。

（7）handler（饱和策略）：当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。

我们尽量优先使用Executors提供的静态方法来创建线程池，如果Executors提供的方法无法满足要求，再自己通过ThreadPoolExecutor类来创建线程池。

提交任务的两种方式：

（1）通过execute()方法，如：

ExecutorService threadpool= Executors.newFixedThreadPool(10);
threadpool.execute(new Runnable(){...});

这种方式提交没有返回值，也就不能判断任务是否被线程池执行成功。

（2）通过submit()方法，如：     

Future future = threadpool.submit(new Runnable(){...});
    try {
            Object res = future.get();
        } catch (InterruptedException e) {
            // 处理中断异常
            e.printStackTrace();
        } catch (ExecutionException e) {
            // 处理无法执行任务异常
            e.printStackTrace();
        }finally{
            // 关闭线程池
            executor.shutdown();
        }

使用submit 方法来提交任务，它会返回一个Future对象，通过future的get方法来获取返回值，get方法会阻塞住直到任务完成，而使用get(long timeout, TimeUnit unit)方法则会阻塞一段时间后立即返回，这时有可能任务没有执行完。

线程池工作流程分析：(来自参考文章)

从上图我们可以看出，当提交一个新任务到线程池时，线程池的处理流程如下：

1、首先线程池判断基本线程池是否已满（< corePoolSize ？）？没满，创建一个工作线程来执行任务。满了，则进入下个流程。

2、其次线程池判断工作队列是否已满？没满，则将新提交的任务存储在工作队列里。满了，则进入下个流程。

3、最后线程池判断整个线程池是否已满（< maximumPoolSize ？）？没满，则创建一个新的工作线程来执行任务，满了，则交给饱和策略来处理这个任务。

也就是说，线程池优先要创建出基本线程池大小（corePoolSize）的线程数量，没有达到这个数量时，每次提交新任务都会直接创建一个新线程，当达到了基本线程数量后，又有新任务到达，优先放入等待队列，如果队列满了，才去创建新的线程（不能超过线程池的最大数maxmumPoolSize）。

关于线程池的配置原则可阅读参考文章。

ThreadPoolExecutor简单实例：

public class BankCount {
    public synchronized void addMoney(int money){//存钱
        System.out.println(Thread.currentThread().getName() + ">存入：" + money);
    }

    public synchronized void getMoney(int money){//取钱
        System.out.println(Thread.currentThread().getName() + ">取钱：" + money);
    }
}

测试类：

public class BankTest {
    public static void main(String[] args) {
        final BankCount bankCount = new BankCount();

        ExecutorService executor = Executors.newFixedThreadPool(10);
        executor.execute(new Runnable() {//存钱线程
            @Override
            public void run() {
                int i = 5;
                while(i-- > 0){
                    bankCount.addMoney(200);
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        Future future = executor.submit(new Runnable() {//取钱线程
            @Override
            public void run() {
                int i = 5;
                while(i-- > 0){
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    bankCount.getMoney(200);
                }
            }
        });
        try {
            Object res = future.get();
            System.out.println(res);
        } catch (InterruptedException e) {
            // 处理中断异常
            e.printStackTrace();
        } catch (ExecutionException e) {
            // 处理无法执行任务异常
            e.printStackTrace();
        }finally{
            // 关闭线程池
            executor.shutdown();
        }
    }
}

打印结果如下：

pool-1-thread-1>存入：200

pool-1-thread-1>存入：200

pool-1-thread-2>取钱：200

pool-1-thread-1>存入：200

pool-1-thread-2>取钱：200

pool-1-thread-1>存入：200

pool-1-thread-2>取钱：200

pool-1-thread-1>存入：200

pool-1-thread-2>取钱：200

pool-1-thread-2>取钱：200

null

可以看到，打印出来的future.get()获取的结果为null，这是因为Runnable是没有返回值的，需要返回值要使用Callable，这里就不再细说了，具体可参考如下文章：

http://blog.csdn.net/xiaojin21cen/article/details/41820983

http://icgemu.iteye.com/blog/467848

2、生产者和消费者模型

生产者消费者模型，描述是：有一块缓冲区作为仓库，生产者可以将产品放入仓库，消费者可以从仓库中取走产品。解决消费者和生产者问题的 核心在于保证同一资源被多个线程并发访问时的完整性 。一般采用信号量或加锁机制解决。下面介绍Java中解决生产者和消费者问题主要三种仿：

（1）wait() / notify()、notifyAll()

wait和notify方法是Object的两个方法，因此每个类都会拥有这两个方法。

wait()方法：使当前线程处于等待状态，放弃锁，让其他线程执行。

notify()方法：唤醒其他等待同一个锁的线程，放弃锁，自己处于等待状态。

如下例子：

/**
 * 仓库
 */
public class Storage {
    private static final int MAX_SIZE = 100;//仓库的最大容量
    private List