实现线程的三种方法

线程启动方式

利用Thread子类

1.d定义Thread类的子类，并重写该类的run()方法，该方法的方法体就是线程需要完成的任务，run()方法也称为线程执行体。

2.创建Thread子类的实例，也就是创建了线程对象

3.启动线程，即调用线程的start()方法

public class MyThread extends Thread{
    public void run(){
        for (int i = 0; i < 10000; i++) {
            System.out.print("Nice");
        }
    }
}

测试类：

    @Test
    public void testStartThread(){
        MyThread myThread = new MyThread();
        myThread.start();
        for (int i = 0; i < 10000; i++) {
            System.out.println("[email protected]");
        }
    }

改进写法：

public class PrintThread extends Thread{
    private String message;
    public PrintThread(String message){
        this.message = message;
    }
    public void run(){
        for (int i = 0; i < 10000; i++) {
            System.out.println(message);
        }
    }

}

    @Test
    public void testPrintThread(){
        new PrintThread("Good！").start();
        new PrintThread("Nice！").start();
    }

Runnable接口

1.定义Runnable接口的实现类，一样要重写run()方法，这个run（）方法和Thread中的run()方法一样是线程的执行体

2.创建Runnable实现类的实例，并用这个实例作为Thread的target来创建Thread对象，这个Thread对象才是真正的线程对象

3.第三部依然是通过调用线程对象的start()方法来启动线程

public class Printer implements Runnable {

    private String message;
    public Printer(String message) {
        this.message = message;
    }
    @Override
    public void run() {
        System.out.println(message);
    }
}

测试：

    @Test
    public void testPrient(){
        new Thread(new Printer("good！")).start();
        new Thread(new Printer("nice！")).start();
    }

Thread类本身还实现了Runnable接口，并持有run方法，但Thread类的run方法主体是空的，不执行任何操作。Thread类的run方法通常由子类的run方法重写。

Callable接口

1.Callable接口实际上是属于Executor框架中的功能类，Callable接口与Runnable接口的功能类似，但提供了比Runnable更加强大的功能。

2.Callable可以在任务结束的时候提供一个返回值，Runnable无法提供这个功能
3.Callable的call方法分可以抛出异常，而Runnable的run方法不能抛出异常。

public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println("-------------helo");
        return "Hello Word!";
    }
}

测试

  @Test
    public void testCallable(){
        MyCallable myCallable = new MyCallable();
        FutureTask<String> result = new FutureTask<>(myCallable);
        new Thread(result).start();
        try {
            String s = result.get();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }