java代码的复用提现在 java写时复制原理

java中的复用类是什么意思

代码复用能够大大简化我们的工作。面向对象的语言中一般是通过对类的重复使用来达到代码复用的目的的，Java也不例外。在Java中，复用类有两种方式，合成（has-a）与继承（is-a）。合成就是在新的类中直接创建旧类的对象，这里我们复用的只是代码的功能而不是它的形式。而继承是在原有的类的基础上建立一个新类，新类具有旧类的形式，但也加入了一些新的特性。这一章介绍的主要就是合成与继承方面的知识。

荔城网站制作公司哪家好，找成都创新互联公司！从网页设计、网站建设、微信开发、APP开发、成都响应式网站建设等网站项目制作，到程序开发，运营维护。成都创新互联公司自2013年起到现在10年的时间，我们拥有了丰富的建站经验和运维经验，来保证我们的工作的顺利进行。专注于网站建设就选成都创新互联公司。

一、合成所使用的语法

合成的语法很简单，只要把要复用的类的对象的引用直接放到新类里就可以了。当然仅仅这样还是不够的，我们还要创建这个类的对象让那个引用来指向它。因为Java不会帮我们自动创建一个缺省的对象，它只会自动替我们把字段中的引用初始化为null。为引用赋值可以在三个地方，一个就是在定义这个引用的时候，另一个是在构造函数中，第三个地方就是在即将要使用这个对象之前。为了防止忘记在使用前为引用赋值，我们一般应该在前两种场合来创建对象。如果我们要创建的这个对象会花费很大开销，而且又可能不是每次都需要创建它的话，我们可以考虑第三种方式来创建这个对象。

二、继承所使用的语法

继承是Java中的重要部分，因为Java是使用单根体系的（C++不是这样，因为它要保持向C的兼容），所以我们定义的每一个类都是继承自Java中的根类Object类。在定义一个继承自已有的类的类时，要使用extends关键字，其后跟上基类的名字，这样表示新定义的这个类是继承自那个基类。在Java中不允许多重继承（C++中允许），也就是说它不允许一个类拥有多于一个的基类，这点劣势可以用接口来弥补，因为Java允许一个类实现任意多个接口。

一个子类会自动获得基类中的全部字段与方法（那些由访问控制符控制的对子类而言不可见的成员也会获得，只是不可见，用不了），这也就是对基类中代码的复用。除了自动获得自基类的代码外，子类中还可定义新的成员，也可以覆写基类中的方法（所谓覆写指的是方法的声明部分一样但实现不一样），这样可以让相同签名的方法拥有不一样的形为。

因为子类自动拥有了基类的成员，因此在子类中自然就可以调用基类的方法。如果这个方法在子类中被覆写过，那编译器知道你是要调用哪个方法呢？Java提供了super关键字在类中表示该类的基类的引用，我们可以通过这个关键字来明确表示我们要用到的是基类中的成员。如果不写super的话，那编译器将会理解为嵌套调用。

这里有个题外话。在Java程序中常常是用public类中的main()方法做为整个程序的入口。这样的静态main()方法并不是非得要在public类中才能出现的，静态的main()方法可以做所有类的入口（但只能是main()，而不能是其它名字的什么静态方法）。比如一个程序有多个class组成，我们要对其中的某个class进行单元测试时，我们就可以在这个class文件中加入main()，编译后生成这个类的.class文件，在控制台通过java来运行它就是了。

子类继承了一个基类后便拥有了基类中的成员，也就可以通过创建的子类对象来访问基类中可见的成员。Java是怎样做到这一点的呢？在我们创建一个子类对象的时候，这里创建的已经不是一个类的对象了，它还会创建这个类的基类的对象，这个基类的对象创建后被包括在子类的对象中。也就是说创建的子类的对象拥有其基类全部的成员（从这就可以知道为什么可以上传），但是子类对象只能访问基类中它可见的成员。那么在创建一个这样的对象时，子类和基类对象创建的顺序是怎么样的呢？为了能够正确的初始化基类，一般会调用基类的构造函数来进行初始化。Java中在调用子类的构造函数时首先会自动的调用基类的构造函数，并且这样的过程是层层传递的。比如C继承了B，而B又继承了A，在创建C的对象时，C的构造函数会首先调用B的构造函数，这时B的构造函数又会首先调用A的构造函数。（如果基类中没有默认构造函数，编译时就会报错。）但是这里自动调用的都是基类的默认构造函数（无参的），如果我们想调用基类的某个带参数的构造函数又该怎么办呢？上面提到可以用super来代替基类的引用，与在构造函数中通过this调用本类其它构造函数的形式一样，我们可以通过super来调用基类带参数的构造函数，比如“super(i, j)”。与调用本类的其它构造函数一样，对基类构造函数的显示调用也需要放在子类构造函数的最前面，在它之前不能有任何东西，如果基类的构造函数会抛出异常需要捕获的话，就会比较麻烦。

