java线程四种实现方法

继承Thread类

	 Thread类本质上是实现了Runnable接口的一个实例，代表一个					线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extends Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法

Thread类的部分源码：

public class Thread implements Runnable{
    public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);
        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }
    private native void start0();
}

示例：

class Right extends Thread{
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("画方....");
			try {
				Thread.sleep(100);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}

调用方法：
第一种：
Thread t1=new 右手();
t1.start();
第二种：
右手 t1=new 右手();
t1.start();

线程调用时可以直接调用run()方法吗？

注意：可以直接调用run方法，但是直接调用run方法则为单线程（main），不会产生新线程；如果调用start方法，最终执行的实际上就是run方法，但是是多线程执行，有新线程产生

run()方法没有返回值void，而且不能抛出异常

实现Runnable接口

Runnable接口源码：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

代码示例：

class Right implements Runnable{
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("右手一个慢动作....");
			try {
				System.out.println(Thread.currentThread());
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}	
	}
}

调用方法：
Runnable runnable=new Right();
Thread t=new Thread(runnable);
t.start();	

因为Runable接口为函数式接口，支持lambda表达式

//简化写法：lambda表达式
Thread t = new Thread(()->{
	for (int i = 0; i < 10; i++) {
		System.out.println("右手一个慢动作....");
		try {
			System.out.println(Thread.currentThread());
			Thread.sleep(100);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
});
t.start();

使用Callable和Future接口创建线程

具体是创建Callable接口的实现类，并实现call()方法。并使用FutureTask类来包装Callable实现类的对象，且以此FutureTask对象作为Thread对象的target来创建线程

Callable及FutureTask的定义：

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

public interface Future<V>

Future接口的系统实现类
public class FutureTask<V> implements RunnableFuture<V>

public interface RunnableFuture<V> extends Runnable, Future<V>

首先定义实现了Callable接口的类，并定义call方法，这个方法可以返回线程执行的结果，这里允许抛出异常中断程序

class MyCallable implements Callable {
	public Object call() throws Exception {
		int sum = 0;
		for (int i = 1; i <= 100; i++)
			sum += i;
		System.out.println("返回数据");
		return sum;
	}
}

调用过程：
Callable myCallable = new MyCallable();  // 创建MyCallable对象
FutureTask ft = new FutureTask(myCallable); //使用FutureTask来包装MyCallable对象,FutureTask实现了Runnable接口
Thread thread = new Thread(ft);//FutureTask对象作为Thread对象的target创建新的线程
thread.start();      //线程进入到就绪状态
Object sum = ft.get(); //取得新创建的新线程中的call()方法返回的结果,当前线程会阻塞等待

注意:FutureTask实现了Future和Runnable接口，所以new Thread(futureTask),当执行thread.start()方法时会自动调用Callable接口实现中的call方法。当调用futureTask.get()方法时可以获取对应的线程对象的执行结果，如果线程并没有返回时，当前线程阻塞等待

使用线程池创建线程

使用ExecutorService、Callable、Future实现有返回结果的线程

创建线程要花费昂贵的资源和时间，如果任务来了才创建线程那么响应时间会变长，而且一个进程能创建的线程数是有限的。为了避免这些问题，在程序启动的时候就创建若干线程对象来响应处理，它们被称为线程池，里面的线程叫工作线程。从JDK1.5开始，Java API提供了Executor框架让你可以创建不同的线程池。比如单线程池，每次处理一个任务；数目固定的线程池或者是缓存线程池（一个适合很多生存期短的任务的程序的可扩展线程池）

package com.cn.cao;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Test1 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//创建线程池
		ExecutorService es=Executors.newCachedThreadPool();
		//提交任务到线程池中
		Future f=es.submit(()->{
			int sum=0;
			for (int i = 0; i <=100; i++) 
				sum+=i;
			return sum;	
		});
		Object res=f.get();
		System.out.println(res);
	}
}

总结

如何选择：
一般创建线程对象时不建议使用extends Thread方法？ 单根继承

一般没有返回结果时建议使用Runnable接口，如果有返回值一般建议使用Callable接口

如果使用线程比较频繁建议使用线程池