Java多线程实现的四种方式

1. 继承 Thread 类，重写 run 方法
2. 实现 Runnable 接口，重写 run 方法，实现 Runnable 接口的实现类的实例对象作为 Thread 构造函数的 target
3. 通过 Callable 和 FutureTask 创建线程
4. 通过线程池创建线程

前面两种可以归结为一类：无返回值，原因很简单，通过重写 run 方法，run 方式的返回值是 void，所以没有办法返回结果
后面两种可以归结成一类：有返回值，通过 Callable 接口，就要实现 call 方法，这个方法的返回值是 Object，所以返回的结果可以放在 Object 对象中
方式 1：继承 Thread 类的线程实现方式如下：

public class ThreadDemo01 extends Thread{public ThreadDemo01(){// 编写子类的构造方法，可缺省}
    public void run(){
        // 编写自己的线程代码
        System.out.println(Thread.currentThread().getName());
    }
    public static void main(String[] args){ThreadDemo01 threadDemo01 = new ThreadDemo01(); 
        threadDemo01.setName("我是自定义的线程 1");
        threadDemo01.start();       
        System.out.println(Thread.currentThread().toString());  
    }
}

程序结果：
Thread[main,5,main]
我是自定义的线程 1

线程实现方式 2：通过实现 Runnable 接口，实现 run 方法，接口的实现类的实例作为 Thread 的 target 作为参数传入带参的 Thread 构造函数，通过调用 start()方法启动线程

public class ThreadDemo02 {public static void main(String[] args){System.out.println(Thread.currentThread().getName());
        Thread t1 = new Thread(new MyThread());
        t1.start();}
}

class MyThread implements Runnable{
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName()+"--> 我是通过实现接口的线程实现方式！");
    }   
}

程序运行结果：
main
Thread-0–> 我是通过实现接口的线程实现方式！

线程实现方式 3：通过 Callable 和 FutureTask 创建线程
a: 创建 Callable 接口的实现类，并实现 Call 方法
b: 创建 Callable 实现类的实现，使用 FutureTask 类包装 Callable 对象，该 FutureTask 对象封装了 Callable 对象的 Call 方法的返回值
c: 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动线程
d: 调用 FutureTask 对象的 get() 来获取子线程执行结束的返回值

public class ThreadDemo03 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Callable<Object> oneCallable = new Tickets<Object>();
        FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);

        Thread t = new Thread(oneTask);

        System.out.println(Thread.currentThread().getName());

        t.start();}

}

class Tickets<Object> implements Callable<Object>{

    // 重写 call 方法
    @Override
    public Object call() throws Exception {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName()+"--> 我是通过实现 Callable 接口通过 FutureTask 包装器来实现的线程");
        return null;
    }   
}

程序运行结果：
main
Thread-0–> 我是通过实现 Callable 接口通过 FutureTask 包装器来实现的线程

线程实现方式 4：通过线程池创建线程

public class ThreadDemo05{

    private static int POOL_NUM = 10;     // 线程池数量

    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub
        ExecutorService executorService = Executors.newFixedThreadPool(5);  
        for(int i = 0; i<POOL_NUM; i++)  
        {RunnableThread thread = new RunnableThread();

            //Thread.sleep(1000);
            executorService.execute(thread);  
        }
        // 关闭线程池
        executorService.shutdown();}   

}

class RunnableThread implements Runnable  
{     
    @Override
    public void run()  
    {System.out.println("通过线程池方式创建的线程：" + Thread.currentThread().getName() + " ");  

    }  
}

程序运行结果：
通过线程池方式创建的线程：pool-1-thread-3
通过线程池方式创建的线程：pool-1-thread-4
通过线程池方式创建的线程：pool-1-thread-1
通过线程池方式创建的线程：pool-1-thread-5
通过线程池方式创建的线程：pool-1-thread-2
通过线程池方式创建的线程：pool-1-thread-5
通过线程池方式创建的线程：pool-1-thread-1
通过线程池方式创建的线程：pool-1-thread-4
通过线程池方式创建的线程：pool-1-thread-3
通过线程池方式创建的线程：pool-1-thread-2

ExecutorService、Callable 都是属于 Executor 框架。返回结果的线程是在 JDK1.5 中引入的新特征，还有 Future 接口也是属于这个框架，有了这种特征得到返回值就很方便了。
通过分析可以知道，他同样也是实现了 Callable 接口，实现了 Call 方法，所以有返回值。这也就是正好符合了前面所说的两种分类

执行 Callable 任务后，可以获取一个 Future 的对象，在该对象上调用 get 就可以获取到 Callable 任务返回的 Object 了。get 方法是阻塞的，即：线程无返回结果，get 方法会一直等待。

再介绍 Executors 类：提供了一系列工厂方法用于创建线程池，返回的线程池都实现了 ExecutorService 接口。

public static ExecutorService newFixedThreadPool
(int nThreads)创建固定数目线程的线程池。
public static ExecutorService newCachedThreadPool()
创建一个可缓存的线程池，调用 execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
public static ExecutorService newSingleThreadExecutor()
创建一个单线程化的 Executor。
public static ScheduledExecutorService newScheduledThreadPool(intcorePoolSize)
创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代 Timer 类。
ExecutoreService 提供了 submit()方法，传递一个 Callable，或 Runnable，返回 Future。如果 Executor 后台线程池还没有完成 Callable 的计算，这调用返回 Future 对象的 get()方法，会阻塞直到计算完成。

Java 多线程实现的方式有四种