Java线程

第三种方法：

Callable
Callable位于java.util.concurrent包下，是个接口，它提供了一个call() 方法可以作为线程执行体。
        call() 方法可以有返回值。
        call() 方法可以声明抛出异常。

这是一个泛型接口，call()函数返回的类型就是传递进来的V类型

Future接口
Future就是对于具体的 Runnable 或者 Callable 任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过 get 方法获取执行结果，该方法会阻塞直到任务返回结果。

在Future 接口中声明了5个方法，下面依次解释每个方法的作用：

boolean cancel(boolean mayInterruptIfRunning) 

试图取消对此任务的执行。如果取消任务成功则返回true，如果取消任务失败则返回false。
参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true；若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。 

V get() 

方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；

V get(long timeout, TimeUnit unit) 

用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。

boolean isCancelled() 

如果在任务正常完成前将其取消，则返回 true。 

boolean isDone() 

如果任务已完成，则返回 true。 

Future 接口的实现类是 FutureTask，FutrueTask 实现类提供了两个构造方法：

FutureTask(Callable<V> callable) 

创建一个 FutureTask，一旦运行就执行给定的 Callable。 

FutureTask(Runnable runnable, V result) 

创建一个 FutureTask，一旦运行就执行给定的 Runnable，并安排成功完成时 get 返回给定的结果 。


创建并启动有返回值的线程的步骤：
1）创建Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，且该 call() 方法有返回值 。
2）创建Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象， 该 FutrueTask 对象封装了该 Callable 对象的 call() 方法的返回值。
3）使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
4）调用FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。
代码示例：

package com.hainiu.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * @author 花牛
 *		实现线程的第三种方式
 *			1. 写一个类  实现 Callable接口
 *			2. 重写 call 方法 该方法 等同于  run方法  是线程的实际执行体  并创建对象
 *			3. 把 Callable 的子类 套接咋  Runnable 子类对象中
 *			4. 把 Runnable 子类对象 套接在  Thread 类对象里
 *			5. Thread 对象 start 开启线程
 *
 *
 *		第三种方式的特殊之处
 *			1. 可以抛异常
 *			2. 有返回值
 *
 *
 *
 *		源码分析
 *			this.callable = callable;  套接  callable是 接收到的 Callable接口的子类对象
 *			result = callable.call(); 调用 call 方法  
 *			outcome = v;	本类的属性存储返回值 
 *			get方式 其实获取的就是   outcome
 *			
 *
 */
public class Test {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		// 2. 重写 call 方法 该方法 等同于  run方法  是线程的实际执行体  并创建对象
		Callable<Object> callable = new TestCallable();
		// 3. 把 Callable 的子类 套接咋  Runnable 子类对象中
		FutureTask<Object> runn = new FutureTask<>(callable);
		// 4. 把 Runnable 子类对象 套接在  Thread 类对象里
		new Thread(runn,"call").start();
		// 获取线程的返回值  为阻塞方法   线程不结束  一直等待
		//Object object = runn.get();
		Object object = null;
		long l = System.currentTimeMillis();
		try {
			// 前面是数字  后面是时间单位
			object = runn.get(5, TimeUnit.SECONDS);
		} catch (TimeoutException e) {
			System.out.println(System.currentTimeMillis()-l);
			//e.printStackTrace();
		}
		
		System.out.println("结果 "+object);
		System.out.println("main -gg");
	}
}

class TestCallable implements Callable<Object>{//1. 写一个类  实现 Callable

	// 2. 重写 call 方法 该方法 等同于  run方法  是线程的实际执行体  并创建对象
	@Override
	public Object call() throws Exception {
		int sum = 0;
		for (int i = 0; i < 10000000; i++) {
			sum += i;
			Thread.sleep(10);
		}
		return sum;
	}
	
}