2019 java 面试题

基础篇

基本功

面向对象的特征

答：封装，继承，多态和抽象

1. 封装
   封装给对象提供了隐藏内部特性和行为的能力。对象提供一些能被其他对象访问的方法来改
   变它内部的数据。在 Java 当中，有 3 种修饰符： public， private 和 protected。每一种修饰符
   给其他的位于同一个包或者不同包下面对象赋予了不同的访问权限。

下面列出了使用封装的一些好处：

• 通过隐藏对象的属性来保护对象内部的状态。
• 提高了代码的可用性和可维护性，因为对象的行为可以被单独的改变或者是扩展。
• 禁止对象之间的不良交互提高模块化

1. 继承
   继承给对象提供了从基类获取字段和方法的能力。继承提供了代码的重用行，也可以在不修改类的情况下给现存的类添加新特性。

2. 多态
   多态是编程语言给不同的底层数据类型做相同的接口展示的一种能力。一个多态类型上的操作可以应用到其他类型的值上面。

3. 抽象
   抽象是把想法从具体的实例中分离出来的步骤，因此，要根据他们的功能而不是实现细节来创建类。 Java 支持创建只暴漏接口而不包含方法实现的抽象的类。这种抽象技术的主要目的是把类的行为和实现细节分离开。

final, finally, finalize 的区别

答：

1. final
   修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。

2. finally
   在异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。

3. finalize
   方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

int 和 Integer 有什么区别

答：

int 是基本数据类型

Integer是其包装类，注意是一个类。

为什么要提供包装类呢???

一是为了在各种类型间转化，通过各种方法的调用。否则，你无法直接通过变量转化。

比如，现在int要转为String

int a=0;
String result = Integer.toString(a);

在java中包装类，比较多的用途是用在于各种数据类型的转化中。

我写几个demo

//通过包装类来实现转化的
int num = Integer.valueOf("12");
int num2 = Integer.parseInt("12");
double num3 = Double.valueOf("12.2");
double num4 = Double.parseDouble("12.2");
//其他的类似。通过基本数据类型的包装来的valueOf和parseXX来实现String转为XX
String a = String.valueOf("1234");//这里括号中几乎可以是任何类型
String b = String.valueOf(true);
String c = new Integer(12).toString();//通过包装类的toString()也可以
String d = new Double(2.3).toString();

再举例下。比如我现在要用泛型：

List nums;

这里<>需要类。如果你用int。它会报错的。

重载和重写的区别

答：

• override（重写）

1. 方法名、参数、返回值相同。
2. 子类方法不能缩小父类方法的访问权限。
3. 子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。
4. 存在于父类和子类之间。
5. 方法被定义为final不能被重写。

• overload（重载）

1. 参数类型、个数、顺序至少有一个不相同。
2. 不能重载只有返回值不同的方法名。
3. 存在于父类和子类、同类中。

抽象类和接口有什么区别

答：

接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的，
另外，实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。

还有，接口可以实现多重继承，而一个类只能继承一个超类，但可以通过继承多个接口实现多重继承，接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用。

说说反射的用途及实现？

答：

Java反射机制主要提供了以下功能：

在运行时构造一个类的对象；判断一个类所具有的成员变量和方法；调用一个对象的方法；生成动态代理。反射最大的应用就是框架

Java反射的主要功能：

• 确定一个对象的类
• 取出类的modifiers,数据成员,方法,构造器,和超类.
• 找出某个接口里定义的常量和方法说明.
• 创建一个类实例,这个实例在运行时刻才有名字(运行时间才生成的对象).
• 取得和设定对象数据成员的值,如果数据成员名是运行时刻确定的也能做到.
• 在运行时刻调用动态对象的方法.
• 创建数组,数组大小和类型在运行时刻才确定,也能更改数组成员的值.
  反射的应用很多，很多框架都有用到

spring 的 ioc/di 也是反射…

javaBean和jsp之间调用也是反射…

struts的 FormBean 和页面之间…也是通过反射调用…

JDBC 的 classForName()也是反射…

hibernate的 find(Class clazz) 也是反射…

反射还有一个不得不说的问题，就是性能问题，大量使用反射系统性能大打折扣。怎么使用使你的系统达到最优就看你系统架构和综合使用问题啦，这里就不多说了。

