其实非常简单:其实他们的区别就是Callable有返回值并且可以抛出异常。

/**
 * Represents a command that can be executed. Often used to run code in a
 * different {@link Thread}.
 */
public interface Runnable {

/**
     * Starts executing the active part of the class' code. This method is
     * called when a thread is started that has been created with a class which
     * implements {@code Runnable}.
     */
    public void run();
}

/**
 * A task that returns a result and may throw an exception.
 * Implementors define a single method with no arguments called
 * <tt>call</tt>.
 *
 * <p>The <tt>Callable</tt> interface is similar to {@link
 * java.lang.Runnable}, in that both are designed for classes whose
 * instances are potentially executed by another thread.  A
 * <tt>Runnable</tt>, however, does not return a result and cannot
 * throw a checked exception.
 *
 * <p> The {@link Executors} class contains utility methods to
 * convert from other common forms to <tt>Callable</tt> classes.
 *
 * @see Executor
 * @since 1.5
 * @author Doug Lea
 * @param <V> the result type of method <tt>call</tt>
 */
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;
}

2. Thread类

 1、Runnable接口源码:

1 public interface Runnable {
2 public void run();
3 }

  2、Thread类与Runnable接口的继承关系

1 public class Thread implements Runnable{
2
3 }

  Runnable接口仅有一个run()方法,Thread类实现了Runnable接口。

  3、构造函数

1 public Thread() {
2 init(null, null, "Thread-" + nextThreadNum(), 0);
3 }
1 public Thread(Runnable target) {
2 init(null, target, "Thread-" + nextThreadNum(), 0);
3 }
1 public Thread(ThreadGroup group, Runnable target) {
2 init(group, target, "Thread-" + nextThreadNum(), 0);
3 }
1 public Thread(String name) {
2 init(null, null, name, 0);
3 }
                  还有其它的构造方法,此处省略。。。

  这里的第三个参数是设置线程的名称,从下面的代码中可以看出,生成名称的规则是:”Thread-”加上创建的线程的个数(第几个)。

继续查看init方法:

 1 /**
2 * Initializes a Thread.
3 *
4 * @param g the Thread group
5 * @param target the object whose run() method gets called
6 * @param name the name of the new Thread
7 * @param stackSize the desired stack size for the new thread, or
8 * zero to indicate that this parameter is to be ignored.
9 */
    //ThreadGroup:线程组表示一个线程的集合。此外,线程组也可以包含其他线程组。线程组构成一棵树,在树中,除了初始线程组外,每个线程组都有一个父线程组。 
10 private void init(ThreadGroup g, Runnable target, String name,
11 long stackSize) {
12 Thread parent = currentThread();
13 SecurityManager security = System.getSecurityManager();
14 if (g == null) {
15 /* Determine if it's an applet or not */
16
17 /* If there is a security manager, ask the security manager
18 what to do. */
19 if (security != null) {
20 g = security.getThreadGroup();
21 }
22
23 /* If the security doesn't have a strong opinion of the matter
24 use the parent thread group. */
25 if (g == null) {
26 g = parent.getThreadGroup();
27 }
28 }
29
30 /* checkAccess regardless of whether or not threadgroup is
31 explicitly passed in. */
32 g.checkAccess();
33
34 /*
35 * Do we have the required permissions?
36 */
37 if (security != null) {
38 if (isCCLOverridden(getClass())) {
39 security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
40 }
41 }
42
43
44 g.addUnstarted();
45
46 this.group = g;

    //每个线程都有一个优先级,高优先级线程的执行优先于低优先级线程。每个线程都可以或不可以标记为一个守护程序。当某个线程中运行的代码创建一个新 Thread 对象时,该新线程的初始优先级被设定为创建线程的优先级,并且当且仅当创建线程是守护线程时,新线程才是守护程序。

47     this.daemon = parent.isDaemon();
48 this.priority = parent.getPriority();
49 this.name = name.toCharArray();
50 if (security == null || isCCLOverridden(parent.getClass()))
51 this.contextClassLoader = parent.getContextClassLoader();
52 else
53 this.contextClassLoader = parent.contextClassLoader;
54 this.inheritedAccessControlContext = AccessController.getContext();
55 this.target = target;
56 setPriority(priority);
57 if (parent.inheritableThreadLocals != null)
58 this.inheritableThreadLocals =
59 ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
60 /* Stash the specified stack size in case the VM cares */
61 this.stackSize = stackSize;
62
63 /* Set thread ID */
64 tid = nextThreadID();
65 }

  初始化时设置了是否为守护线程,优先级,初始化名称。

  4、Thread的start方法的实现:

 1 public synchronized void start() {
2 /**
3 * This method is not invoked for the main method thread or "system"
4 * group threads created/set up by the VM. Any new functionality added
5 * to this method in the future may have to also be added to the VM.
6 *
7 * A zero status value corresponds to state "NEW".
8 */
9 if (threadStatus != 0)
10 throw new IllegalThreadStateException();
11 group.add(this);
12 start0();
13 if (stopBeforeStart) {
14 stop0(throwableFromStop);
15 }
16 }

  这里主要的是start0方法;查看其实现:

 1 private native void start0();

  这里使用了本地调用,通过C代码初始化线程需要的系统资源。可见,线程底层的实现是通过C代码去完成的。

