The difference between inheriting the thread class and implementing the Runnable interface in Java

There are two ways to create thread threads in Java:

1. By inheriting the thread class, overriding the thread's run () method, placing the logic in which the threads run

2. Instantiate the thread class by implementing the Runnable interface

In the practical application, we often use multi-threading, such as the station ticketing system, the station's various ticket outlets equal to each thread. When we do this system may think of two ways to achieve, inherit the thread class or implement the Runnable interface, now look at the two ways to achieve the results.

Java code

2. Package com.threadtest;
4. Class MyThread extends thread{
8. private int ticket = 10;
10. private String name;
12. Public MyThread (String name) {
14. THIS.name =name;
16. }
20. public void Run () {
22. for (int i =0;i<500;i++) {
24. if (this.ticket>0) {
26. SYSTEM.OUT.PRINTLN (this.name+ "sell ticket---->" + (this.ticket--));
28. }
30. }
32. }
34. }
36. public class Threaddemo {
42. public static void Main (string[] args) {
44. MyThread mt1= New MyThread ("one Window");
46. MyThread mt2= New MyThread ("Window No. second");
48. MyThread mt3= New MyThread ("Window No. third");
50. Mt1.start ();
52. Mt2.start ();
54. Mt3.start ();
56. }
60. }

The results of the operation are as follows:

Java code

2. A window sells tickets---->10
4. A window sells tickets---->9
6. Window second sell ticket---->10
8. A window sells tickets---->8
10. A window sells tickets---->7
12. A window sells tickets---->6
14. Window third sell ticket---->10
16. A window sells tickets---->5
18. A window sells tickets---->4
20. A window sells tickets---->3
22. A window sells tickets---->2
24. A window sells tickets---->1
26. Window second sell ticket---->9
28. Window second sell ticket---->8
30. Window third sell ticket---->9
32. Window third sell ticket---->8
34. Window third sell ticket---->7
36. Window third sell ticket---->6
38. Window third sell ticket---->5
40. Window third sell ticket---->4
42. Window third sell ticket---->3
44. Window third sell ticket---->2
46. Window third sell ticket---->1
48. Window second sell ticket---->7
50. Window second sell ticket---->6
52. Window second sell ticket---->5
54. Window second sell ticket---->4
56. Window second sell ticket---->3
58. Window second sell ticket---->2
60. Window second sell ticket---->1

The code for implementing the Runnable interface is as follows:

Java code

2. Package com.threadtest;
4. Class MyThread1 implements runnable{
6. private int ticket = 10;
8. private String name;
10. public void Run () {
12. for (int i =0;i<500;i++) {
14. if (this.ticket>0) {
16. System.out.println (Thread.CurrentThread (). GetName () + "sell ticket---->" + (this.ticket--));
18. }
20. }
22. }
24. }
26. public class Runnabledemo {
32. public static void Main (string[] args) {
34. TODO auto-generated Method Stub
36. Design of three threads
38. MyThread1 MT = new MyThread1 ();
40. thread T1 = new Thread (MT, "one Window");
42. Thread t2 = new Thread (MT, "window number second");
44. thread t3 = new Thread (MT, "window number third");
46. MyThread1 mt2 = new MyThread1 ();
48. MyThread1 mt3 = new MyThread1 ();
50. T1.start ();
52. T2.start ();
54. T3.start ();
56. }
60. }

The results of the operation are as follows:

Java code

1. A window sells tickets---->10
2. Window third sell ticket---->9
3. Window third sell ticket---->7
4. Window third sell ticket---->5
5. Window third sell ticket---->4
6. Window third sell ticket---->3
7. Window third sell ticket---->2
8. Window third sell ticket---->1
9. A window sells tickets---->8
10. Window second sell ticket---->6

Why this kind of result is present. We might as well make a metaphor, actually just the procedure,

Inherit the thread class, we are equivalent to take out three things namely three tickets to sell 10 of the task divided to three windows, they each do the various things sold each of the tickets to complete each task, because Mythread inherits the thread class, so in new Mythread creates three threads while creating three objects;

Achieve runnable, equivalent to take out a ticket to sell 10 of the task to three people to work together, new mythread equivalent to create a task, and then instantiate three thread, create three threads to arrange three windows to execute.

The diagram shows the following:

We may be confused when we touch. Inherit the thread class and implement the Runnable interface to implement multi-threading, in fact, after contact we will find that this is completely two different implementations of multi-threading, one is multiple threads to complete their own tasks, one is multiple threads together to complete a task.

In fact, in the implementation of a task with multiple threads to do can also be used to inherit the thread class to achieve is just more trouble, generally we use the implementation of runnable interface to achieve, concise and clear.

In most cases, you should use the Runnable interface if you only want to override the run () method without overriding the other Thread methods. This is important because a subclass should not be created for the class (Thread) unless the programmer intends to modify or enhance the basic behavior of the class.

The difference between inheriting the thread class and implementing the Runnable interface in Java