参考：反射机制的理解及其用途

说说自定义注解的场景及实现

（此题自由发挥，就看你对注解的理解了!==）登陆、权限拦截、日志处理，以及各种Java框架，如Spring，Hibernate，JUnit 提到注解就不能不说反射，Java自定义注解是通过运行时靠反射获取注解。实际开发中，例如我们要获取某个方法的调用日志，可以通过AOP（动态代理机制）给方法添加切面，通过反射来获取方法包含的注解，如果包含日志注解，就进行日志记录。

HTTP Get 与HTTP Post的区别

答：最直观的区别就是GET把参数包含在URL中，POST通过request body传递参数。
GET方法会把名值对追加在请求的URL后面。因为URL对字符数目有限制，进而限制了用在客户端请求的参数值的数目。并且请求中的参数值是可见的，因此，敏感信息不能用这种方式传递。

POST方法通过把请求参数值放在请求体中来克服GET方法的限制，因此，可以发送的参数的数目是没有限制的。最后，通过POST请求传递的敏感信息对外部客户端是不可见的。

参考：HTTP请求中POST与GET的区别

session 与 cookie 区别

cookie 是 Web 服务器发送给浏览器的一块信息。浏览器会在本地文件中给每一个 Web 服务器存储 cookie。以后浏览器在给特定的 Web 服务器发请求的时候，同时会发送所有为该服务器存储的 cookie。

下面列出了 session 和 cookie 的区别：

无论客户端浏览器做怎么样的设置，session都应该能正常工作。客户端可以选择禁用 cookie，但是， session 仍然是能够工作的，因为客户端无法禁用服务端的 session。

JDBC 流程

1、加载JDBC驱动程序：

在连接数据库之前，首先要加载想要连接的数据库的驱动到JVM（Java虚拟机），
这通过java.lang.Class类的静态方法forName(String className)实现。
例如：

try{
	//加载MySql的驱动类
	Class.forName("com.mysql.jdbc.Driver") ;
} catch (ClassNotFoundException e){
	System.out.println("找不到驱动程序类，加载驱动失败！");
	e.printStackTrace();
}

成功加载后，会将Driver类的实例注册到DriverManager类中。

2、提供JDBC连接的URL

• 连接URL定义了连接数据库时的协议、子协议、数据源标识。
• 书写形式：协议：子协议：数据源标识
  协议：在JDBC中总是以jdbc开始 子协议：是桥连接的驱动程序或是数据库管理系统名称。
  数据源标识：标记找到数据库来源的地址与连接端口。
  例如：

jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=gbk;useUnicode=true;
（MySql的连接URL）
表示使用Unicode字符集。如果characterEncoding设置为 gb2312或GBK，本参数必须设置为true 。characterEncoding=gbk：字符编码方式。

3、创建数据库的连接

• 要连接数据库，需要向java.sql.DriverManager请求并获得Connection对象， 该对象就代表一个数据库的连接。
• 使用DriverManager的getConnectin(String url , String username , String password )方法传入指定的欲连接的数据库的路径、数据库的用户名和 密码来获得。
  例如：

//连接MySql数据库，用户名和密码都是root
String url = "jdbc:mysql://localhost:3306/test" ;
String username = "root" ;
String password = "root" ;
try{
	Connection con = DriverManager.getConnection(url , username , password ) ;
} catch (SQLException se){
	System.out.println("数据库连接失败！");
	se.printStackTrace();
}

4、创建一个Statement

• 要执行SQL语句，必须获得java.sql.Statement实例，Statement实例分为以下3 种类型：

1. 执行静态SQL语句。通常通过Statement实例实现。
2. 执行动态SQL语句。通常通过PreparedStatement实例实现。
3. 执行数据库存储过程。通常通过CallableStatement实例实现。
   具体的实现方式：

Statement stmt = con.createStatement();
PreparedStatement pstmt = con.prepareStatement(sql);
CallableStatement cstmt = con.prepareCall("{CALL demoSp(? , ?)}");

5、执行SQL语句

Statement接口提供了三种执行SQL语句的方法：executeQuery 、executeUpdate 和execute

