一、Runnable接口

创建线程可以通过继承Thread类，或者通过实现Runnable接口实现。其中如果程序员要继承其他类，就无法继承Thread类，只能通过实现Runnable接口。

实现Runnable接口，启动新线程的步骤

1.定义类实现Runnable接口

2.覆盖Runnable接口中的run方法（将线程要运行的代码存放在该run方法中）

3.通过Thread类创建线程对象

4.将Runnable接口的子类对象作为实际的参数传递给Thread类的构造函数（为什么要Runnable接口的子类对象传递给Thread的子类对象，所以要让线程去指定对象的run方法，就必须明确该run方法所属的对象）

5.调用Thread类的start方法开启线程并且调用Runnable接口子类的run方法。

public class testDemo{
    public static void main(String[] args){
        Thread aThread = new Thread(new Athread());
        Thread bThread = new Thread(new Bthread());
        aThread.start();
        bThread.start();
    }
}
public static class Athread implement Runnable{
    @Overrite
    public void run(){
        System.out.println("执行了A线程")
}
}
public static class Bthread implement Runnable{
    @Overrite
    public void run(){
        System.out.println("执行了B线程")
    }
}

实现Runnable接口的意义

Runnable接口用来指定每个线程要执行的任务，包含了一个run的无参构造方法，需要由接口实现类重写该方法，并且实现接口避免了单继承的局限性。

实现Runnable接口的原理

实现Runnable接口，可以多个继承，避免了继承Thread类的单继承局限性。将线程任务代码定义到run方法中。

创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中，而且这个run方法所属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。

实现Runnable接口的好处

声明实现Runnable接口避免了单继承的局限性，所以较为常用。实现Runnable接口的方式，更加的符合面向对象思想，线程分为两部分，一部分是线程对象，一部分是线程任务。继承Thread类，线程对象和线程任务会耦合在一起，一旦创建Thread类的子类对象，既是线程对象，又有线程任务。实现Runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。（解耦的意思是Thread不用跟某一个方法体绑定，只跟不同的runnable绑定。线程是线程，工作内容是工作内容。）如果继承了Thread就不能继承别的了，这样耦合度就增加了，对象组合依然会增加耦合度。

线程的匿名内部类使用

public static void main(String[] args){
    //继承Thread类方法
    //此处的new Thread()方法整体就是匿名内部类，创建线程对象，可以直接重写run()方法
    new Thread(){
        @Override
        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接口用来记录线程任务执行完毕后产生的结果。

public static void main(String[] args){
    //获得线程池对象
    ExecutorService es = Executors.newFixedThreadPool(2);//此处表示线程池中有两个线程
    //创建线程任务对象
    MyRunnable r = new MyRunnable();
    //将线程任务交给线程池执行
    //此处要有3条任务执行，而线程池只有2条，所以只能先执行前两个任务，其中一个任务执行完毕在继续第三个任务执行
    es.submit(r);
    es.submit(r);
    es.submit(r);
    //销毁线程池
    es.shutdown();
}

使用线程池方式-Callable接口

Callable接口与Runnable接口功能相似，用来指定线程任务。其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。

Futuresubmit(Callable task) : 获取线程池中的某一个线程对象，并执行线程中的call()方法。

Future接口：用来记录线程任务执行完毕后产生的结果。

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.submit();
}

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(t1);
    Future<Integer> f2 = es.sumbit(r2);
    //获取返回值，任务同时进行，但结果有先后
    System.out.println(f1.get());
    System.out.println(f2.get());
    //销毁线程池
    es.shutdown();