创建线程三种方式Thread,Runnable,Callable

今天给大家分享的是创建线程的三种方式，分别是Thread类，Runnable和Callable接口。

一、最简单直接的肯定是继承Thread类：

/**
 * 用继承Thread类来创建线程
 */
public class ThreadFirst extends Thread {
    private int i;

    @Override
    public void run() {
        for (; i < 100; i++) {
            System.out.println(this.getName() + "--" + i);
        }
    }

    public static void main(String[] args) {
        for (int k = 0; k < 100; k++) {

            System.out.println(Thread.currentThread().getName() + "--" + k);
            if (k == 20) {
                ThreadFirst first = new ThreadFirst();
                ThreadFirst second = new ThreadFirst();
                first.start();
                second.start();
            }
        }
    }

}

继承Thread类，重写run方法作为执行体，会打印出3个线程的name

二、实现Runnable类创建线程

/**
 * 用Runnable接口来当做Thread的target
 */
public class RunnableThread implements Runnable {
    private int i;

    @Override
    public void run() {
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "--" + i);
        }

    }

    public static void main(String[] args) {
        for (int k = 0; k < 100; k++) {
            System.out.println(Thread.currentThread().getName() + "--" + k);
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (k == 20) {
                RunnableThread thread = new RunnableThread();
                RunnableThread threadTwo = new RunnableThread();
                Thread first = new Thread(thread, "新线程1");
                Thread second = new Thread(threadTwo, "新线程2");
                first.start();
                second.start();
            }
        }
    }
}

先创建Runnable实现类对象，并以此对象作为Thread的target该Thread对象才是真正的线程对象，当Runnable实现类对象作为多个Thread的target时，可以使用实例变量来处理业务。

三、用Callable和Future实现类来创建线程

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

/**
 * 用Callable来创建线程
 */
class CallableThreadThird implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int i = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "--" + i);
        }
        return i;
    }

    public static void main(String[] args) {
        //创建一个实例
        //先创建Callable对象
        //再使用FutureTask来包装Callable对象
//        Callable<Integer> callable = new Callable<Integer>() {
//            @Override
//            public Integer call() throws Exception {
//                int i = 0;
//                for (; i < 100; i++) {
//                    System.out.println(Thread.currentThread().getName() + "--" + i);
//                }
//                return i;
//            }
//        };
//        FutureTask<Integer> futureTask = new FutureTask<Integer>(callable);

        //用Lambda表达式一步完成
//        FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
//            @Override
//            public Integer call() throws Exception {
//                int i = 0;
//                for (; i < 100; i++) {
//                    System.out.println(Thread.currentThread().getName() + "--" + i);
//                }
//                return i;
//            }
//        });
        CallableThreadThird callableThread = new CallableThreadThird();

        //直接用写好的实现类
        FutureTask<Integer> futureTask = new FutureTask<Integer>(callableThread);
        FutureTask<Integer> futureTask2 = new FutureTask<Integer>(callableThread);
        //开始循环
        for (int k = 0; k < 100; k++) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (k == 20) {
                Thread first = new Thread(futureTask, "有返回的线程_1");
                Thread second = new Thread(futureTask2, "有返回的线程_2");
                first.start();
                second.start();
            }
            System.out.println(Thread.currentThread().getName() + "--" + k);

        }
        try {
            System.out.println("返回值为" + "--" + futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }


}

Callable实现类需要实现call方法，此方法比run方法强大，可以有返回值，而且可以声明抛出异常，返回值可以通过FutureTask包装后get()获得，使用FutureTask对象来作为Thread的target。但是要注意不能把同一个FutureTask对象当作多个Thread的target会发生启动失败。