java线程创建的三种方式

继承Thread类

通过继承Thread类来创建并启动多线程步骤如下：

1、定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务。因此把run方法称为线程执行体。

2、创建Thread子类的实例，即创建了线程对象。

3、调用线程对象的start()方法来启动该线程。

下面展示一些 内联代码片。

public class FirstThreadTest extends Thread {
	
	int i=0;
	//重写run()，现场执行体
	public void run(){
		for(;i<10;i++){
			System.out.println(this.getName()+" "+i);
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for(int i=0;i<10;i++){
			System.out.println(Thread.currentThread().getName()+" "+i);
			if(i==5){
				new FirstThreadTest().start();
				new FirstThreadTest().start();
			}
		}
	}
}

实现Runnable接口

1、定义了一个实现Runnable接口的类，并重写run（）方法

2、创建该类的实例，并将此实例作为Thread类的target来创建Thread对象，该Thread对象是真正的线程对象。

3、调用线程对象的start()方法来启动该线程。

下面展示一些 内联代码片。

public class RunnableTreadTest implements Runnable{

	private int i=0;

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(;i<10;i++){
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
         for(int i=0;i<10;i++){
        	 System.out.println(Thread.currentThread().getName()+" "+i);
             if(i==5){
            	 RunnableTreadTest target =new RunnableTreadTest();
                 new Thread(target, "new tread one").start();
                 new Thread(target, "new tread two").start();
             }
         }
	}
}

匿名内部类

匿名内部类本质上也是一个类实现了Runnable接口，重写了run方法，只不过这个类没有名字，直接作为参数传入Thread类，示例代码：

下面展示一些 内联代码片。

public class Main {
	
	public static void main(String[] args) {
		new Thread(new Runnable() {
		
			public void run() {
				for (int i = 0; i < 50; i++) {
					System.out.println(Thread.currentThread().getName() + "执行" + i);
				}
			}
		}).start();
		for (int i = 0; i < 50; i++) {
			System.out.println(Thread.currentThread().getName() + "执行" + i);
		}
	}
}

通过Callable和Future创建对象

1、定义一个实现Callable接口的类，并实现call()方法，该call方法将作为线程执行体，并且有返回值

2、创建该类的实例。

3、创建FutureTask的实例，即使用FutrueTask类来包装Callable对象。

4、将FutureTask的实例作为Thread的target创建并启动新线程。

5、调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

下面展示一些 内联代码片。

public class CallableThreadTest implements Callable<Integer>{
	private int tasknum;
	
	public CallableThreadTest() {
		super();
	}
	
	public CallableThreadTest(int tasknum) {
		super();
		this.tasknum = tasknum;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		CallableThreadTest callableThreadTest =new CallableThreadTest();
		FutureTask<Integer> futureTask =new FutureTask<Integer>(callableThreadTest);
		
		for(int i=0;i<10;i++){
			System.out.println(Thread.currentThread().getName()+" "+i);
			if(i==5){
				new Thread(futureTask, "有返回值的线程").start();
			}
		}
		try {
			System.out.println("子线程的返回值："+futureTask.get());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	@Override
	public Integer call() throws Exception {
		// TODO Auto-generated method stub
		int i=0;
		/*for(;i<10;i++){
			System.out.println(Thread.currentThread().getName()+" "+i);
		}*/
		System.out.println(Thread.currentThread().getName()+" 有返回值的线程正在运行。。。。。。。。。");
		return tasknum;
	}
}

总结

	继承Thread类	实现Runnable接口	通过Callable和Future创建对象
线程执行体	run()	run()	call()
target对象		Runnable实现类的实例对象	FutureTask的实例(包装Callable对象)
线程对象	创建Thread子类的实例	用target创建的Thread对象	用target创建的Thread对象
启动	线程对象.start()	线程对象.start()	线程对象.start()
执行体返回值	无	无	target对象实例.get()
获取当前线程	this.	Thread.currentThread()	Thread.currentThread()

• 继承 Thread：

class MyThread extends Thread 并重写run()
new MyThread().start();

• 实现 Runable ：

class MyRunnable implements Runnable 并重写run()
MyRunnable runnable = new MyRunnable();
new Thread(runnable).start();

• 实现 Callabl：

class MyCallable implements Callable 并重写call()
MyCallable callable = new MyCallable();
FutureTask futureTask = new FutureTask<>(callable);
new Thread(futureTask).start();

源代码

• Thread 类

package java.lang;
public class Thread implements Runnable {
	// 构造方法
	public Thread(Runnable target);
	public Thread(Runnable target, String name);
	
	public synchronized void start();
}

• Runnable 接口

 package java.lang;

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

• Callable 函数式接口

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

• FutureTask

public class FutureTask<V> implements RunnableFuture<V> {
	// 构造函数
	public FutureTask(Callable<V> callable);
	
	// 取消线程
	public boolean cancel(boolean mayInterruptIfRunning);
	// 判断线程
	public boolean isDone();
	// 获取线程执行结果
	public V get() throws InterruptedException, ExecutionException;
}

• RunnableFuture

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

Thread类是实现Runnable，Callable封装成FutureTask，FutureTask实现RunnableFuture，RunnableFuture继承Runnable，所以Callable也算是一种Runnable，所以三种实现方式本质上都是Runnable实现
参考：多线程(一)：创建线程和线程的常用方法: link.