多线程——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接口的时候调用Thread的Thread(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接口的区别了，这能够看作是接口和继承的问题。咱们弄懂了接口和继承，就不难理解Thread和Runnable。

              在刚接触的时候可能会有些迷糊这两者的区别于联系，可是实践和总结事后咱们会发现这是两个彻底不一样的实现多线程，一个是多个线程分别完成本身的任务，一个是多个线程共同完成一个任务。其实，在实现一个任务用多个线程来作也能够用继承Thread类来实现，只是比较麻烦，通常咱们用实现Runnable接口来实现。

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