说明

Java多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的（案例代码使用jdk1.8）。

###多线程一些概念

  1. 并行，网络存在需要同时运行的情况为并行，而并行可以通过多进程、多线程来实现。
  2. 多进程，一般大多数操作系统都支持多进程、系统的并行通过多进程实现。 1.JVM是一个进程，main()是一个线程（主线程）。
  3. Java不支持多进程，并行通过多线程实现。
  4. 多进程内存独立，java中多线程堆内存共享，栈内存独立。
  5. 多线程运行时相互独立的，但是结果会互相影响。

继承Thread类

Thread类本质上是实现了Runnable接口,是一个线程实例，重写run()方法，编写你的线程内容。使用start()方法启动线程。start()方法的实现被synchronized修饰，同时还调用了start0()方法，而start0()被native修饰（这个使用native修饰是为了什么？）再调用run()方法。下面是实现一个多线程demo。

package thread;

public class ThreadDemo extends Thread {
    @Override
    public void run() {
        System.out.println("ThreadDemo.run()");
    }

    public static void main(String[] args) {
        ThreadDemo t = new ThreadDemo();
        ThreadDemo t1 = new ThreadDemo();
        t.start();
        t1.start();
        System.exit(0);
    }
}

###实现Runnable接口 在java中实现的是单继承，如果你的实现类已经继承了一个父类，那么使用继承Thread方法已经不行了，这样我们就来实现Runnable接口。但是实现Runnable接口的线程需要使用Thread类来启动。例如启动RunnableDemo 需要实例化一个Thread 对象，把RunnableDemo对象作为参数传入。

package thread;

public class RunnableDemo implements Runnable{

    @Override
    public void run() {
        System.out.println("RunnableDemo.run()");
    }

    public static void main(String[] args) {
        RunnableDemo r = new RunnableDemo();
        Thread t = new Thread(r);
        Thread t1 = new Thread(r);
        t.start();
        t1.start();
        System.exit(0);
    }
}

###使用ExecutorService、Callable、Future实现有返回结果的多线程 ExecutorService、Callable、Future这个对象实际上都是属于Executor框架中的功能类。想要详细了解Executor框架的可以访问http://www.javaeye.com/topic/366591。

####实现Callable接口 实现Callable接口后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了，再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。

package thread;

import java.util.Date;
import java.util.concurrent.Callable;

public class CallableDemo implements Callable<Object> {
    private String taskNum;

    public CallableDemo() {
        super();
    }

    public CallableDemo(String taskNum) {
        this.taskNum = taskNum;
    }

    @Override
    public Object call() throws Exception {
        System.out.println(">>" + taskNum + "任务启动");
        Date dateTmp1 = new Date();
        Thread.sleep(1000);
        Date dateTmp2 = new Date();
        long time = dateTmp2.getTime() - dateTmp1.getTime();
        System.out.println(">>>" + taskNum + "任务终止");
        return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";
    }
}

在上面的代码中，可以明确的知道，线程的主体是在call()方法中实现。 那么现在再去实现调用，实现多线程，同时获取返回对象。

@Test
    public void callableDemoTest() throws ExecutionException, InterruptedException {
        int num = 5;//线程个数
        // 创建一个线程池
        ExecutorService pool = Executors.newFixedThreadPool(num);
        // 保存返回值
        List<Future> list = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            //获取对象
            Callable c = new CallableDemo("task-name-"+i);
            // 执行任务并获取Future对象
            Future f = pool.submit(c);
            list.add(f);
        }
        // 关闭线程池
        pool.shutdown();
        // 获取所有并发任务的运行结果
        for (Future f : list) {
            // 从Future对象上获取任务的返回值，并输出到控制台
            System.out.println(">>>" + f.get().toString());
        }
    }