首先说一下在开发中为什么会有线程和线程池。
日常开发中，如果一个操作需要好几个步完成，其中有一两个步非同步或事务操作，比如记录日志，那么为了提高响应时间，可以把这一两步单独开一个线程，由新开的线程来完成。
为什么会有线程池呢？如果当前并发巨大，同一时刻会启动多个线程来完成，那么随着线程的增多，服务器的内存最终会耗尽，因此需要有线程池来管理这些线程，设置线程池的容量，新开了线程，都放到线程池等待，有空余资源就处理这些线程。这样就避免新开无数线程导致服务器资源耗尽的情况了。
新建一个线程
新建一个类FirstThread，该类实现Runnable接口，并重写Run方法，则该类就可以做为一个线程实现类来使用。
代码如下：
public class FirstThread implements Runnable {
private String username;//传参数
public FirstThread(String username) {
this.username = username;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(username + i);
}
}
}
线程启动
首先new 当前的FirstThread，再new 一个Thread，执行start方法即可，比如：
public static void main(String[] args) {
FirstThread ft1 = new FirstThread("张三");
FirstThread ft2 = new FirstThread("李四");
Thread t1 = new Thread(ft1);
Thread t2 = new Thread(ft2);
t1.start();
t2.start();
}
线程池
线程池原理如下：
1、Executors.newFixedThreadPool(10)初始化一个包含10个线程的线程池executor；
2、通过executor.execute方法提交20个任务，每个任务打印当前的线程名；
3、负责执行任务的线程的生命周期都由Executor框架进行管理；
4、线程池里最大有10个线程，如果超过10个，其余的等待，执行完后再进入线程池进行任务执行。如果小于10个，则直接全部执行。
代码如下：
/**
* Created by 孔垂云 on 2017/4/21.
*/
public class ExecutorTest {
private static Executor executor = Executors.newFixedThreadPool(10);//新建一个10个线程的线程池
/**
* 内部类实现一个线程
*/
static class Task implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());//打印当前线程的名称
try {
TimeUnit.SECONDS.sleep(new Random().nextInt(10));//暂停几秒钟
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
for (int i = 0; i < 20; i++) {
executor.execute(new Task());
}
}
}
Future和Callable实现
/**
* Created by 孔垂云 on 2017/4/21.
*/
public class FutureTest {
private static ExecutorService executor = Executors.newFixedThreadPool(10);//定义10个线程的线程池
static class Task implements Callable<String> {
@Override
public String call() throws Exception {
TimeUnit.SECONDS.sleep(1);
return "Hello Future";
}
}
public static void main(String[] args) throws Exception {
Future<String> future = executor.submit(new Task());
System.out.println("开始执行线程：");
String ret = future.get();//获取该线程的返回值
System.out.println("执行结果：" + ret);
System.out.println("执行完毕");
executor.shutdown();
}
}
在实际业务场景中，Future和Callable基本是成对出现的，Callable负责产生结果，Future负责获取结果。
1、Callable接口类似于Runnable，只是Runnable没有返回值。
2、Callable任务除了返回正常结果之外，如果发生异常，该异常也会被返回，即Future可以拿到异步执行任务各种结果；
3、Future.get方法会导致主线程阻塞，直到Callable任务执行完成；
4、线程都执行完毕后，执行executor.shutdown();，关闭主进程。
