专栏首页yaphetsfangRunnable和Thread比较

Runnable和Thread比较

看代码

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单继承规定导致不能在继承别的了)。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 为什么要用私钥加签,公钥加密

    之所以用发送方的私钥加签,是因为,即便信息被黑客拦截,黑客修改了信息,但是加签需要用发送方的私钥,黑客没有发送方的私钥,所以也无法生成正确的签名,接收方验签就不...

    yaphetsfang
  • 最全Vue开发环境搭建

    一直想去学Vue,不过一直找不到一个契机。然公司手机端用到了跨平台开发apicloud,里边涉及到Vue组件化开发,例如header和footer的封装,以及a...

    yaphetsfang
  • mysql行转列,列转行

    行转列,列转行是我们在开发过程中经常碰到的问题。行转列一般通过CASE WHEN 语句来实现,也可以通过 SQL SERVER 2005 新增的运算符PIVOT...

    yaphetsfang
  • 某团面试题:JVM 堆内存溢出后,其他线程是否可继续工作?

    最近网上出现一个美团面试题:“一个线程OOM后,其他线程还能运行吗?”。我看网上出现了很多不靠谱的答案。这道题其实很有难度,涉及的知识点有jvm内存分配、作用域...

    乔戈里
  • 某团面试题:JVM 堆内存溢出后,其他线程是否可继续工作?

    这道题其实很有难度,涉及的知识点有jvm内存分配、作用域、gc等,不是简单的是与否的问题。

    良月柒
  • 某团面试题:JVM 堆内存溢出后,其他线程是否可继续工作?

    最近网上出现一个美团面试题:“一个线程OOM后,其他线程还能运行吗?”。我看网上出现了很多不靠谱的答案。这道题其实很有难度,涉及的知识点有jvm内存分配、作用域...

    芋道源码
  • 美团面试题:JVM堆内存溢出后,其他线程是否可继续工作?

    最近网上出现一个美团面试题:“一个线程OOM后,其他线程还能运行吗?”。我看网上出现了很多不靠谱的答案。这道题其实很有难度,涉及的知识点有jvm内存分配、作用域...

    Spark学习技巧
  • Java 的线程工厂 ThreadFactory原理及源码详解

    在我们一般的使用中,创建一个线程,通常有两种方式: 继承Thread类,覆盖run方法,实现我们需要的业务 继承Runnable接口,实现run方法,实现我...

    JavaEdge
  • Radiology:对阿兹海默和行为变异型额颞痴呆症的基于皮层萎缩的个体患者的自动诊断分类

    请点击上面“思影科技”四个字,选择关注我们,思影科技专注于脑影像数据处理,涵盖(fMRI,结构像,DTI,ASL,EEG/ERP,FNIRS,眼动)等,希望专业...

    用户1279583
  • Spring Boot2 系列教程(二十二)整合 MyBatis 多数据源

    关于多数据源的配置,前面和大伙介绍过 JdbcTemplate 多数据源配置,那个比较简单,本文来和大伙说说 MyBatis 多数据源的配置。

    江南一点雨

扫码关注云+社区

领取腾讯云代金券