1. ResultSet executeQuery(String sqlString)：执行查询数据库的SQL语句 ，返回一个结果集（ResultSet）对象。
2. int executeUpdate(String sqlString)：用于执行INSERT、UPDATE或 DELETE语句以及SQL DDL语句，如：CREATE TABLE和DROP TABLE等
3. execute(sqlString):用于执行返回多个结果集、多个更新计数或二者组合的语句。
   具体实现的代码：

ResultSet rs = stmt.executeQuery(“SELECT * FROM …”);
int rows = stmt.executeUpdate(“INSERT INTO …”);
boolean flag = stmt.execute(String sql);

6、处理结果

两种情况：

1. 执行更新返回的是本次操作影响到的记录数。
2. 执行查询返回的结果是一个ResultSet对象。

• ResultSet包含符合SQL语句中条件的所有行，并且它通过一套get方法提供了对这些 行中数据的访问。
• 使用结果集（ResultSet）对象的访问方法获取数据：

while(rs.next()){
	String name = rs.getString(“name”) ;
	String pass = rs.getString(1) ; // 此方法比较高效
}

（列是从左到右编号的，并且从列1开始）

7、关闭JDBC对象

操作完成以后要把所有使用的JDBC对象全都关闭，以释放JDBC资源，关闭顺序和声明顺序相反：

1. 关闭记录集
2. 关闭声明
3. 关闭连接对象

if(rs != null){ // 关闭记录集
    try{
      rs.close() ;
    } catch (SQLException e){
      e.printStackTrace() ;
    }
}
if(stmt != null){ // 关闭声明
    try{
      stmt.close() ;
    } catch (SQLException e){
      e.printStackTrace() ;
    }
}
if(conn != null){ // 关闭连接对象
    try{
      conn.close() ;
    } catch (SQLException e){
      e.printStackTrace() ;
    }
}

MVC 设计思想

MVC就是

M:Model 模型

V:View 视图

C:Controller 控制器

模型就是封装业务逻辑和数据的一个一个的模块,控制器就是调用这些模块的(java中通常是用Servlet来实现,框架的话很多是用Struts2来实现这一层),视图就主要是你看到的,比如JSP等.

当用户发出请求的时候,控制器根据请求来选择要处理的业务逻辑和要选择的数据,再返回去把结果输出到视图层,这里可能是进行重定向或转发等.

Jsp与Servlet的区别

1. jsp经编译后就变成了servlet(jsp本质就是servlet,jvm只能识别java的类，不能识别jsp代码，web容器将jsp的代码编译成jvm能够识别的java类)；

2. jsp更擅长表现于页面显示，servlet更擅长于逻辑控制；

3. setvlet中没有内置对象，jsp中的内置对象都是必须通过HttpServletRequest对象，HttpServletResponse对象及HttpServlet对象得到；

4. jsp是servlet的一种简化，使用jsp只需要完成程序员需用输出到客户端的内容，jsp中的java脚本如何镶嵌到一个类中，由jsp容器完成，而servlet则是个完整的java类，这个类的service方法用于生成对客户端的响应；

equals 与 == 的区别

值类型（int,char,long,boolean等）都是用==判断相等性。对象引用的话，判断引用所指的对象是否是同一个。equals是Object的成员函数，有些类会覆盖（override）这个方法，用于判断对象的等价性。例如String类，两个引用所指向的String都是"abc"，但可能出现他们实际对应的对象并不是同一个（和jvm实现方式有关），因此用判断他们可能不相等，但用equals判断一定是相等的。

集合

List 和 Set 区别

List,Set都是继承自Collection接口

List特点：元素有放入顺序，元素可重复

Set特点：元素无放入顺序，元素不可重复，重复元素会覆盖掉

（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的，加入Set 的Object必须定义equals()方法 ，另外list支持for循环，也就是通过下标来遍历，也可以用迭代器，但是set只能用迭代，因为他无序，无法用下标来取得想要的值。）

Set和List对比：

Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。

List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变。

List 和 Map 区别

答：List是对象集合，允许对象重复。

Map是键值对的集合，不允许key重复。

Arraylist 与 LinkedList 区别

Arraylist：

优点：ArrayList是实现了基于动态数组的数据结构,因为地址连续，一旦数据存储好了，查询操作效率会比较高（在内存里是连着放的）。

缺点：因为地址连续， ArrayList要移动数据,所以插入和删除操作效率比较低。

LinkedList：

