Java多线程实现方式主要有四种：继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。
其中前两种方式线程执行完后都没有返回值，后两种是带返回值的。
1继承Thread类
Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：
public class ThreadDemo extends Thread{
private String ThreadName;
public ThreadDemo(String ThreadName){
this.ThreadName = ThreadName;
}
public void run(){
System.out.println("running--"+this.ThreadName+"---"+Thread.currentThread().getId());
}
public static void main(String[] args) {
ThreadDemo threadDemo = new ThreadDemo("ThreadDemo_one");
threadDemo.start();
ThreadDemo threadDemo1 = new ThreadDemo("ThreadDemo_two");
threadDemo1.start();
}
}
2实现Runnable接口
如果自己的类已经extends另一个类，就无法直接extends Thread，此时，可以实现一个Runnable接口，如下：
class RunnableDemo implements Runnable{
private Thread t;
private String threadName;
RunnableDemo(String threadName){
this.threadName = threadName;
System.out.println("创建---"+threadName);
}
public void run(){
System.out.println("running---"+threadName);
try {
for (int i = 0; i < 4; i++) {
System.out.println("Thread: " + threadName + ", " + i);
Thread.sleep(5000);
}
} catch (InterruptedException e) {
System.out.println("Thread " + threadName + " interrupted.");
}
System.out.println("Thread " + threadName + " exiting.");
}
public void start(){
System.out.println("starting---"+threadName);
if(t==null){
t = new Thread(this,threadName);
t.start();
}
}
public static void main(String[] args) {
RunnableDemo runnableDemo = new RunnableDemo("wq");
runnableDemo.start();
RunnableDemo runnableDemo1 = new RunnableDemo("css");
runnableDemo1.start();
}
}
3实现Callable接口通过FutureTask包装器来创建Thread线程
Callable接口（也只有一个方法）
FutureTask<Integer>是一个包装器，它通过接受Callable<Integer>来创建，它同时实现了Future和Runnable接口。
public class CallableDemo implements Callable<Integer>{
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) {
CallableDemo call = new CallableDemo();
FutureTask<Integer> ft = new FutureTask<Integer>(call);
// new Thread(ft,"有返回值的线程").start();
for(int i = 0;i < 100;i++)
{
System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);
if(i==21)
{
new Thread(ft,"有返回值的线程").start();
}
}
try {
System.out.println("子线程的返回值："+ft.get());
} catch (InterruptedException e) {
} catch (ExecutionException e) {
}
}
}
4ExecutorService、Callable、Future实现有返回结果的多线程
public class test {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newFixedThreadPool(5);
// newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
// newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
// newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
// newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
List<Future> futureList= new ArrayList<Future>();
for (int i = 0; i <5; i++) {
Callable task = new TestCallable("wq"+i, "phone"+i);
Future<Object> f = threadPool.submit(task);
futureList.add(f);
}
threadPool.shutdown();
for (Future future : futureList) {
try {
System.out.println(future.get().toString());
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
class TestCallable implements Callable<Object>{
private String name;
private String phone;
TestCallable(String name,String phone){
this.name=name;
this.phone=phone;
}
public Object call() throws Exception {
System.out.println(name+"----"+phone);
return name+"--return--"+phone;
}
}