简述JAVA中继承实现代码复用

看看下面这个例子，就会明白了：JAVA中继承可以实现代码复用，

由于在父类中已经定义的方法，被子类继承以后，就可以使用，实现了代码的复用

class Father{

private int moneyDollar=300;

int moneyHK=200;

int add(int x,int y){

return x+y;

}

}

class Son extends Father{

int moneyRMB=800;

public void changMoneyHK(int x){

moneyHK=x;

}

public void changMoneyRMB(int x){

moneyRMB=x;

}

int subs(int x,int y){

return x-y;

}

}

class GrandSon extends Son{

int multi(int x,int y){

return x*y;

}

}

public class Example5_1{

public static void main(String args[]){

int a=5,b=3;

Son son=new Son();

GrandSon sunzi=new GrandSon();

son.changMoneyHK(666);

son.changMoneyRMB(5000);

System.out.println("儿子的港币是继承的属性,当前的值是:"+son.moneyHK);

System.out.println("儿子的人民币是新增的属性,当前的值是:"+son.moneyRMB);

System.out.printf("减法是儿子新增的功能,%d-%d等于%d\n",a,b,son.subs(a,b));

System.out.printf("加法是儿子继承的功能,%d+%d等于%d\n",a,b,son.add(a,b));

System.out.println("孙子的港币和人民币都是继承的属性,,当前的值是:");

System.out.println("港币:"+sunzi.moneyHK+" 人民币:"+sunzi.moneyRMB);

System.out.printf("乘法是孙子新增的功能,%d*%d等于%d\n",a,b,sunzi.multi(a,b));

System.out.printf("加法是孙子继承的功能,%d+%d等于%d\n",a,b,sunzi.add(a,b));

System.out.printf("减法是孙子继承的功能,%d-%d等于%d\n",a,b,sunzi.subs(a,b));

}

}

java三大特征

Java三大特性

Java语言的三大特性即是：封装、继承、多态

封装：

首先，属性可用来描述同一类事物的特征，方法可描述一类事物可做的操作。封装就是把属于同一类事物的共性（包括属性与方法）归到一个类中，以方便使用。

1.概念：封装也称为信息隐藏，是指利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。系统的其他部分只有通过包裹在数据外面的被授权的操作来与这个抽象数据类型交流与交互。也就是说，用户无需知道对象内部方法的实现细节，但可以根据对象提供的外部接口(对象名和参数)访问该对象。

2.好处：(1)实现了专业的分工。将能实现某一特定功能的代码封装成一个独立的实体后，各程序员可以在需要的时候调用，从而实现了专业的分工。(2)隐藏信息，实现细节。通过控制访问权限可以将可以将不想让客户端程序员看到的信息隐藏起来，如某客户的银行的密码需要保密，只能对该客户开发权限。

继承：

就是个性对共性的属性与方法的接受，并加入个性特有的属性与方法

1.概念：一个类继承另一个类，则称继承的类为子类，被继承的类为父类。

2.目的：实现代码的复用。

3.理解：子类与父类的关系并不是日常生活中的父子关系，子类与父类而是一种特殊化与一般化的关系，是is-a的关系，子类是父类更加详细的分类。如class dog extends animal,就可以理解为dog is a animal.注意设计继承的时候，若要让某个类能继承，父类需适当开放访问权限，遵循里氏代换原则，即向修改关闭对扩展开放，也就是开-闭原则。

