1、Runnable和Callable的区别是：
(1)Callable规定的方法是call(),Runnable规定的方法是run().
(2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得
(3)call方法可以抛出异常，run方法不可以
(4)运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。
public interface Runnable {
/**
* When an object implementing interface <code>Runnable</code> is used
* to create a thread, starting the thread causes the object‘s
* <code>run</code> method to be called in that separately executing
* thread.
* <p>
* The general contract of the method <code>run</code> is that it may
* take any action whatsoever.
*
* @see java.lang.Thread#run()
*/
public abstract void run();
}
public interface Callable<V> {/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}
由代码可以清晰看出：两个接口的差别：Runnable只有一个run()函数，没有返回值；Callable一个泛型接口，call()函数返回的类型就是客户程序传递进来的V类型。
使用实例：
Runnable():
class RunThread implements Runnable
{
@Override
public void run()
{
}
}
//调用
new thread(new RunThread()).start();
Callable<T>():
class CallThread implements Callable<String>
{
@Override
public String call() throws Exception {
return null;
}
}
//调用
ExecutorService pool = Executors.newCachedThreadPool();
Future<String> future = pool.submit(new CallThread());
String result = future.get();//注意这里要加上try_catch异常控制语句
pool.shutdown();
Future:
public interface Future<V> {/**
* Attempts to cancel execution of this task. This attempt will
*/boolean cancel(boolean mayInterruptIfRunning);
/**
* Returns <tt>true</tt> if this task was cancelled before it complete
*/boolean isCancelled();
/**
* Returns <tt>true</tt> if this task completed.
*/boolean isDone();
/**
* Waits if necessary for the computation to complete, and then
*/
V get() throws InterruptedException, ExecutionException;
/**
* Waits if necessary for at most the given time for the computation
* to complete, and then retrieves its result, if available.
*/
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
Future表示异步计算的结果，它提供了检查计算是否完成的方法isDone()，以等待计算的完成，并检索计算的结果。Future的cancel()方法可以取消任务的执行，它有一布尔参数，参数为 true 表示立即中断任务的执行，参数为 false 表示允许正在运行的任务运行完成。Future的 get() 方法等待计算完成，获取计算结果；
FutureTask
FutureTask实现了RunnableFuture<V>接口，而RunnableFuture实现了Runnbale又实现了Futrue<V>这两个接口：
public class FutureTask<V> implements RunnableFuture<V>
public interface RunnableFuture<V> extends Runnable, Future<V> {/**
* Sets this Future to the result of its computation
* unless it has been cancelled.
*/void run();
}
2、Runnable与Thread区别：
class
Thread implements Runnable {
/**
*
Allocates a new {@code Thread} object. This constructor has the same
*/
public
Thread() {
init(null, null, "Thread-" + nextThreadNum(), 0);
}
/**
*
Allocates a new {@code Thread} object. This constructor has the same
*/
public Thread(Runnable
target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}
public synchronized void
start() {
}
@Override
public void run() {
if (target != null) {
target.run();
}
}
}
1、可以看出Thread是类，Runnable是接口，而Thread实现了Runnable接口；
2、实现线程的方式可以：继承Thread,也可以实现Runnbale接口（当然也可以实现Callable接口）
3、由于继承Thread类，Java是单继承，就难以继承其他的类，这是宜使用Runnable的原因；