Runnable 和Callable的实现与区别，应用场景
Java 提供了三种创建线程的方法
1：通过实现Runnable接口
2：通过继承Thread接口
3：通过Callable和Future创建线程
-
相同点
都是接口
都可以编写多线程程序
都采用Thread.start()启动线程
-
不同点
(1)Callable规定的方法是call()，Runnable规定的方法是run()。其中Runnable可以提交给Thread来包装下，直接启动一个线程来执行，而Callable则一般都是提交给ExecuteService来执行。(2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得
(3)call方法可以抛出异常，run方法不可以
(4)运行Callable任务可以拿到一个Future对象，c表示异步计算的结果。
注：Callalbe接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。
线程的创建如下
1、通过实现Runnable接口来创建Thread线程：
步骤1：创建实现Runnable接口的类：
class SomeRunnable implements Runnable
{
public void run()
{
//do something here
}
}
步骤2：创建一个类对象：
Runnable oneRunnable = new SomeRunnable();
步骤3：由Runnable创建一个Thread对象：
Thread oneThread = new Thread(oneRunnable);
步骤4：启动线程：
oneThread.start();
至此，一个线程就创建完成了。
注释：线程的执行流程很简单，当执行代码oneThread.start();时，就会执行oneRunnable对象中的void run();方法，
该方法执行完成后，线程就消亡了。
2、与方法1类似，通过实现Callable接口来创建Thread线程：其中，Callable接口（也只有一个方法）定义如下：
public interface Callable
{
V call() throws Exception;
}
步骤1：创建实现Callable接口的类SomeCallable（略）；
步骤2：创建一个类对象：
Callable oneCallable = new SomeCallable();
步骤3：由Callable创建一个FutureTask对象：
FutureTask oneTask = new FutureTask(oneCallable);
注释：FutureTask是一个包装器，它通过接受Callable来创建，它同时实现了Future和Runnable接口。
步骤4：由FutureTask创建一个Thread对象：
Thread oneThread = new Thread(oneTask);
步骤5：启动线程：
oneThread.start();
至此，一个线程就创建完成了。
3、通过继承Thread类来创建一个线程：
步骤1：定义一个继承Thread类的子类：
class SomeThead extends Thraad
{
public void run()
{
//do something here
}
}
步骤2：构造子类的一个对象：
SomeThread oneThread = new SomeThread();
步骤3：启动线程：
oneThread.start();
至此，一个线程就创建完成了。
注释：这种创建线程的方法不够好，主要是因为其涉及运行机制问题，影响程序性能。
4、通过线程池来创建线程：
步骤1：创建线程池：
ExecutorService pool = Executors.newCachedThreadPool();
步骤2：通过Runnable对象或Callable对象将任务提交给ExecutorService对象：
Future submit(Callable task);
注释：Future是一个接口，它的定义如下：
public interface Future
{
V get() throws …;
V get(long timeout, TimeUnit unit) throws …;
void cancle(boolean mayInterrupt);
boolean isCancelled();
boolean isDone();
}
至此，一个线程就创建完成了。
注释：线程池需调用shutdown();方法来关闭线程。
5、通过事件分配线程直接使用程序中的原有线程：
使用方法：
直接调用EventQueue类的静态方法invokeLater()：
EventQueue.invokeLater(oneRunnable);
注释：调用EventQueue.invokeLater(oneRunnable);会直接执行oneRunnable对象中的run()方法
Callable使用
/**
* CallableImpl 简要描述
* TODO:描述该类职责
*
* @author ckmike
* @version 1.0
* @date 18-12-6 下午8:53
* @copyright ckmike
**/
public class CallableImpl implements Callable {
private String accept;
public CallableImpl(String accept) {
this.accept = accept;
}
@Override
public String call() throws Exception {
// 休眠
TimeUnit.SECONDS.sleep(3);
return this.accept;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
Callable callable = new CallableImpl("my callable test!");
FutureTask task = new FutureTask<>(callable);
long beginTime = System.currentTimeMillis();
// 创建线程
new Thread(task).start();
// 调用get()阻塞主线程，反之，线程不会阻塞
String result = task.get();
long endTime = System.currentTimeMillis();
System.out.println("hello : " + result);
System.out.println("cast : " + (endTime - beginTime) / 1000 + " second!");
}
}
Runnable使用
/**
* RunnableImpl 简要描述
* TODO:描述该类职责
*
* @author ckmike
* @version 1.0
* @date 18-12-6 下午9:03
* @copyright ckmike
**/
public class RunnableImpl implements Runnable {
public RunnableImpl(String accept) {
this.accept = accept;
}
private String accept;
@Override
public void run() {
// 线程阻塞 1 秒，此时有异常产生，只能在方法内部消化，无法上抛
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 最终处理结果无法返回
System.out.println("hello : " + this.accept);
}
public static void main(String[] args) {
Runnable runnable = new RunnableImpl("my runable test!");
long beginTime = System.currentTimeMillis();
new Thread(runnable).start();
long endTime = System.currentTimeMillis();
System.out.println("cast : " + (endTime - beginTime) / 1000 + " second!");
}
}