4.结果：继承后子类自动拥有了父类的属性和方法，但特别注意的是，父类的私有属性和构造方法并不能被继承。

另外子类可以写自己特有的属性和方法，目的是实现功能的扩展，子类也可以复写父类的方法即方法的重写。

多态：

多态的概念发展出来，是以封装和继承为基础的。

多态就是在抽象的层面上实施一个统一的行为，到个体（具体）的层面上时，这个统一的行为会因为个体（具体）的形态特征而实施自己的特征行为。（针对一个抽象的事，对于内部个体又能找到其自身的行为去执行。）

1.概念：相同的事物，调用其相同的方法，参数也相同时，但表现的行为却不同。

2.理解：子类以父类的身份出现，但做事情时还是以自己的方法实现。子类以父类的身份出现需要向上转型(upcast)，其中向上转型是由JVM自动实现的，是安全的，但向下转型(downcast)是不安全的，需要强制转换。子类以父类的身份出现时自己特有的属性和方法将不能使用。

Java线程池中的核心线程是如何被重复利用的

Java线程池中的核心线程是如何被重复利用的？

引言

在Java开发中，经常需要创建线程去执行一些任务，实现起来也非常方便，但如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。此时，我们很自然会想到使用线程池来解决这个问题。

使用线程池的好处：

降低资源消耗。java中所有的池化技术都有一个好处，就是通过复用池中的对象，降低系统资源消耗。设想一下如果我们有n多个子任务需要执行，如果我们为每个子任务都创建一个执行线程，而创建线程的过程是需要一定的系统消耗的，最后肯定会拖慢整个系统的处理速度。而通过线程池我们可以做到复用线程，任务有多个，但执行任务的线程可以通过线程池来复用，这样减少了创建线程的开销，系统资源利用率得到了提升。

降低管理线程的难度。多线程环境下对线程的管理是最容易出现问题的，而线程池通过框架为我们降低了管理线程的难度。我们不用再去担心何时该销毁线程，如何最大限度的避免多线程的资源竞争。这些事情线程池都帮我们代劳了。

提升任务处理速度。线程池中长期驻留了一定数量的活线程，当任务需要执行时，我们不必先去创建线程，线程池会自己选择利用现有的活线程来处理任务。

很显然，线程池一个很显著的特征就是“长期驻留了一定数量的活线程”，避免了频繁创建线程和销毁线程的开销，那么它是如何做到的呢？我们知道一个线程只要执行完了run()方法内的代码，这个线程的使命就完成了，等待它的就是销毁。既然这是个“活线程”，自然是不能很快就销毁的。为了搞清楚这个“活线程”是如何工作的，下面通过追踪源码来看看能不能解开这个疑问。

分析方法

在分析源码之前先来思考一下要怎么去分析，源码往往是比较复杂的，如果知识储备不够丰厚，很有可能会读不下去，或者读岔了。一般来讲要时刻紧跟着自己的目标来看代码，跟目标关系不大的代码可以不理会它，一些异常的处理也可以暂不理会，先看正常的流程。就我们现在要分析的源码而言，目标就是看看线程是如何被复用的。那么对于线程池的状态的管理以及非正常状态下的处理代码就可以不理会，具体来讲，在ThreadPollExcutor类中，有一个字段 private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); 是对线程池的运行状态和线程池中有效线程的数量进行控制的， 它包含两部分信息: 线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount)，还有几个对ctl进行计算的方法:

// 获取运行状态

private static int runStateOf(int c)     { return c ~CAPACITY; }

// 获取活动线程数

private static int workerCountOf(int c)  { return c CAPACITY; }123456

以上两个方法在源码中经常用到，结合我们的目标，对运行状态的一些判断及处理可以不用去管，而对当前活动线程数要加以关注等等。

下面将遵循这些原则来分析源码。

解惑

当我们要向线程池添加一个任务时是调用ThreadPollExcutor对象的execute(Runnable command)方法来完成的，所以先来看看ThreadPollExcutor类中的execute(Runnable command)方法的源码：

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);

 else if (workerCountOf(recheck) == 0)

     addWorker(null, false);

}

else if (!addWorker(command, false))

 reject(command);

}123456789101112131415161718192021

