多线程的创建方法

1. 线程的创建方法

• 继承Thread类，实现run()方法，步骤如下：
  （1）定义Thread类的子类MyThread，并且重写run()方法，方法体是线程需要完成的任务
  （2） 创建MyThread类的实例，即线程对象
  （3）调用Thread的start()方法启动线程

class MyThread extends Thread {
    @Override
    public void run(){//实现run（）方法
        super.run();
        System.out.println("MyThread");
    }
}
public class test{
    public static void main(String[] args){
        MyThread myThread = new MyThread();
        myThread.start();//启动线程
    }
}

• 实现Runnable接口，重写run()方法，步骤如下：
  （1）定义Runnable接口的实现类MyThread，重写run()方法，方法体是线程需要完成的任务
  （2）创建MyThread类的实例，并且该实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象
  （3）调用Thread的start()方法启动线程

class MyThread implements Runnable {
    @Override
    public void run(){//实现run（）方法
        System.out.println("MyThread");
    }
}
public class test{
    public static void main(String[] args){
        MyThread myThread = new MyThread();
        Thread t = new Thread(myThread);
        t.start();//启动线程
    }
}

• 使用Callable和Future，重写call()方法，步骤如下：
  （1）定义Runnable接口的实现类MyThread，重写call()方法，方法体是线程需要完成的任务
  （2）创建MyThread类的实例
  （3）使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值
  （4）使用FutureTask对象作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象（因为FutureTask实现了Runnable接口）
  （5）调用Thread的start()方法启动线程
  （6）调用FutureTask对象的get()方法获取子线程执行结束后的返回值

class MyThread implements Callable<Integer>{//创建线程类
    @Override
    public Integer call(){//重写call（）方法
        int sum = 0;
        for(int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName() + " " + i);
            sum += i;
        }
        return sum;
    }
}
public class CallableAndFuture{
    public static void main(String[] args){
        Callable<Integer> myThread = new MyThread();//创建MyThread()对象
        FutureTask<Integer> futureTask = new FutureTask<>(myThread);//使用FutureTask来包装MyThread对象
        for(int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName() + " " + i);
            if(i == 3){
                Thread thread = new Thread(futureTask);//FutureTask对象作为Thread对象的target创建新的线程
                thread.start();//启动线程，线程进入就绪状态
            }
        }
        System.out.println("主线程for循环执行完毕");
        try{
            int sum = futureTask.get();//获取创建的新的线程的call()方法的返回结果
            System.out.println("sum = " + sum);
        }catch(InterruptedException e){
            e.printStackTrace();
        }catch (ExecutionException e){
            e.printStackTrace();
        }
    }
}

FutureTask是RunnableFuture的实现类，而RunnableFuture继承了Runnable和Future接口，所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值，也是Future的唯一实现类

2. 三种方法的对比

• 使用继承Thread类创建线程时，编程简单，只用this即可访问当前线程；不能再继承其他父类
• 使用实现Runnable接口和Callable接口创建线程时，编程复杂，需要使用Thread.currentThread()方法访问当前线程；但是可以继承其他类

3. 实现Callable接口和Runnable接口的区别

Callable接口是属于Executor框架中的功能类，比Runnable接口功能更强大，主要区别：

• Callable重写call()方法，而Runnable重写run()方法
• Callable可以在任务结束后提供一个返回值，而Runnable不提供返回值
• call()方法可以抛异常，而run()方法不可以
• 运行Callable可以拿到一个Future对象。Future对象表示异步计算的结果，提供了检查计算是否完成的方法，等待计算完成，并检索计算结果。通过Future对象，可以了解任务的执行情况，可以取消任务的执行，还可以获取任务的执行结果

由于线程属于异步计算模型，因此无法从别的线程中得到函数的返回结果。但是，可以使用Future来监视目标线程调用call()方法的情况，当调用Future的get()方法可以获取结果，这时当前线程会阻塞，直到call()方法结束返回结果