看代码

public static void main(String[] args) {
// TODO Auto-generated method stub new MyThread().start();
new MyThread().start(); } class MyThread extends Thread{
private int ticket = 5;
public void run(){
while(true){
System.out.println("Thread ticket = " + ticket--);
if(ticket < 0){
break;
}
}
}
}

输出结果:

Thread ticket = 5
Thread ticket = 5
Thread ticket = 4
Thread ticket = 4
Thread ticket = 3
Thread ticket = 2
Thread ticket = 3
Thread ticket = 1
Thread ticket = 2
Thread ticket = 0
Thread ticket = 1
Thread ticket = 0

这样多卖了一半的票显然不合理,用runnable试试:

public static void main(String[] args) {
// TODO Auto-generated method stub
MyThread2 m=new MyThread2();
new Thread(m).start();
new Thread(m).start(); }
class MyThread2 implements Runnable{
private int ticket = 5;
public void run(){
while(true){
System.out.println("Runnable ticket = " + ticket--);
if(ticket < 0){
break;
}
}
}
}

输出结果:

Runnable ticket = 5
Runnable ticket = 4
Runnable ticket = 3
Runnable ticket = 2
Runnable ticket = 1
Runnable ticket = 0

这样的结果才合理。
很明显这个例子完全错误,多卖票的原因根本不是因为Runnable和Thread的区别,看调用就知道了。
使用Thread的时候是这样调用的:

new MyThread().start();
new MyThread().start();

而使用Runnable的时候是这样调用的:

new Thread(m).start();
new Thread(m).start();

新建了两个MyThread对象去卖票,不卖两倍票才怪呢,而Runnable卖票的时候是同一个Runnable对象,肯定只卖一倍票,所以这个例子根本没体现Runnable和Thread的区别,再来看一个例子:

public class TicketThread extends Thread{

    private int ticket = 10;

