创建线程的方式及区别

创建线程的方式有三种：

    > 1、继承Thread类
    > 2、实现Runnable接口
    > 3、实现Callable接口(该方式主要运用在并发编程异步调用中)
    > 4、使用线程池的方式创建线程（一般不作为常规的创建线程的方式）

各种方式详细代码示例如下：

第一种，继承 java.lang.Thread 类的方式：

package org.xyz.java.thread.demo01;
/**
 * 使用继承Thread的方式来创建线程
 * @author kevin.chen
 */
public class ExtendsThread extends Thread{
        
        @Override
        public void run() {
                for(int i = 1; i <= 20; i++) {
                        System.out.println(Thread.currentThread().getName() + ", use extends Thread: " + i);
                }
        }
        public static void main(String[] args) {
                new ExtendsThread().start();
        }
}

第二种，实现 java.lang.Runnable 接口的方式：

package org.xyz.java.thread.demo01;
/**
 * 使用实现Runnable的方式来创建线程
 * @author kevin.chen
 */
public class ImplRunnable implements Runnable {
        @Override
        public void run() {
                for(int i = 1; i <= 20; i++) {
                        System.out.println(Thread.currentThread().getName() + ", use impl Runnable: " + i);
                }
        }
        
        public static void main(String[] args) {
                ImplRunnable ir = new ImplRunnable();
                // 需要借助Thread类的实例对象来进行线程的启动操作
                new Thread(ir).start();
        }
}

第三种，实现 java.util.concurrent.Callable 接口的方式：

package org.xyz.java.thread.demo01;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
 * 创建线程的方式三：
 * 		使用实现Callable接口的方式来创建线程，相较于Runnable的方式，该方式方法可以有返回值，并可以抛出异常
 * 		> 执行Callable时，执行的方法和Runnable的方法不同，Callable执行的是call()方法，Runnable执行的是run()方法
 * 		> Callable运行时需要FutureTask类的支持，用于接受运算后的结果。其最终也是调用了FutureTask类中的run()方法，run()方法中调用了callable中的call()方法
 * @author kevin.chen
 */
public class ImplCallable implements Callable<Integer>{
        
        @Override
        public Integer call() throws Exception {
                int sum = 0;
                for(int i = 1; i <= 10; i++) {
                        System.out.println(Thread.currentThread().getName() + ", use impl Callable: " + i);
                        sum += i;
                }
                Thread.sleep(5000); // 使用睡眠让主线程等待的时间久点，可以看到主线程在获取结果之前一直处于等待状态
                return sum;
        }
        public static void main(String[] args) {
                ImplCallable ic = new ImplCallable();
                
                // FutureTask 其实是实现了Runnable、Future接口的实现类
                FutureTask<Integer> ft = new FutureTask<Integer>(ic);
                // 启动线程
                new Thread(ft).start();
                
                try {
                        System.out.println("主线程等待结果中...");
                        int result = ft.get(); // 如果该结果在运算的过程需要耗费较长的时间，主线程是处于等待状态的，只有当结果获取到了，主线程才继续执行，有点类似于闭锁（CountDownLatch）的功能
                        System.out.println("主线程等待到结果为：" + result);
                } catch (InterruptedException e) {
                        e.printStackTrace();
                } catch (ExecutionException e) {
                        e.printStackTrace();
                }
        }
}

分析使用继承Thread类和使用实现Runnable接口的优劣：

如果使用继承Thread的方式来创建线程，则不适合资源的共享；
而使用实现Runnable接口的方式，很容易的就实现了资源的共享。
以下是二者的对比：

1、前者不适合多个相同的线程去处理同一个资源，而后者具有天然的优势。

2、使用前者后，不能再继承其他的类，而使用后者则可以避免java中的单继承限制

3、后者相较于前者代码更具有健壮性，代码和数据独立（这个有点勉强）

4、线程池只能放入实现了Runnable或Callable接口的线程，不能直接放入继承Thread类的线程