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

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

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

继承Thread类  

  1.  
    class MyThread1 extends Thread{
  2.  
    private int breakfast=10;
  3.  
    private String name;
  4.  
    public MyThread1(String name){
  5.  
    this.name=name;
  6.  
    }
  7.  
    public void run(){
  8.  
    for(int i =0;i<500;i++){
  9.  
    if(this.breakfast>0){
  10.  
    System.out.println( this.name+"卖早餐---->"+(this.breakfast--));
  11.  
    }
  12.  
    }
  13.  
    }
  14.  
    public static void main(String[] args) {
  15.  
    MyThread1 mt1= new MyThread1("一号窗口");
  16.  
    MyThread1 mt2= new MyThread1("二号窗口");
  17.  
    MyThread1 mt3= new MyThread1("三号窗口");
  18.  
    mt1.start();
  19.  
    mt2.start();
  20.  
    mt3.start();
  21.  
    }
  22.  
    }


 

 

实现Runnable接口

  1.  
    class MyThread2 implements Runnable{
  2.  
    private int breakfast =10;
  3.  
    private String name;
  4.  
    public void run(){
  5.  
    for(int i =0;i<500;i++){
  6.  
    if(this.breakfast>0){
  7.  
    System.out.println(Thread.currentThread().getName()+ "卖早餐---->"+(this.breakfast--));
  8.  
    }
  9.  
    }
  10.  
    }
  11.  
     
  12.  
    public static void main(String[] args) {
  13.  
    //设计三个线程
  14.  
    MyThread2 mt = new MyThread2();
  15.  
    Thread t1 = new Thread(mt,"一号窗口");
  16.  
    Thread t2 = new Thread(mt,"二号窗口");
  17.  
    Thread t3 = new Thread(mt,"三号窗口");
  18.  
    t1.start();
  19.  
    t2.start();
  20.  
    t3.start();
  21.  
    }
  22.  
    }

 

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

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


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

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

  1.  
    //MyThread2 mt = new MyThread2();
  2.  
    Thread t1 = new Threadnew MyThread2(),"一号窗口");
  3.  
    Thread t2 = new Threadnew MyThread2(),"二号窗口");
  4.  
    Thread t3 = new Thread(new MyThread2(),"三号窗口");

 

总结

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

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

转载。 https://blog.csdn.net/xdd19910505/article/details/50732328

猜你喜欢

转载自www.cnblogs.com/gzhbk/p/9292727.html