java 实现线程的三种方式 Thread 、Runnable、 Callable Future

继承Thread类,重写run方法

例如：

/**
 * 实现线程方式一 继承Thread类
 * 
 * @author wbw
 * 
 */
public class MyThread1 extends Thread {

	@Override
	public void run() {

		try {
			for (int i = 0; i < 10; i++) {
				System.out.println("Hello" + i);
				Thread.sleep(10000);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

启动线程

package com.my.thread;

public class Test {
public static void main(String[] args) {
  
	new MyThread1().start();
}
}

实现Runnable接口

package com.my.thread;
/**
 * 实现方式二： 实现抽象接口Runnable,在run方法中编写业务逻辑代码
 * @author wbw
 *
 */
public class MyThread2  implements Runnable{

	@Override
	public void run() {
		try {
			for (int i = 0; i < 10; i++) {
				System.out.println("Hello" + i);
				Thread.sleep(10000);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	}

在上面的两种实现方式，可以看出都能不能有返回值和不能抛出异常

在JDK1.5提供的新特性 Callable 和Fucture 可以允许线程有返回值

Callable的接口

public interface Callable<V> { 

      V   call()   throws Exception; 

} 

Callable和Runnable的区别：

1. Callable定义的方法是call，而Runnable定义的方法是run。

2.  Callable的call方法可以有返回值，而Runnable的run方法不能有返回值。

3.  Callable的call方法可抛出异常，而Runnable的run方法不能抛出异常

4. Callable的启动可以通过创建ExecutorService对象调用sumbit（）方法执行,也可以通过Thread的start()方法,而Runnable通过Thread的start()方法 

例子：

<strong>package com.my.thread;

import java.util.concurrent.Callable;
/**
 * 实现方式三：实现Callable接口
 * @author wbw
 *
 */
public class MyThread3 implements Callable<String> {

	@Override
	public String call() throws Exception {
		
		return "hello world";
	}

}</strong>

启动：

<strong>package com.my.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {
public static void main(String[] args) {
  
	//Callable的启动方式
	MyThread3  task = new MyThread3();
	ExecutorService es =  Executors.newCachedThreadPool();
	es.submit(task);
}
}</strong>

Future用来保存Callable异步运算的结果

FutureTask封装Future的实体类

Future的接口如下：

<strong>public interface Future<V> {   
    boolean cancel(boolean mayInterruptIfRunning);   
    boolean isCancelled();   
    boolean isDone();   
    V get() throws InterruptedException, ExecutionException;   
    V get(long timeout, TimeUnit unit)   
        throws InterruptedException, ExecutionException, TimeoutException;   
}   </strong>

Callable 与Future

<strong>package com.my.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
 * 测试Callable
 * @author wbw
 *
 */
public class Test {
public static void main(String[] args) {
  
	 try {
			//创建callable任务
			Callable<String>  task = new MyThread3();
		   // 创建一个执行任务的服务
			ExecutorService es =  Executors.newCachedThreadPool();
		    // 提交并执行任务，任务启动时返回了一个Future对象，
			 Future<String> future =  es.submit(task);
			 // 获得第一个任务的结果，如果调用get方法，当前线程会等待任务执行完毕后才往下执行，形成阻塞的状态
		    System.out.println("Callable线程的返回值:"+future.get());
		    //停止任务执行服务
		    es.shutdownNow();
	} catch (InterruptedException | ExecutionException e) {
		e.printStackTrace();
	}
}
}</strong>

Callable 与FutureTask

<strong>	    try {
	    	Callable<String>  task2 = new MyThread3();
			//创建FutureTask对象
			FutureTask<String> ft = new FutureTask<String>(task2);
		    Thread thread = new Thread(ft);
		    thread.start();//启动
			Thread.sleep(100);
			if(!ft.isDone()){//判断当前线程的执行状态
				System.out.println(ft.get());
			}
			if(!ft.isCancelled()){//判断当前线程是否已被取消
				ft.cancel(true);
				System.out.println("Cancelled");
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}</strong>

三种实现线程的方式,根据实际情况选用