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

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--);
;
}
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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--);
;
}
}

}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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();

}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

结论：从程序运行结果可发现，继承Thread实际上是3个线程分别卖了5张票 

而实现Runnable3个线程共同卖了5张票

总结：实现Runnable接口比继承Thread的优势有： 

①适合多个相同的程序代码的线程去处理统一资源的情况 

②可以避免由于java单继承特征带来的局限性 

③增强开发程序的健壮性，代码可以多个线程共享，代码和数据是独立的

所以开发首选实现Runnable接口方式来实现多线程操作！
补充：

/* 

    需求： 实现一个售票程序 

     

    创建线程的第二种方式：实现Runnable接口 

 

    步骤： 

    1，定义类实现Runnable接口 

    2，覆盖Runnable接口中的run方法 

        将线程要运行的代码存放在该run方法中 

 

    3，通过Thread 类建立线程对象 

    4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数 

        为什么要将Runnable接口中的子类对象传递给Thread的构造函数 

        因为，自定义的run方法所属的对象是Runnable接口的子类对象 

        所以要让线程去指定指定对象的run方法，就必须明确该run方法所属对象。 

 

    5，调用Thread类的start方法 开启线程并调用Runnable接口子类的run方法 

 

 

 

实现方式和继承方式的区别： 

 

实现方式好处：避免了单继承的局限性 

在定义建议使用实现方式 

 

两种方式区别： 

继承Thread：线程代码存放在Thread子类run方法中。 

实现Runnable：线程代码存放在接口的子类的run方法中、 

*/  

  

class Tick implements Runnable  

{  

    private int tick = 50;  

  

    public void run()  

    {  

        while(true)  

        {  

            if(tick > 0)  

                System.out.println( Thread.currentThread().getName() + " sail --" + tick--);  

        }  

    }  

}  

  

class TickDemo  

{  

    public static void main(String []args)  

    {  

        Tick t = new Tick();  

  

        Thread t1 = new Thread(t);  

        Thread t2 = new Thread(t);  

        Thread t3 = new Thread(t);  

        Thread t4 = new Thread(t);  

  

        t1.start();  

        t2.start();  

        t3.start();  

        t4.start();  

  

    }  

}