Callable与future

前面讲过了线程与锁。这次说一下Callable和future

Callable

它和runnable类似，只是多了一个返回值。

如Callable<Integer>表示返回值 是一个整数类型

有一个call()接口需要实现 

这里写了一段代码看看是不是异步运行。

使用了callable

</pre><pre name="code" class="java">private void test() {
		// TODO Auto-generated method stub
		System.out.println(System.currentTimeMillis());
		Callable<Integer> call = new Callable<Integer>() {

			@Override
			public Integer call() throws Exception {
				// TODO Auto-generated method stub
				int result = 0;
				for (int i = 0; i < 1000; i++) {
					for (int j = 0; j < 1000; j++) {
						result += i;
					}

				}
				return result;
			}
		};
		System.out.println(System.currentTimeMillis());
		try {
			System.out.println(call.call());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

结果：

14045703799561404570379957499500000

使用主线程

	private void test() {
		// TODO Auto-generated method stub
		System.out.println(System.currentTimeMillis());

		// TODO Auto-generated method stub
		int result = 0;
		for (int i = 0; i < 1000; i++) {
			for (int j = 0; j < 1000; j++) {
				result += i;
			}
		}
		System.out.println(System.currentTimeMillis());
		try {
			System.out.println(result);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

结果：

1404570334127
1404570334132
499500000

Future

保存异步计算的结果，当我们new一个future的时候 就可以看到它的接口了

	Future<Object> future=new Future<Object>() {
			
			@Override
			public boolean isDone() {
				// TODO Auto-generated method stub
				return false;
			}
			
			@Override
			public boolean isCancelled() {
				// TODO Auto-generated method stub
				return false;
			}
			
			@Override
			public Object get(long timeout, TimeUnit unit) throws InterruptedException,
					ExecutionException, TimeoutException {
				// TODO Auto-generated method stub
				return null;
			}
			
			@Override
			public Object get() throws InterruptedException, ExecutionException {
				// TODO Auto-generated method stub
				return null;
			}
			
			@Override
			public boolean cancel(boolean mayInterruptIfRunning) {
				// TODO Auto-generated method stub
				return false;
			}
		};

有获取结果。这是一个阻塞的方法 ，如果调用这个方法之前结果还没有算出来，那么就等着，所以这里有取消，还有获取是否计算完毕，是否取消，如果程序对等待时间有要求那么用带时间参数的获取方法，如果在规定时间内没能算完，则会抛出一个超时异常。

不同的是Future可以交给一个线程来运行，之后 我们就不用管它了，等着get就可以了。

futuretask

futuretask是一个包装器，可以将Callable转换成Future和Runnable

	private void test() {
		// TODO Auto-generated method stub
		System.out.println(System.currentTimeMillis());
		Callable<Integer> call = new Callable<Integer>() {

			@Override
			public Integer call() throws Exception {
				// TODO Auto-generated method stub
				int result = 0;
				for (int i = 0; i < 1000; i++) {
					for (int j = 0; j < 1000; j++) {
						result += i;
					}

				}
				return result;
			}
		};
		System.out.println(System.currentTimeMillis());
		FutureTask<Integer> task = new FutureTask<Integer>(call);
		Thread t = new Thread(task);
		t.start();
		try {
			System.out.println(task.get());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}