java 实现runnable接口与继承Thread类相比的优势

  1. 1.继承Thread

    package com.test.thread;
    
    public class TicketThread1 extends Thread {
        private int ticket = 5;
    
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                if (ticket > 0) {
                    System.out.println("Thread剩余==" + ticket--);
                    ;
                }
            }
        }
    }
    

    2.实现Runnable

    package com.test.thread;
    
    public class TicketThread2 implements Runnable {
        private int ticket = 5;
    
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                if (ticket > 0) {
                    System.out.println("Runnable剩余==" + ticket--);
                    ;
                }
            }
    
        }
    }

    3.测试Test

    package com.test.thread;
    
    public class TicketTest {
        public static void main(String[] args) {
            TicketThread1 ticket1 = new TicketThread1();
            TicketThread1 ticket2 = new TicketThread1();
            TicketThread1 ticket3 = new TicketThread1();
            ticket1.start();
            ticket2.start();
            ticket3.start();
    
            TicketThread2 ticketRunnable = new TicketThread2();
            new Thread(ticketRunnable).start();
            new Thread(ticketRunnable).start();
            new Thread(ticketRunnable).start();
    
        }
    }
    

    4.输出结果:

    Thread剩余==5
    Thread剩余==5
    Thread剩余==5
    Thread剩余==4
    Thread剩余==4
    Thread剩余==3
    Thread剩余==4
    Thread剩余==2
    Thread剩余==3
    Thread剩余==1
    Thread剩余==3
    Thread剩余==2
    Thread剩余==1
    Thread剩余==2
    Runnable剩余==5
    Thread剩余==1
    Runnable剩余==4
    Runnable剩余==1
    Runnable剩余==3
    Runnable剩余==2
    

    结论:从程序运行结果可发现,继承Thread实际上是3个线程分别卖了5张票 
    而实现Runnable3个线程共同卖了5张票

    总结:实现Runnable接口比继承Thread的优势有: 
    ①适合多个相同的程序代码的线程去处理统一资源的情况 
    ②可以避免由于java单继承特征带来的局限性 
    ③增强开发程序的健壮性,代码可以多个线程共享,代码和数据是独立的

    所以开发首选实现Runnable接口方式来实现多线程操作!

    补充:
  2. /* 
  3.     需求: 实现一个售票程序 
  4.      
  5.     创建线程的第二种方式:实现Runnable接口 
  6.  
  7.     步骤: 
  8.     1,定义类实现Runnable接口 
  9.     2,覆盖Runnable接口中的run方法 
  10.         将线程要运行的代码存放在该run方法中 
  11.  
  12.     3,通过Thread 类建立线程对象 
  13.     4,将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数 
  14.         为什么要将Runnable接口中的子类对象传递给Thread的构造函数 
  15.         因为,自定义的run方法所属的对象是Runnable接口的子类对象 
  16.         所以要让线程去指定指定对象的run方法,就必须明确该run方法所属对象。 
  17.  
  18.     5,调用Thread类的start方法 开启线程并调用Runnable接口子类的run方法 
  19.  
  20.  
  21.  
  22. 实现方式和继承方式的区别: 
  23.  
  24. 实现方式好处:避免了单继承的局限性 
  25. 在定义建议使用实现方式 
  26.  
  27. 两种方式区别: 
  28. 继承Thread:线程代码存放在Thread子类run方法中。 
  29. 实现Runnable:线程代码存放在接口的子类的run方法中、 
  30. */  
  31.   
  32. class Tick implements Runnable  
  33. {  
  34.     private int tick = 50;  
  35.   
  36.     public void run()  
  37.     {  
  38.         while(true)  
  39.         {  
  40.             if(tick > 0)  
  41.                 System.out.println( Thread.currentThread().getName() + " sail --" + tick--);  
  42.         }  
  43.     }  
  44. }  
  45.   
  46. class TickDemo  
  47. {  
  48.     public static void main(String []args)  
  49.     {  
  50.         Tick t = new Tick();  
  51.   
  52.         Thread t1 = new Thread(t);  
  53.         Thread t2 = new Thread(t);  
  54.         Thread t3 = new Thread(t);  
  55.         Thread t4 = new Thread(t);  
  56.   
  57.         t1.start();  
  58.         t2.start();  
  59.         t3.start();  
  60.         t4.start();  
  61.   
  62.     }  
  63. }  


你可能感兴趣的:(java)