Java复习：创建线程的的几种方式

1.实现Runnable接口，传入Thread

class MyRunnable implements Runnable{
   @Override
   public void run() {
        //Do
   }
}

Thread thread1 = new Thread(new MyRunnable());
thread1.start();

2.实现Thread的run方法

class MyRunnable implements Runnable{
    @Override
    public void run() {
        //Do
    }
}

MyThread thread2 = new MyThread();
thread2.start();

注：如果一个Thread既实现了自己的run方法，初始化的时候又传入了Runnable对象，后者优先

3.实现Callable接口，传入FutureTask，FutureTask传给Thread

class MyCallable implements Callable<String>{
    @Override
    public String call() throws Exception {
        //Do
        return "str";
    }
}

FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
Thread thread3 = new Thread(futureTask);
thread3.start();

注：Callable区别于Runnable在于有返回值

以下提供一个小栗子分析Runnable和Callable的区别

private void executorTest() {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        try {
            addRunnable(executorService);
            addCallable(executorService);
            addTaskRunnable(executorService);
            addTaskCallable(executorService);
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void addRunnable(ExecutorService service) throws ExecutionException, InterruptedException {
        Future<?> result = service.submit(new Runnable() {
            @Override
            public void run() {
                //Do
            }
        });
        System.out.println("Runnable的result：" + result.get());
    }

    private void addCallable(ExecutorService service) throws ExecutionException, InterruptedException {
        Future<String> result = service.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "这里是Callable";
            }
        });
        System.out.println("Callable的result：" + result.get());
    }

    private void addTaskRunnable(ExecutorService service) throws ExecutionException, InterruptedException {
        final String str = "这里是TaskRunnable";
        FutureTask<String> result = new FutureTask<>(new Runnable() {
            @Override
            public void run() {
                //Do
            }
        }, str);
        service.submit(result);
        System.out.println("TaskRunnable的result：" + result.get());
    }

    private void addTaskCallable(ExecutorService service) throws ExecutionException, InterruptedException {
        FutureTask<String> result = new FutureTask<>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "这里是TaskCallable";
            }
        });
        service.submit(result);
        System.out.println("TaskCallable的result：" + result.get());
    }

运行后控制台打印如下：

I/System.out: Runnable的result：null
I/System.out: Callable的result：这里是Callable
I/System.out: TaskRunnable的result：这里是TaskRunnable
I/System.out: TaskCallable的result：这里是TaskCallable

其中第三个，传入FutureTask的是一个Runnable实现和一个result。在FutureTask中，会自动把这两者包装成一个Callable，所以其实后三个都是Callable。