按照我们在分析方法中提到的一些原则，去掉一些相关性不强的代码，看看核心代码是怎样的。

// 为分析而简化后的代码

public void execute(Runnable command) {

int c = ctl.get();

if (workerCountOf(c) corePoolSize) {

 // 如果当前活动线程数小于corePoolSize，则新建一个线程放入线程池中，并把任务添加到该线程中

 if (addWorker(command, true))

     return;

 c = ctl.get();

}

// 如果当前活动线程数大于等于corePoolSize，则尝试将任务放入缓存队列

if (workQueue.offer(command)) {

 int recheck = ctl.get();

 if (workerCountOf(recheck) == 0)

     addWorker(null, false);

}else {

 // 缓存已满，新建一个线程放入线程池，并把任务添加到该线程中（此时新建的线程相当于非核心线程）

 addWorker(command, false)

}

}12345678910111213141516171819202122

这样一看，逻辑应该清晰很多了。

如果 当前活动线程数 指定的核心线程数，则创建并启动一个线程来执行新提交的任务（此时新建的线程相当于核心线程）；

如果 当前活动线程数 = 指定的核心线程数，且缓存队列未满，则将任务添加到缓存队列中；

如果 当前活动线程数 = 指定的核心线程数，且缓存队列已满，则创建并启动一个线程来执行新提交的任务（此时新建的线程相当于非核心线程）；

接下来看 addWorker(Runnable firstTask, boolean core)方法

private boolean addWorker(Runnable firstTask, boolean core) {

retry:

for () {

 int c = ctl.get();

 int rs = runStateOf(c);

 // Check if queue empty only if necessary.

 if (rs = SHUTDOWN

     ! (rs == SHUTDOWN

        firstTask == null

        ! workQueue.isEmpty()))

     return false;

 for () {

     int wc = workerCountOf(c);

     if (wc = CAPACITY ||

         wc = (core ? corePoolSize : maximumPoolSize))

         return false;

     if (compareAndIncrementWorkerCount(c))

         break retry;

     c = ctl.get();  // Re-read ctl

     if (runStateOf(c) != rs)

         continue retry;

     // else CAS failed due to workerCount change; retry inner loop

 }

}

boolean workerStarted = false;

boolean workerAdded = false;

Worker w = null;

try {

 w = new Worker(firstTask);

 final Thread t = w.thread;

 if (t != null) {

     final ReentrantLock mainLock = this.mainLock;

     mainLock.lock();

     try {

         // Recheck while holding lock.

         // Back out on ThreadFactory failure or if

         // shut down before lock acquired.

         int rs = runStateOf(ctl.get());

         if (rs SHUTDOWN ||

             (rs == SHUTDOWN firstTask == null)) {

             if (t.isAlive()) // precheck that t is startable

                 throw new IllegalThreadStateException();

             workers.add(w);

             int s = workers.size();

             if (s largestPoolSize)

                 largestPoolSize = s;

             workerAdded = true;

         }

     } finally {

         mainLock.unlock();

     }

     if (workerAdded) {

         t.start();

         workerStarted = true;

     }

 }

} finally {

 if (! workerStarted)

     addWorkerFailed(w);

}

return workerStarted;

}12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667

同样，我们也来简化一下：

// 为分析而简化后的代码

private boolean addWorker(Runnable firstTask, boolean core) {

int wc = workerCountOf(c);

if (wc = (core ? corePoolSize : maximumPoolSize))

 // 如果当前活动线程数 = 指定的核心线程数，不创建核心线程

 // 如果当前活动线程数 = 指定的最大线程数，不创建非核心线程  

 return false;

boolean workerStarted = false;

boolean workerAdded = false;

Worker w = null;

try {

 // 新建一个Worker，将要执行的任务作为参数传进去

 w = new Worker(firstTask);

 final Thread t = w.thread;

 if (t != null) {

     workers.add(w);

     workerAdded = true;

     if (workerAdded) {

         // 启动刚刚新建的那个worker持有的线程，等下要看看这个线程做了啥

         t.start();

         workerStarted = true;

     }

 }

} finally {

 if (! workerStarted)

     addWorkerFailed(w);

}

return workerStarted;

}1234567891011121314151617181920212223242526272829303132

看到这里，我们大概能猜测到，addWorker方法的功能就是新建一个线程并启动这个线程，要执行的任务应该就是在这个线程中执行。为了证实我们的这种猜测需要再来看看Worker这个类。

private final class Worker

extends AbstractQueuedSynchronizer

implements Runnable{

// ....

}

Worker(Runnable firstTask) {

setState(-1); // inhibit interrupts until runWorker

this.firstTask = firstTask;

this.thread = getThreadFactory().newThread(this);

}123456789101112

从上面的Worker类的声明可以看到，它实现了Runnable接口，以及从它的构造方法中可以知道待执行的任务赋值给了它的变量firstTask，并以它自己为参数新建了一个线程赋值给它的变量thread，那么运行这个线程的时候其实就是执行Worker的run()方法，来看一下这个方法：

public void run() {

 runWorker(this);

}

final void runWorker(Worker w) {

Thread wt = Thread.currentThread();

Runnable task = w.firstTask;

w.firstTask = null;

w.unlock(); // allow interrupts

boolean completedAbruptly = true;

try {

 while (task != null || (task = getTask()) != null) {

     w.lock();

     // If pool is stopping, ensure thread is interrupted;

     // if not, ensure thread is not interrupted.  This

     // requires a recheck in second case to deal with

     // shutdownNow race while clearing interrupt

     if ((runStateAtLeast(ctl.get(), STOP) ||

          (Thread.interrupted()

           runStateAtLeast(ctl.get(), STOP)))

         !wt.isInterrupted())

         wt.interrupt();

     try {

         beforeExecute(wt, task);

         Throwable thrown = null;

         try {

             task.run();

         } catch (RuntimeException x) {

             thrown = x; throw x;

         } catch (Error x) {

             thrown = x; throw x;

         } catch (Throwable x) {

             thrown = x; throw new Error(x);

         } finally {

             afterExecute(task, thrown);

         }

     } finally {

         task = null;

         w点抗 pletedTasks++;

         w.unlock();

     }

 }

 completedAbruptly = false;

} finally {

 processWorkerExit(w, completedAbruptly);

}

}123456789101112131415161718192021222324252627282930313233343536373839404142434445464748

在run()方法中只调了一下 runWorker(this) 方法，再来简化一下这个 runWorker() 方法

// 为分析而简化后的代码

final void runWorker(Worker w) {

Runnable task = w.firstTask;

w.firstTask = null;

while (task != null || (task = getTask()) != null) {

     try {

         task.run();

     } finally {

         task = null;

     }

 }

}12345678910111213

很明显，runWorker()方法里面执行了我们新建Worker对象时传进去的待执行的任务，到这里为止貌似这个worker的run()方法就执行完了，既然执行完了那么这个线程也就没用了，只有等待虚拟机销毁了。那么回顾一下我们的目标：Java线程池中的核心线程是如何被重复利用的？好像并没有重复利用啊，新建一个线程，执行一个任务，然后就结束了，销毁了。没什么特别的啊，难道有什么地方漏掉了，被忽略了？再仔细看一下runWorker()方法的代码，有一个while循环，当执行完firstTask后task==null了，那么就会执行判断条件 (task = getTask()) != null，我们假设这个条件成立的话，那么这个线程就不止只执行一个任务了，可以执行多个任务了，也就实现了重复利用了。答案呼之欲出了，接着看getTask()方法

private Runnable getTask() {

boolean timedOut = false; // Did the last poll() time out?

for () {

 int c = ctl.get();

 int rs = runStateOf(c);

 // Check if queue empty only if necessary.

 if (rs = SHUTDOWN (rs = STOP || workQueue.isEmpty())) {

     decrementWorkerCount();

     return null;

 }

 int wc = workerCountOf(c);

 // Are workers subject to culling?

 boolean timed = allowCoreThreadTimeOut || wc corePoolSize;

 if ((wc maximumPoolSize || (timed timedOut))

      (wc 1 || workQueue.isEmpty())) {

     if (compareAndDecrementWorkerCount(c))

         return null;

     continue;

 }

 try {

     Runnable r = timed ?

         workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :

         workQueue.take();

     if (r != null)

         return r;

     timedOut = true;

 } catch (InterruptedException retry) {

     timedOut = false;

 }

}

}1234567891011121314151617181920212223242526272829303132333435363738

