Runnable接口
创建线程的另一种方法是声明实现 Runnable 接口的类。该类实现 run 方法。然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。
实现Runnable接口的意义：Runnable接口用来指定每个线程要执行的任务。包含了一个 run 的无参数抽象方法，需要由接口实现类重写该方法。
创建线程的步骤。
1、定义类实现Runnable接口。
2、覆盖接口中的run方法。。
3、创建Thread类的对象
4、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
5、调用Thread类的start方法开启线程。
//实现Runnable接口
public class MyRunnable implements Runnable {
public void run() {
for(int i=0;i<100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
public static void main(String[] args) {
//创建线程任务对象
MyRunnable my=new MyRunnable();
//创建线程对象
Thread t=new Thread(my);
Thread t2=new Thread(my);
//开启线程
t.start();
t2.start();
}
实现Runnable的原理
实现Runnable接口，避免了继承Thread类的单继承局限性，可以多个继承。覆盖Runnable接口中的run方法，将线程任务代码定义到run方法中。
创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。
实现Runnable的好处
声明实现Runnable接口避免了单继承的局限性，所以较为常用。实现Runnable接口的方式，更加的符合面向对象思想，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。
线程的匿名内部类使用
public static void main(String[] args) {
//继承Thread类方式
//此处的new Thread()方法整体就是匿名内部类，创建线程对象，可以直接重写run()方法
new Thread(){
public void run() {
for(int i=0;i<100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}.start();
//实现Runnable接口方式
//此处的Runnable r=new Thread()方法整体就是匿名内部类，重写Runnable中的run()方法
Runnable r=new Runnable(){
public void run() {
for(int i=0;i<100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
};
//创建线程对象并开启线程
new Thread(r).start();
}
线程池：
线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
图解示例：
线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使用应用程序响应更快。另外，通过适当的调整线程中的线程数目可以防止出现资源不足的情况。
使用线程池方式--Runnable接口
通常，线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法。
Executors：线程池创建工厂类
ExecutorService：线程池类
Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用
使用线程池中线程对象的步骤：
创建线程池对象
创建Callable接口子类对象
提交Callable接口子类对象
关闭线程池
public static void main(String[] args) {
//获取线程池对象
ExecutorService es=Executors.newFixedThreadPool(2);//此处表示线程池中有2条线程
//创建线程任务对象
MyRunnable r=new MyRunnable();
//将线程任务交给线程池执行
//此处要有3条任务执行，而线程池只有2条，所以只能先执行前2个任务，其中一个任务执行完毕再继续第3个任务执行
es.submit(r);
es.submit(r);
es.submit(r);
//销毁线程池
es.shutdown();
}
使用线程池方式—Callable接口
Callable接口：与Runnable接口功能相似，用来指定线程的任务。其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。
ExecutorService：线程池类
<T> Future<T> submit(Callable<T> task)：获取线程池中的某一个线程对象，并执行线程中的call()方法
Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用
使用线程池中线程对象的步骤：
1.创建线程池对象
2.创建Callable接口子类对象
3.提交Callable接口子类对象
4.关闭线程池
public static void main(String[] args) throws InterruptedException, ExecutionException {
//获取线程池对象
ExecutorService es=Executors.newFixedThreadPool(2);
//创建线程任务
MyCallable c=new MyCallable();
//将线程任务交给线程池执行
Future<String> f=es.submit(c);
//注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中
//获取返回值
String str=f.get();
System.out.println(str);
//销毁线程池
es.shutdown();
}
l Callable接口实现类,call方法可抛出异常、返回线程任务执行完毕后的结果
public class GetSum implements Callable<Integer> {
private int num;
public GetSum() {
super();
}
public GetSum(int num) {
super();
this.num = num;
}
public Integer call() throws Exception {
int sum=0;
for(int i=1;i<=num;i++){
sum+=i;
}
return sum;
}
public static void main(String[] args) throws InterruptedException, ExecutionException {
//异步计算1-n的和
//两条线程分别计算1-100和1-200的和
//获取线程池对象
ExecutorService es=Executors.newFixedThreadPool(2);
//创建线程任务对象 构造方法有返回值
GetSum r1=new GetSum(100);
GetSum r2=new GetSum(200);
//将线程任务提交给线程池执行
Future<Integer> f1=es.submit(r1);
Future<Integer> f2=es.submit(r2);
//获取返回值 任务同时进行，但结果有先后
System.out.println(f1.get());
System.out.println(f2.get());
//销毁线程池
es.shutdown();
}
//5050 20100