    public void run(){
for(int i =0;i<10;i++){
synchronized (this){
if(this.ticket>0){
try {
Thread.sleep(100);
System.out.println(Thread.currentThread().getName()+"卖票---->"+(this.ticket--));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
} public static void main(String[] arg){
TicketThread t1 = new TicketThread();
new Thread(t1,"线程1").start();
new Thread(t1,"线程2").start();
}
}

输出结果:

线程1卖票—->10
线程1卖票—->9
线程1卖票—->8
线程2卖票—->7
线程2卖票—->6
线程1卖票—->5
线程1卖票—->4
线程2卖票—->3
线程2卖票—->2
线程1卖票—->1

(这里必须使用synchronized,否则会出现重复卖某一张票的情况,当然这点和本篇文章无关,这里不做详述。)
这样就达到了卖一倍票的结果,没毛病。这样看起来,Thread和Runnable岂不是没区别了?
找到答案很简单,点进去看Thread源码就知道了

public class Thread implements Runnable {}

可以看出,Thread实现了Runnable接口,这和上面例子中的MyThread2一样了,当我们使用

TicketThread t1 = new TicketThread();
new Thread(t1,"线程1").start();

这种写法时,会被认为智障。。。。没错,就是智障,这是脱裤子放屁的写法,标准写法应该是:

TicketThread t1 = new TicketThread();
t1.start();

看看源码:

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

new Thread( new TicketThread(),"线程1").start();这种写法里面,TicketThread会被当做一个Runnable,那我还要写一个TicketThread类干嘛?所以这就是脱裤子放屁。
说了这么多,那两者的区别到底是什么?
来看看Runnable的代码:

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();
}

结论就是:

1、效果上没区别,写法上的区别而已。
2、没有可比性,Thread实现了Runnable接口并进行了扩展,我们通常拿来进行比较只是写法上的比较,而Thread和Runnable的实质是实现的关系,不是同类东西。

无论你使用Runnable还是Thread,都有一个new Thread的过程,效果上最后都是new Thread,然后执行run方法。写法上的区别无非就是你是new Thead还是new你自定义的thread,如果你有复杂的线程操作需求,那就自定义Thread,如果只是简单的在子线程run一下任务,那就自己实现runnable,当然如果自己实现runnable的话可以多一个继承(自定义Thread必须继承Thread类,java单继承规定导致不能在继承别的了)。

Runnable和Thread比较的更多相关文章

  1. Android笔记——Handler Runnable与Thread的区别

    在java中可有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口:Thread类是在java.lang包中定义的.一个类只要继承了Thread类同时覆写了本类中的run() ...

  2. Java中Runnable和Thread的区别

    在java中可有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口:Thread类是在java.lang包中定义的.一个类只要继承了Thread类同时覆写了本类中的run() ...

  3. Runnable,Thread实现多线程以及Runnable的同步资源共享

    (一) 实现多线程有两种方式 (1) 继承Thread类,重写run()方法,如以下例子 class MyThread extends Thread{ public void run(){ // } ...

  4. Android开发:Handler Runnable和Thread之间的区别和联系 应用--------------------看完本篇,从此一览无余!

    http://blog.csdn.net/yanzi1225627/article/details/8582081 在java中可有两种方式实现多线程,一种是继承Thread类,一种是实现Runnab ...

  5. java多线程(二)-Runnable和Thread

    Java在顺序性语言的基础上提供了多线程的支持.Java的线程机制是抢占式的.这表示调度机制会周期的中断线程,将上下文切换到另一个线程,从而为每个线程都提供时间片.(与抢占式多线程对应的是 协作式多线 ...

  6. Java多线程中的Runnable和Thread

    摘要: 在java中可有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口:Thread类是在java.lang包中定义的.一个类只要继承了Thread类同时覆写了本类中的r ...

  7. Android开发笔记之:Handler Runnable与Thread的区别详解

    在java中可有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口:Thread类是在java.lang包中定义的.一 个类只要继承了Thread类同时覆写了本类中的run( ...

  8. Java多线程之Runnable与Thread

    Java多线程之Thread与Runnable 一.Thread VS Runnable 在java中可有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口:Thread类和 ...

  9. 彻底理解Runnable和Thread的区别

    昨天去面试,面试官问了一个问题:Runnable和Thread有什么区别,因为针对这个问题以前有背过,并且网上大多数都是这些结论,所以脱口而出: 1.Thread有单继承的问题: 2.Runnable ...

随机推荐

  1. 如何实现在Eclipse导入c3p0

    1 右键项目->Properties->Java Build Path->Libraries->Add External JARs...-> c3p0-0.9.5.2.j ...

  2. MySQL 数据库架构

    1 架构 master-slave性能,qps,tps,cpu,disk,memory,network,raid卡,fashion卡, 并发量:同一时刻需要db处理 连接量: 大表:1000w行或者表 ...

  3. Prometheus告警模型分析

    Prometheus作为时下最为流行的开源监控系统,其庞大的生态体系:包括针对各种传统应用的Exporter,完整的二次开发工具链,与Kubernetes等主流平台的高度亲和以及由此带来的强大的自发现 ...

  4. CTF—WEB—sql注入之宽字节注入

     宽字节注入 宽字节注入是利用mysql的一个特性,mysql在使用GBK编码(GBK就是常说的宽字节之一,实际上只有两字节)的时候,会认为两个字符是一个汉字(前一个ascii码要大于128,才到汉字 ...

  5. 剑指Offer总结——用两个栈实现队列

    class Solution { public: void push(int node) { stack2.push(node); } int pop() { if(stack1.empty()){ ...

  6. 【VS开发】动态创建ActiveX控件

    bool CCollectDataDlgDlg::CreateMyCtrl(LPRECT lpRect, UINT nID, CWnd *pParent) {  CLSID clsid;  wstri ...

  7. [百度知道]ssm和ssh各自的优势

    https://zhidao.baidu.com/question/875108451824176892.html SSM和SSH不同主要在MVC实现方式,以及ORM持久化方面不同(Hiibernat ...

  8. React基础篇学习

    到今天为止, 使用react已经一年了, 现在整理一下入门时的一些重要知识, 帮助想要学习react的同学们理解某些内容. React 元素 React 元素,它是 React 中最小基本单位,我们可 ...

  9. linux-yum-downloadonly 下载rpm安装包到本地

    注意 注意1:如果机器,本来就安装了相应的rpm包,则该rpm包不会下载. 参考 centos7离线安装rpm包自动解决依赖 查看linux系统版本信息(Oracle Linux.Centos Lin ...

  10. hugo搭建个人博客

    本地先安装git 1. 下载hugo,并配置好环境变量 我这里win7 64位,选择该版本下载 将解压后的hugo.exe,配置到环境变量中,如下图所示表明配置成功 hugo version 2. 生 ...