老规矩，简化一下代码来看：

// 为分析而简化后的代码

private Runnable getTask() {

boolean timedOut = false;

for () {

 int c = ctl.get();

 int wc = workerCountOf(c);

 // timed变量用于判断是否需要进行超时控制。

 // allowCoreThreadTimeOut默认是false，也就是核心线程不允许进行超时；

 // wc corePoolSize，表示当前线程池中的线程数量大于核心线程数量；

 // 对于超过核心线程数量的这些线程，需要进行超时控制

 boolean timed = allowCoreThreadTimeOut || wc corePoolSize;

 if (timed timedOut) {

     // 如果需要进行超时控制，且上次从缓存队列中获取任务时发生了超时，那么尝试将workerCount减1,即当前活动线程数减1，

     // 如果减1成功，则返回null，这就意味着runWorker()方法中的while循环会被退出，其对应的线程就要销毁了，也就是线程池中少了一个线程了

     if (compareAndDecrementWorkerCount(c))

         return null;

     continue;

 }

 try {

     Runnable r = timed ?

         workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :

         workQueue.take();

     // 注意workQueue中的poll()方法与take()方法的区别

     //poll方式取任务的特点是从缓存队列中取任务,最长等待keepAliveTime的时长，取不到返回null

     //take方式取任务的特点是从缓存队列中取任务，若队列为空,则进入阻塞状态，直到能取出对象为止

     if (r != null)

         return r;

     timedOut = true;

 } catch (InterruptedException retry) {

     timedOut = false;

 }

}

}123456789101112131415161718192021222324252627282930313233343536373839

从以上代码可以看出，getTask()的作用是

如果当前活动线程数大于核心线程数，当去缓存队列中取任务的时候，如果缓存队列中没任务了，则等待keepAliveTime的时长，此时还没任务就返回null，这就意味着runWorker()方法中的while循环会被退出，其对应的线程就要销毁了，也就是线程池中少了一个线程了。因此只要线程池中的线程数大于核心线程数就会这样一个一个地销毁这些多余的线程。

如果当前活动线程数小于等于核心线程数，同样也是去缓存队列中取任务，但当缓存队列中没任务了，就会进入阻塞状态，直到能取出任务为止，因此这个线程是处于阻塞状态的，并不会因为缓存队列中没有任务了而被销毁。这样就保证了线程池有N个线程是活的，可以随时处理任务，从而达到重复利用的目的。

小结

通过以上的分析，应该算是比较清楚地解答了“线程池中的核心线程是如何被重复利用的”这个问题，同时也对线程池的实现机制有了更进一步的理解：

当有新任务来的时候，先看看当前的线程数有没有超过核心线程数，如果没超过就直接新建一个线程来执行新的任务，如果超过了就看看缓存队列有没有满，没满就将新任务放进缓存队列中，满了就新建一个线程来执行新的任务，如果线程池中的线程数已经达到了指定的最大线程数了，那就根据相应的策略拒绝任务。

当缓存队列中的任务都执行完了的时候，线程池中的线程数如果大于核心线程数，就销毁多出来的线程，直到线程池中的线程数等于核心线程数。此时这些线程就不会被销毁了，它们一直处于阻塞状态，等待新的任务到来。

注意： 

本文所说的“核心线程”、“非核心线程”是一个虚拟的概念，是为了方便描述而虚拟出来的概念，在代码中并没有哪个线程被标记为“核心线程”或“非核心线程”，所有线程都是一样的，只是当线程池中的线程多于指定的核心线程数量时，会将多出来的线程销毁掉，池中只保留指定个数的线程。那些被销毁的线程是随机的，可能是第一个创建的线程，也可能是最后一个创建的线程，或其它时候创建的线程。一开始我以为会有一些线程被标记为“核心线程”，而其它的则是“非核心线程”，在销毁多余线程的时候只销毁那些“非核心线程”，而“核心线程”不被销毁。这种理解是错误的。

另外还有一个重要的接口 BlockingQueue 值得去了解，它定义了一些入队出队同步操作的方法，还可以阻塞，作用很大。