4、Thread的run方法的实现

1 public void run() {
2 if (target != null) {
3 target.run();
4 }
5 }

  这里的target实际上要保存的是一个Runnable接口的实现的引用:

1 private Runnable target;

  所以使用继承Thread创建线程类时,需要重写run方法,因为默认的run方法什么也不干。

  而当我们使用Runnable接口实现线程类时,为了启动线程,需要先把该线程类实例初始化一个Thread,实际上就执行了如下构造函数:

1 public Thread(Runnable target) {
2 init(null, target, "Thread-" + nextThreadNum(), 0);
3 }

  即是把线程类的引用保存到target中。这样,当调用Thread的run方法时,target就不为空了,而是继续调用了target的run方法,所以我们需要实现Runnable的run方法。这样通过Thread的run方法就调用到了Runnable实现类中的run方法。

  这也是Runnable接口实现的线程类需要这样启动的原因。

另外java中的Executor 类也是非常简单的接口,只有一个execute()方法

public interface Executor {

/**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the <tt>Executor</tt> implementation.
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution.
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

Excutor执行已提交的 Runnable 任务的对象。此接口提供一种将任务提交与每个任务将如何运行的机制(包括线程使用的细节、调度等)分离开来的方法。通常使用 Executor 而不是显式地创建线程。例如,可能会使用以下方法,而不是为一组任务中的每个任务调用 new Thread(new(RunnableTask())).start()

 Executor executor = anExecutor;
executor.execute(new RunnableTask1());
executor.execute(new RunnableTask2());
...

不过,Executor 接口并没有严格地要求执行是异步的。在最简单的情况下,执行程序可以在调用方的线程中立即运行已提交的任务:

 class DirectExecutor implements Executor {
public void execute(Runnable r) {
r.run();
}
}

更常见的是,任务是在某个不是调用方线程的线程中执行的。以下执行程序将为每个任务生成一个新线程。

 class ThreadPerTaskExecutor implements Executor {
public void execute(Runnable r) {
new Thread(r).start();
}
}

许多 Executor 实现都对调度任务的方式和时间强加了某种限制。以下执行程序使任务提交与第二个执行程序保持连续,这说明了一个复合执行程序。

 class SerialExecutor implements Executor {
final Queue<Runnable> tasks = new LinkedBlockingQueue<Runnable>();
final Executor executor;
Runnable active; SerialExecutor(Executor executor) {
this.executor = executor;
} public synchronized void execute(final Runnable r) {
tasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (active == null) {
scheduleNext();
}
} protected synchronized void scheduleNext() {
if ((active = tasks.poll()) != null) {
executor.execute(active);
}
}
}

关于Thread的Runnable和Callable接口的更多相关文章

  1. java 多线程:Callable接口;FutureTask类实现对象【Thread、Runnable、Callable三种方式实现多线程的区别】

    Callable接口介绍: Java5开始,Java提供了Callable接口,像是Runnable接口的增强版,Callable接口提供了一个 call()方法可以作为线执行体. call()方法比 ...

  2. Java并发编程之线程创建和启动(Thread、Runnable、Callable和Future)

    这一系列的文章暂不涉及Java多线程开发中的底层原理以及JMM.JVM部分的解析(将另文总结),主要关注实际编码中Java并发编程的核心知识点和应知应会部分. 说在前面,Java并发编程的实质,是线程 ...

  3. Java:多线程,分别用Thread、Runnable、Callable实现线程

    并发性(concurrency)和并行性(parallel)是两个概念,并行是指在同一时刻,有多条指令在多个处理器上同时执行:并发指在同一时刻只能有一条指令执行,但多个进程指令被快速轮换执行,使得宏观 ...

  4. Java多线程之Thread、Runnable、Callable及线程池

    一.多线程 线程是指进程中的一个执行流程,一个进程中可以有多个线程.如java.exe进程中可以运行很多线程.进程是运行中的程序,是内存等资源的集合,线程是属于某个进程的,进程中的多个线程共享进程中的 ...

  5. Android进阶——多线程系列之Thread、Runnable、Callable、Future、FutureTask

    多线程一直是初学者最抵触的东西,如果你想进阶的话,那必须闯过这道难关,特别是多线程中Thread.Runnable.Callable.Future.FutureTask这几个类往往是初学者容易搞混的. ...

  6. 使用Runnable和Callable接口实现多线程的区别

    使用Runnable和Callable接口实现多线程的区别 先看两种实现方式的步骤: 1.实现Runnable接口 public class ThreadDemo{ public static voi ...

  7. Runnable和Callable接口辨析

    突然发现和启动一个线程有关的有三函数,run(), call(), start(),有点小乱,所以特别梳理一下 首先说一下start(),这个是最好说的,感觉start()和run()这俩名字是真的有 ...

  8. [多线程]多线程(Thread、Runnable、Callable)

    1.继承Thread类,重写run方法 线程 是程序中的执行线程.Java 虚拟机允许应用程序并发地运行多个执行线程. 每个线程都有一个优先级,高优先级线程的执行优先于低优先级线程.每个线程都可以或不 ...

  9. 多线程-Thread,Runnable,Callable,Future,RunnableFuture,FutureTask

    类图: 先看各自的源码: public interface Runnable { public abstract void run(); } public class Thread implement ...

随机推荐

  1. Linux实现SSH无密码登录(对目录权限的设置非常详细,可以参考一下)

    假设服务器IP地址为192.168.1.1,机器名:cluster.hpc.org 客户端IP地址为172.16.16.1,机器名:p470-2.wangrx.sioc.ac.cn 客户端用户yzha ...

  2. jQuery 序列化表单数据 serialize() serializeArray()

    1.serialize()方法 格式:var data = $("form").serialize(); 功能:将表单内容序列化成一个字符串. 这样在ajax提交表单数据时,就不用 ...

  3. 【转】内核编译时, 到底用make clean, make mrproper还是make distclean(转载)

    原文网址:http://dongyulong.blog.51cto.com/1451604/449470 内核编译时, 到底用make clean, make mrproper还是make distc ...

  4. < IOS > 文件中 某个类设置ARC,或者非ARC

    用-fno-objc-arc标记来禁用在ARC工程那些不支持ARC的文件的ARC用-fobjc-arc标记启用非ARC工程中支持ARC的文件 项目targets -> build phases ...

  5. 【C++第三课】---新的关键字

    一.动态分配内存的时的关键字 注意在C++中和C不一样的是,在C中使用的malloc来动态分配内存,而这个malloc只是标准C库的调用,所以这个不属于标准C的范畴,而在C++ 中却有真正的关键字来分 ...

  6. Java算法简介及排序剖析

    本文来自http://blog.csdn.net/liuxian13183/ ,引用必须注明出处! 从小白晋升,一路走来:从helloworld,到JFrame,再到Android:从城外小子,到内城 ...

  7. 用数据说话,外贸B2C产品选择(上篇)-热门搜索法

    当选择了外贸这条路,那就是选择了跟外国人做生意.那面对全球这么大的市场究竟选什么样的产品才干脱颖而出?什么样的产品才是全球卖家喜欢的呢?什么样的产品才干让自己財源滚滚?我想这都是全部刚開始外贸创业的人 ...

  8. Sublime Text 2 介紹

    代码编辑器或者文本编辑器,对于程序猿来说,就像剑与战士一样,谁都想拥有一把能够随心驾驭且瑞丽无比的宝剑,而每一位程序猿,相同会去追求最适合自己的强大.灵活的编辑器,相信你和我一样,都不会例外. 我用过 ...

  9. Android应用程序与SurfaceFlinger服务之间的共享UI元数据(SharedClient)的创建过程分析

    文章转载至CSDN社区罗升阳的安卓之旅,原文地址:http://blog.csdn.net/luoshengyang/article/details/7867340 在前面一篇文章中,我们分析了And ...

  10. 四、Mp3文件类型及其判断

    根据前两篇文章的分析,帧分为标签帧和数据帧,MP3文件类型是根据数据帧的类型来分的,文件类型如下表: 位率相等(Constant BitRate) CBR  Mp3文件 位率不等(Variable B ...