【Java多线程并发总结】Runnable、Callable----线程的创建篇

线程的创建

线程一般有三种创建方式：实现Runnable接口、继承Thread类、实现Callable接口。我们将通过实例介绍一下这两种线程创建的方式：

1、实现Runnable接口方式创建线程

由这种方式创建线程是创建线程时最经常使用的方式。

public class ThreadTest implements Runnable {
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            System.out.println("NewThread");
            try {
                Thread.sleep(50);   //为了能更好地展现出线程的CPU资源抢占机制，我们使其休眠50ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        new Thread(new ThreadTest()).start();   //开启新线程
        for (int i=0;i<100;i++){                //主线程进程
            System.out.println("MainThread");
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

代码输出结果：

MainThread
MainThread
NewThread
MainThread
NewThread
NewThread
MainThread
NewThread
MainThread
NewThread
MainThread
MainThread
NewThread
...

假如你用以前看单线程的目光看这个程序，或许会发生疑问，为什么明明NewThread线程是先执行的，但先输出的却是MainThread？

这是因为我们通过Thread构造器获取了一个Runnable对象，然后我们调用Thread对象的start()方法时需要进行一定的初始化操作，这时间虽然很短，但是这段时间内CPU的资源被主线程所抢占，所以你会发现虽然CPU资源抢占是随机的，但"MainThread"总会先被输出。

2、继承Thread方式创建线程

public class ThreadTest extends Thread {
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            System.out.println("NewThread");
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        new ThreadTest().start();
        for (int i=0;i<100;i++){
            System.out.println("MainThread");
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

这个方式和实现Runnable接口的方法类似，但是实现接口方式可以再继承其他的类，相对而言更加灵活。

3、有返回值的线程----实现Callable接口

public class ThreadTest implements Callable<String> {
    @Override
    public String call() throws Exception {  //call方法会抛出异常，所以在获取返回数据时应处理异常
        Thread.sleep(1000);    //我们将线程休眠1s，以体现get()阻塞机制
        return "ThreadTest";
    }
}

public class Main {
    public static void main(String[] args) {
//      第一种实现方式
        FutureTask<String> futureTask=new FutureTask<String>(new ThreadTest());
        new Thread(futureTask).start();
        try {
            System.out.println(futureTask.get()); //通过FutureTask的get()方法，主线程被阻塞
            System.out.println("MainThread1");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

//     第二种方式：直接调用Callable的call方法，线程仍会被阻塞
        try {
            String s=new ThreadTest().call();
            System.out.println(s);
            System.out.println("MainThread2");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

输出结果：

ThreadTest
MainThread1
ThreadTest
MainThread2

用这种方式可以返回任务结果，需要实现的方法不再是run()而是call()，Callable线程可以产生Future对象，我们可以通过Future对象的get()方法获取任务结果，我们可以通过isDone()方法判断任务是否完成，但在获取结果时我们不必判断isDone()=true,因为如果我们在任务未结束前调用get()方法时，get()将会阻塞(Blocked)，直至任务完成。