多线程——Java中继承Thread类与实现Runnable接口的区别

线程我只写过继承Thread类的，后来知道java多线程有三种方式，今天首先比较一下常用的继承Thread类和实现Runnable接口的区别。

 按着Ctrl键进入Thread之后，发现Thread类也是Runnable接口的之类，这应该就是它们之间的联系了吧。

继承Thread类 

  

   

    

     

    
    

     

      class MyThread1 extends Thread{  
     
    
   

    

     

    
    

     
    private int breakfast=10;  
     
    
   

    

     

    
    

     
    private String name;  
     
    
   

    

     

    
    

     
    public MyThread1(String name){  
     
    
   

    

     

    
    

     
        this.name=name;  
     
    
   

    

     

    
    

     

          }  
     
    
   

    

     

    
    

     
    public void run(){  
     
    
   

    

     

    
    

     
        for(int i =0;i<500;i++){  
     
    
   

    

     

    
    

     
            if(this.breakfast>0){  
     
    
   

    

     

    
    

     

                      System.out.println(this.name+"卖早餐---->"+(this.breakfast--));  
     
    
   

    

     

    
    

     

                  }  
     
    
   

    

     

    
    

     

              }  
     
    
   

    

     

    
    

     

          }  
     
    
   

    

     

    
    

     
    public static void main(String[] args) {  
     
    
   

    

     

    
    

     

              MyThread1 mt1= new MyThread1("一号窗口");  
     
    
   

    

     

    
    

     

              MyThread1 mt2= new MyThread1("二号窗口");  
     
    
   

    

     

    
    

     

              MyThread1 mt3= new MyThread1("三号窗口");  
     
    
   

    

     

    
    

     

              mt1.start();  
     
    
   

    

     

    
    

     

              mt2.start();  
     
    
   

    

     

    
    

     

              mt3.start();  
     
    
   

    

     

    
    

     

          }  
     
    
   

    

     

    
    

     

      }  
     
    
  
 

实现Runnable接口

  

   

    

     

    
    

     

      [java] view plain copy
     
    
   

    

     

    
    

     

      class MyThread2 implements Runnable{  
     
    
   

    

     

    
    

     
    private int breakfast =10;  
     
    
   

    

     

    
    

     
    private String name;  
     
    
   

    

     

    
    

     
    public void run(){  
     
    
   

    

     

    
    

     
        for(int i =0;i<500;i++){  
     
    
   

    

     

    
    

     
            if(this.breakfast>0){  
     
    
   

    

     

    
    

     

                      System.out.println(Thread.currentThread().getName()+"卖早餐---->"+(this.breakfast--));  
     
    
   

    

     

    
    

     

                  }  
     
    
   

    

     

    
    

     

              }  
     
    
   

    

     

    
    

     

          }  
     
    
   

    

     

    
    

     
  
     
    
   

    

     

    
    

     
    public static void main(String[] args) {  
     
    
   

    

     

    
    

     
        //设计三个线程 
     
    
   

    

     

    
    

     
        MyThread2 mt = new MyThread2();  
     
    
   

    

     

    
    

     
        Thread t1 = new Thread(mt,"一号窗口");  
     
    
   

    

     

    
    

     
        Thread t2 = new Thread(mt,"二号窗口");  
     
    
   

    

     

    
    

     
        Thread t3 = new Thread(mt,"三号窗口");  
     
    
   

    

     

    
    

     

              t1.start();  
     
    
   

    

     

    
    

     

              t2.start();  
     
    
   

    

     

    
    

     

              t3.start();  
     
    
   

    

     

    
    

     

          }  
     
    
   

    

     

    
    

     

      }  
     
    
  
 

  显然，这两个结果是不同的。为什么会这样呢?我们来分析一下。

              其实，第一个继承Thread类来实现多线程，其实是相当于拿出三件事即三个卖早餐10份的任务分别分给三个窗口，他们各做各的事各卖各的早餐各完成各的任务，因为MyThread继承Thread类，所以在newMyThread的时候在创建三个对象的同时创建了三个线程；实现Runnable的， 相当于是拿出一个卖早餐10份的任务给三个人去共同完成，newMyThread相当于创建一个任务，然后实例化三个Thread，创建三个线程即安排三个窗口去执行。

              一个类只能继承一个父类，存在局限；一个类可以实现多个接口。在实现Runnable接口的时候调用Thread的Thread(Runnable run)或者Thread(Runnablerun,String name)构造方法创建进程时，使用同一个Runnable实例，建立的多线程的实例变量也是共享的；但是通过继承Thread类是不能用一个实例建立多个线程，故而实现Runnable接口适合于资源共享；当然，继承Thread类也能够共享变量，能共享Thread类的static变量；

              如果第二种实现Runnable接口的方式要想达到第一种继承Thread类的效果，可以这样来实例化线程类。

  

   

    

     

    
    

     

      [java] view plain copy
     
    
   

    

     

    
    

     

      //MyThread2 mt = new MyThread2(); 
     
    
   

    

     

    
    

     

      Thread t1 = new Threadnew MyThread2(),"一号窗口");  
     
    
   

    

     

    
    

     

      Thread t2 = new Threadnew MyThread2(),"二号窗口");  
     
    
   

    

     

    
    

     

      Thread t3 = new Thread(new MyThread2(),"三号窗口");  
     
    
  
 

总结

              其实，抽象来说，这并不是Thread类和Runnable接口的区别了，这可以看做是接口和继承的问题。我们弄懂了接口和继承，就不难理解Thread和Runnable。

              在刚接触的时候可能会有些迷糊这二者的区别于联系，但是实践和总结过后我们会发现这是两个完全不同的实现多线程，一个是多个线程分别完成自己的任务，一个是多个线程共同完成一个任务。其实，在实现一个任务用多个线程来做也可以用继承Thread类来实现，只是比较麻烦，一般我们用实现Runnable接口来实现。

文章来源: brucelong.blog.csdn.net，作者：Bruce小鬼，版权归原作者所有，如需转载，请联系作者。

原文链接：brucelong.blog.csdn.net/article/details/79957623