&&&&&&&&在java中，其实java中实现 多线程有三种方法，一种是继承Thread类；第二种是实现Runnable接口；第三种是实现Callable接口。
1，继承Thread
&&&&&&&&Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限。
&&&&&&&&下面看例子：
package org.thread.
　　class MyThread extends Thread{
　　private S
　　public MyThread(String name) {
　　super();
　　this.name =
　　public void run(){
　　for(int i=0;i&10;i++){
　　System.out.println("线程开始："+this.name+",i="+i);
　　package org.thread.
　　public class ThreadDemo01 {
　　public static void main(String[] args) {
　　MyThread mt1=new MyThread("线程a");
　　MyThread mt2=new MyThread("线程b");
　　mt1.run();
　　mt2.run();
&&&&&&&&但是，此时结果很有规律，先第一个对象执行，然后第二个对象执行，并没有相互运行。在JDK的文档中可以发现，一旦调用start()方法，则会通过JVM找到run()方法。下面启动start()方法启动线程：
package org.thread.
public class ThreadDemo01 {
public static void main(String[] args) {
MyThread mt1=new MyThread("线程a");
MyThread mt2=new MyThread("线程b");
mt1.start();
mt2.start();
&&&&&&&&这样程序可以正常完成交互式运行。那么为啥非要使用start();方法启动多线程呢？
&&&&&&&&在JDK的安装路径下，src.zip是全部的java源程序，通过此代码找到Thread中的start()方法的定义，可以发现此方法中使用了private native void start0();其中native关键字表示可以调用操作系统的底层函数，那么这样的技术成为JNI技术（java Native Interface）
2，Runnable接口
&&&&&&&&在实际开发中一个多线程的操作很少使用Thread类，而是通过Runnable接口
public interface Runnable{
public void run();
package org.runnable.
class MyThread implements Runnable{
public MyThread(String name) {
this.name =
public void run(){
for(int i=0;i&100;i++){
System.out.println("线程开始："+this.name+",i="+i);
&&&&&&&&使用Runnable定义的子类中没有start()方法，只有Thread类中才有。此时观察Thread类，有一个构造方法：public Thread(Runnable targer)此构造方法接受Runnable的子类实例，也就是说可以通过Thread类来启动Runnable实现的多线程。（start()可以协调系统的资源）：
package org.runnable.
import org.runnable.demo.MyT
public class ThreadDemo01 {
public static void main(String[] args) {
MyThread mt1=new MyThread("线程a");
MyThread mt2=new MyThread("线程b");
new Thread(mt1).start();
new Thread(mt2).start();
&&&&&&&&两种实现方式的区别和联系：
&&&&&&&&在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比继承Thread类有如下好处：
&&&&&&&&&&&&&&&&1,避免点继承的局限，一个类可以继承多个接口。
&&&&&&&&&&&&&&&&2,适合于资源的共享
&&&&&&&&Runnable接口和Thread之间的联系：
&&&&&&&&public class Thread extends Object implements Runnable
&&&&&&&&发现Thread类也是Runnable接口的子类。
3，Callable接口
&&&&&&&&Callable 和 Runnable 的使用方法大同小异， 区别在于：
&&&&&&&&&&&&&&&&1.Callable 使用 call（） 方法， Runnable 使用 run() 方法
&&&&&&&&&&&&&&&&2.call() 可以返回值， 而 run()方法不能返回。
&&&&&&&&&&&&&&&&3.call() 可以抛出受检查的异常，比如ClassNotFoundException， 而run()不能抛出受检查的异常。
&&&&&&&&Callable示例如下：
class TaskWithResult implements Callable&String& {
private int
public TaskWithResult(int id) {
public String call() throws Exception {
return "result of TaskWithResult " +
public class CallableTest {
public static void main(String[] args) throws InterruptedException,
ExecutionException {
ExecutorService exec = Executors.newCachedThreadPool();
ArrayList&Future&String&& results = new ArrayList&Future&String&&();
for (int i = 0; i & 10; i++) {
results.add(exec.submit(new TaskWithResult(i)));
for (Future&String& fs : results) {
if (fs.isDone()) {
System.out.println(fs.get());
System.out.println("Future result is not yet complete");
exec.shutdown();
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：2252次
排名：千里之外
原创：16篇
(1)(1)(6)(6)(5)(4)Java中Runnable和Thread的区别
继承Thread和实现Runable都可以实现多线程，下面通过一个实例说明两者的区别：
1、继承Thread类多线程（Thread实质也是Runnable的接口的子类）
public class MyThread1 extends Thread{
private int ticket=10;
public void run(){
for(int i=0;i0){
System.out.println("卖票：ticket"+this.ticket--);
public static void main(String[] args) {
MyThread1 mt1=new MyThread1();
MyThread1 mt2=new MyThread1();
MyThread1 mt3=new MyThread1();
mt1.start();//每个线程都各卖了10张，共卖了30张票
mt2.start();//但实际只有10张票，每个线程都卖自己的票
mt3.start();//没有达到资源共享
卖票：ticket10
卖票：ticket9
卖票：ticket8
卖票：ticket7
卖票：ticket6
卖票：ticket5
卖票：ticket4
卖票：ticket3
卖票：ticket2
卖票：ticket1
卖票：ticket10
卖票：ticket9
卖票：ticket8
卖票：ticket7
卖票：ticket6
卖票：ticket5
卖票：ticket4
卖票：ticket3
卖票：ticket2
卖票：ticket1
卖票：ticket10
卖票：ticket9
卖票：ticket8
卖票：ticket7
卖票：ticket6
卖票：ticket5
卖票：ticket4
卖票：ticket3
卖票：ticket2
卖票：ticket1
2、实现Runnable接口
public class TestRunable implements Runnable{
private int ticket=10;
public void run() {
// TODO Auto-generated method stub
for(int i=0;i0){
System.out.println("卖票：ticket"+this.ticket--);
public static void main(String[] args) {
TestRunable mt=new TestRunable();
new Thread(mt).start();//同一个mt，但是在Thread中就不可以，如果用同一
new Thread(mt).start();//个实例化对象mt，就会出现异常
new Thread(mt).start();
卖票：ticket10
卖票：ticket9
卖票：ticket8
卖票：ticket7
卖票：ticket5
卖票：ticket3
卖票：ticket2
卖票：ticket1
卖票：ticket6
卖票：ticket4
总结一下两者的区别：
·一个类可以实现多个接口，但只能继承一个类
·Runnable可以实现资源共享
补充，另附一道SCJP的考试题：
public class MyThread implements Runnable{
public void run() {
// TODO Auto-generated method stub
System.out.println("run");
throw new RuntimeException("Problem");
public static void main(String[] args) {
Thread thread = new Thread(new MyThread());
thread.start();
System.out.println("End of method");
Which two can be results? (Choose two.)
A. java.lang.RuntimeException: Problem
java.lang.RuntimeException: Problem
C. End of method.
java.lang.RuntimeException: Problem
D. End of method.
java.lang.RuntimeException: Problem
java.lang.RuntimeException: Problem
End of method
(window.slotbydup=window.slotbydup || []).push({
id: '2467140',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467141',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467142',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467143',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467148',
container: s,
size: '1000,90',
display: 'inlay-fix'<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
您的访问请求被拒绝 403 Forbidden - ITeye技术社区
您的访问请求被拒绝
亲爱的会员，您的IP地址所在网段被ITeye拒绝服务，这可能是以下两种情况导致：
一、您所在的网段内有网络爬虫大量抓取ITeye网页，为保证其他人流畅的访问ITeye，该网段被ITeye拒绝
二、您通过某个代理服务器访问ITeye网站，该代理服务器被网络爬虫利用，大量抓取ITeye网页
请您点击按钮解除封锁&java学习（1）
本来这篇文章是要开始讲讲Handler消息传递机制的。无奈里面牵涉了我不太熟悉的Runnable跟Thread，在学习android前，啃了一段时间的java，但是并没有花太多时间研究。没办法，先把基础打牢实了。
Java多线程
java中有两种实现多线程的方式：
1. 一种是通过继承Thread类，同时重写run()方法。但是java中，只允许单继承，也就是一个类只能继承一个父类，使得该方式具有一定的局限性，等下就知道了。
2. 另一种是实现Runnable类接口的run()方法，再结合Thread类来实现多线程。
两种方式最终都是通过调用start()方法来实现多线程。切记不能直接调用Thread类或Runnable对象的run()方法，因为直接调用run()方法，只会执行同一个线程中的任务，而不会启动新线程。调用start()方法将会创建一个执行run()方法的线程。下面讲几个例子来辅助理解：
例1：继承Thread类，调用run()方法
public class MyThread extends Thread {
private int ticket = 5;
public MyThread(String name) {
this.name =
public void run() {
for (int i=0; i&10; i++) {
if (this.ticket&0)
System.out.println("线程开始："+this.name+",卖票：i="+this.ticket--);
public class TestThreadRunnable {
public static void main(String [] args) {
Thread t1 = new MyThread("线程a");
Thread t2 = new MyThread("线程b");
**t1.run()**;
**t2.run()**;
运行结果：
线程开始：线程a,卖票：i=5
线程开始：线程a,卖票：i=4
线程开始：线程a,卖票：i=3
线程开始：线程a,卖票：i=2
线程开始：线程a,卖票：i=1
线程开始：线程b,卖票：i=5
线程开始：线程b,卖票：i=4
线程开始：线程b,卖票：i=3
线程开始：线程b,卖票：i=2
线程开始：线程b,卖票：i=1
结果分析：
看看运行结果，先执行第一个对象的run()，然后执行第二个对象的run()，并没有启动新线程。
例2：继承Thread类，调用start()方法
修改上面的TestThreadRunnable.java
public class TestThreadRunnable {
public static void main(String [] args) {
Thread t1 = new MyThread("线程a");
Thread t2 = new MyThread("线程b");
t1.start();
t2.start();
运行结果：
线程开始：线程b,卖票：i=5
线程开始：线程a,卖票：i=5
线程开始：线程b,卖票：i=4
线程开始：线程b,卖票：i=3
线程开始：线程b,卖票：i=2
线程开始：线程b,卖票：i=1
线程开始：线程a,卖票：i=4
线程开始：线程a,卖票：i=3
线程开始：线程a,卖票：i=2
线程开始：线程a,卖票：i=1
结果分析：
1. 看看运行结果，两个线程正常完成交互运行。说明start()方法是新建了一个线程去执行run()方法。
2. 两个线程访问的run()方法都是独立的，对应的MyThread类成员变量ticket也是独立。资源不能共享。
例3：实现Runnable接口
public class MyRunnable implements Runnable {
private int ticket = 5;
public void run() {
for (int i=0; i&10; i++) {
if (this.ticket&0)
System.out.println("线程开始："+Thread.currentThread().getName()+",卖票："+this.ticket--);
public class TestThreadRunnable {
public static void main(String [] args) {
Runnable r = new MyRunnable();
Thread t1 = new Thread(r, "线程a");
Thread t2 = new Thread(r, "线程b");
t1.start();
t2.start();
运行结果：
线程开始：线程a,卖票：5
线程开始：线程b,卖票：4
线程开始：线程b,卖票：2
线程开始：线程a,卖票：3
线程开始：线程b,卖票：1
结果分析：
1. 使用Runnable对象时，Runnable定义的子类没有start()方法，只有Thread类中才有，观察Thread类，有一个构造方法public Thread(Runnable target)，此构造方法接受Runanble的子类实例，也就是说可以通过Thread类来启动Runnable实现多线程。
2. 每个线程调用的都是同一个MyRunnable对象的run()方法，访问的是同一个对象中的变量ticket实例。
Runnable和Thread区别
实际开发中我们通常采用Runnable接口来实现多线程。因为实现Runnable接口比继承Thread类有如下好处：
1. 避免继承的局限，一个类可以继承多个接口，但是类只能继承一个类。
2. Runnable接口实现的线程便于资源共享。而通过Thread类实现，各自线程的资源是独立的，不方便共享。上面例2可以看出线程a跟线程b各卖了5张票，而例子3两个线程共卖了5张票，而且没有重复。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：6064次
排名：千里之外
原创：42篇
(5)(6)(7)(10)(13)(1)(1)(2)(3)