线程创建的三种方式及比较

• • 继承Thread类创建线程类
  • 实现Runnable接口创建线程
  • 使用Callable和Future创建线程
  • 实现接口和继承类来创建线程的比较

1.继承Thread类创建线程类

通过继承Thread类创建并启动多线程的步骤如下：

• 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务。
• 创建Thread子类的实例，及创建了线程对象。
• 调用线程对象的start()方法来启动该线程。

public class Firsthread extends Thread{

    private int i;

    public void run(){
        for(;i<;i++){
            System.out.println(getName() + " " + i);
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        for(int i=;i<;i++){
            System.out.println(Thread.currentThread().getName() + " " + i);
            if( i == ){
                new Firsthread().start();
                new Firsthread().start();
            }
        }
    }
}
           

2.实现Runnable接口创建线程

实现Runnable接口创建线程并启动多线程的步骤如下：

• 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体
• 创建Runnable实现类的实例，并以此实例为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象

public class SecondThread implements Runnable{  
    private int i;

    public void run(){
        for(;i<;i++){
            //想获取当前线程，只能用Thread.currentThread()
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        for(int i=;i<;i++){
            System.out.println(Thread.currentThread().getName() + " " + i);
            if( i == ){
                SecondThread st = new SecondThread();
                //通过new Thread(target,name)方法创建线程
                new Thread(st,"新线程1").start();
                new Thread(st,"新线程2").start();
            }
        }
    }
}
           

3.使用Callable和Future创建线程

从Java 5开始，Java提供了Callable接口，该接口提供了call()方法作为线程执行体，call()方法可以有返回值，call()方法可以声明抛出异常。

Java 5提供了Future接口来代表Callable接口里的call()方法的返回值，并为Future接口提供一个FutureTask实现类，该实现类实现了Future接口，并实现了Runnable接口，即可作为Thread类的target。

public interface Future<V> {
    /**
     *试图取消Future关联的Callable任务
     */
    boolean cancel(boolean mayInterruptIfRunning);

    /**
     *如果在Callable任务正常完成前被取消，则返回true
     */
    boolean isCancelled();

    /**
     *如果Callable任务已完成，则返回true
     */
    boolean isDone();

    /**
     *返回Callable任务里call()方法的返回值。
     *调用该方法将导致程序阻塞，必须等到子线程结束后才会得到返回值
     */
    V get() throws InterruptedException, ExecutionException;

    /**
     *返回Callable任务里call()方法的返回值。
     *该方法让程序最多阻塞timeout和unit指定的时间。
     *如果经过指定时间后Callable任务依然没有返回值，将会抛出TimoutException异常
     */
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}
           

创建并启动有返回值的线程的步骤如下：

• 创建Callable接口的实习类，并实现call()方法，该call()方法将作为线程执行体，且该call()方法有返回值，再创建Callable实习类的实例。从Java 8开始，可以直接使用Lambda表达式创建Callable对象。
• 使用FutureTask类包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
• 使用FutureTask对象作为Thread对象的target创建并启动新线程。
• 调用FutureTask对象的get()方法获得子线程执行结束后的返回值。

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

public class ThirdThread {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ThirdThread rt = new ThirdThread();

        //先使用Lambda表达式创建Callable<Integer>对象
        //再用FutureTask来包装Callable对象
        FutureTask<Integer> task = new FutureTask<Integer>((Callable<Integer>)()->{
            int i = ;
            for(;i<;i++){
                System.out.println(Thread.currentThread().getName() + "的循环变量i的值：" + i);
            }
            return i;
        });

        for(int i=;i<;i++){
            System.out.println(Thread.currentThread().getName() + "的循环变量i的值：" + i);
            if(i == ){
                new Thread(task,"有返回值的线程").start();
            }
        }
        try{
            System.out.println("子线程的返回值: " + task.get());
        }
        catch(Exception e){
            e.printStackTrace();
        }
    }

}
           

实现接口和继承类来创建线程的比较

采用实现Runnable、Callable接口的方式创建多线程的优缺点：

• 线程类只是实现了接口，还可以继承其他类
• 在这种情况下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU，代码和数据分开，形成清晰的模型，较好的体现了面向对象的思想。
• 编程稍稍复杂，如果需要访问当前线程，则需要使用Thread.currentThread()

采用继承Thread类的方式创建多线程的优缺点：

• 线程类已经继承了Thread类，所以不能再继承其他父类
• 编写简单，如果需要访问当前线程，不需要使用Thread.currentThread()，直接使用this

因此，一般推荐使用实现Runnable、Callable接口的方式创建多线程。