优点：LinkedList基于链表的数据结构,地址是任意的，所以在开辟内存空间的时候不需要等一个连续的地址，对于新增和删除操作add和remove，LinedList比较占优势。LinkedList 适用于要头尾操作或插入指定位置的场景

缺点：因为LinkedList要移动指针,所以查询操作性能比较低。

适用场景分析：

当需要对数据进行对此访问的情况下选用ArrayList，当需要对数据进行多次增加删除修改时采用LinkedList。

HashMap 和 Hashtable 的区别

答：HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口。主要的区别有：线程安全性，同步(synchronization)，以及速度。

1. Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。

2. HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。

3. HashMap是非synchronized，而Hashtable是synchronized，这意味着Hashtable是线程安全的，多个线程可以共享一个- Hashtable；而如果没有正确的同步的话，多个线程是不能共享HashMap的。Java 5提供了ConcurrentHashMap，它是HashTable的替代，比HashTable的扩展性更好。（在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步(Collections.synchronizedMap)）

4. 另一个区别是HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以当有其它线程改变了HashMap的结构（增加或者移除元素），将会抛出ConcurrentModificationException，但迭代器本身的remove()方法移除元素则不会抛出ConcurrentModificationException异常。但这并不是一个一定发生的行为，要看JVM。这条同样也是Enumeration和Iterator的区别。fail-fast机制如果不理解原理，可以查看这篇文章：HashMap 多线程处理之 Fail-Fast机制：

5. 由于HashMap非线程安全，在只有一个线程访问的情况下，效率要高于HashTable。

6. HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。

7. Hashtable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。

8. 两者通过hash值散列到hash表的算法不一样：HashTbale是古老的除留余数法，直接使用hashcode

int hash = key.hashCode();  
int index = (hash & 0x7FFFFFFF) % tab.length;

而后者是强制容量为2的幂，重新根据hashcode计算hash值，在使用hash 位与 （hash表长度 – 1），也等价取膜，但更加高效，取得的位置更加分散，偶数，奇数保证了都会分散到。前者就不能保证。

```
int hash = hash(k);
int i = indexFor(hash, table.length);

static int hash(Object x) {
　　int h = x.hashCode();  
  
　　h += ~(h << 9);  
　　h ^= (h >>> 14);  
　　h += (h << 4);  
　　h ^= (h >>> 10);  
　　return h;  
}

static int indexFor(int h， int length) {
　　return h & (length-1);
```

线程

创建线程的方式及实现

答：Java中创建线程主要有三种方式：

一、继承Thread类创建线程类

（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体；

（2）创建Thread子类的实例，即创建了线程对象；

（3）调用线程对象的start()方法来启动该线程。

package com.thread;

public class FirstThreadTest extends Thread{
    int i = 0;
    //重写run方法，run方法的方法体就是现场执行体
    public void run()
    {
        for(;i<100;i++){
          System.out.println(getName()+"  "+i);
        }
    }
    public static void main(String[] args)
    {
        for(int i = 0;i< 100;i++)
        {
            System.out.println(Thread.currentThread().getName()+"  : "+i);
            if(i==20)
            {
                new FirstThreadTest().start();
                new FirstThreadTest().start();
            }
        }
    }
}

上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。getName()方法返回调用该方法的线程的名字。

二、通过Runnable接口创建线程类

（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体；

（2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象；

（3）调用线程对象的start()方法来启动该线程。

package com.thread;

public class RunnableThreadTest implements Runnable
{

    private int i;
    public void run()
    {
        for(i = 0;i <100;i++)
        {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }
    public static void main(String[] args)
    {
        for(int i = 0;i < 100;i++)
        {
            System.out.println(Thread.currentThread().getName()+" "+i);
            if(i==20)
            {
                RunnableThreadTest rtt = new RunnableThreadTest();
                new Thread(rtt,"新线程1").start();
                new Thread(rtt,"新线程2").start();
            }
        }
    }
}

三、通过Callable和Future创建线程

（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值；

（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值；

（3）使用FutureTask对象作为Thread对象的target创建并启动新线程；

（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

package com.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableThreadTest implements Callable
{
    public static void main(String[] args)
    {
        CallableThreadTest ctt = new CallableThreadTest();
        FutureTask ft = new FutureTask<>(ctt);
        for(int i = 0;i < 100;i++)
        {
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);
            if(i==20)
            {
                new Thread(ft,"有返回值的线程").start();
            }
        }
        try
        {
            System.out.println("子线程的返回值："+ft.get());
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        } catch (ExecutionException e)
        {
            e.printStackTrace();
        }
    }
    @Override
    public Integer call() throws Exception
    {
        int i = 0;
        for(;i<100;i++)
        {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
        return i;
    }
}

创建线程的三种方式的对比

采用实现Runnable、Callable接口的方式创见多线程时

优势是：

线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。

在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。

劣势是：

编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。

使用继承Thread类的方式创建多线程时

优势是：

编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。

劣势是：

线程类已经继承了Thread类，所以不能再继承其他父类。

sleep() 、join（）、yield（）有什么区别

1、sleep()方法

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。 让其他线程有机会继续执行，但它并不释放对象锁。也就是如果有Synchronized同步块，其他线程仍然不能访问共享数据。注意该方法要捕获异常

比如有两个线程同时执行(没有Synchronized)，一个线程优先级为MAX_PRIORITY，另一个为MIN_PRIORITY，如果没有Sleep()方法，只有高优先级的线程执行完成后，低优先级的线程才能执行；但当高优先级的线程sleep(5000)后，低优先级就有机会执行了。
总之，sleep()可以使低优先级的线程得到执行的机会，当然也可以让同优先级、高优先级的线程有执行的机会。

2、yield()方法

yield()方法和sleep()方法类似，也不会释放“锁标志”，区别在于，它没有参数，即yield()方法只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行，另外yield()方法只能使同优先级或者高优先级的线程得到执行机会，这也和sleep()方法不同。

3、join()方法

Thread的非静态方法join()让一个线程B“加入”到另外一个线程A的尾部。在A执行完毕之前，B不能工作。

Thread t = new MyThread();
t.start();
t.join();

保证当前线程停止执行，直到该线程所加入的线程完成为止。然而，如果它加入的线程没有存活，则当前线程不需要停止。

sleep()和wait()的区别

答：

1. sleep方法是Thread类的静态方法,wait()是Object超类的成员方法

2. sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中，线程不会释放对象锁。

而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备

1. sleep方法需要抛异常,wait方法不需要
   为什么sleep方法需要抛异常,别问我为什么,因为:
   Thread类中sleep方法就已经进行了抛异常处理
   public static native void sleep(long millis) throws InterruptedException;

2. sleep方法可以在任何地方使用,wait方法只能在同步方法和同步代码块中使用

说说 CountDownLatch 原理

参考：

分析CountDownLatch的实现原理

什么时候使用CountDownLatch

Java并发编程：CountDownLatch、CyclicBarrier和Semaphore

说说 CyclicBarrier 原理

参考：JUC回顾之-CyclicBarrier底层实现和原理

说说 Semaphore 原理

参考：

JAVA多线程–信号量(Semaphore)

JUC回顾之-Semaphore底层实现和原理

说说 Exchanger 原理

参考：java.util.concurrent.Exchanger应用范例与原理浅析

ThreadLocal 原理分析

参考：Java并发编程：深入剖析ThreadLocal

讲讲线程池的实现原理

主要是ThreadPoolExecutor的实现原理
参考：Java并发编程：线程池的使用

线程池的几种方式

答：

newFixedThreadPool(int nThreads)

创建一个固定长度的线程池，每当提交一个任务就创建一个线程，直到达到线程池的最大数量，这时线程规模将不再变化，当线程发生未预期的错误而结束时，线程池会补充一个新的线程

newCachedThreadPool()

创建一个可缓存的线程池，如果线程池的规模超过了处理需求，将自动回收空闲线程，而当需求增加时，则可以自动添加新线程，线程池的规模不存在任何限制

newSingleThreadExecutor()

这是一个单线程的Executor，它创建单个工作线程来执行任务，如果这个线程异常结束，会创建一个新的来替代它；它的特点是能确保依照任务在队列中的顺序来串行执行

newScheduledThreadPool(int corePoolSize)

创建了一个固定长度的线程池，而且以延迟或定时的方式来执行任务，类似于Timer。
举个栗子:

private static final Executor exec=Executors.newFixedThreadPool(50);

Runnable runnable = new Runnable(){
    public void run(){
        ...
    }
}
exec.execute(runnable);

Callable