Java multithreaded--thread class and Runable interface

In Java, there are two ways to implement multi-threading, one is to inherit the thread class, and the other is to implement the Runnable interface;
The thread class is defined in the Java.lang package. As long as a class inherits the thread class, it also overwrite the
The run () method enables multithreaded operations, but a class can inherit only one parent class, which is the limit of this method.

Let's look at the example below:

[Java] view plaincopy

2. Package Org.thread.demo;

4. class MyThread extends thread{

6. Private String name;

8. Public MyThread (String name) {

10. Super ();

12. this. Name = name;

14. }

16. Public void Run () {

18. for (int i=0;i<; i++) {

20. System.out.println ("thread start:"+this. name+", i="+i);

22. }

24. }

26. }

28. Package Org.thread.demo;

30. Public class ThreadDemo01 {

32. Public Static void Main (string[] args) {

34. MyThread mt1=New MyThread ("Thread A");

36. MyThread mt2=New MyThread ("thread B");

38. Mt1.run ();

40. Mt2.run ();

42. }

44. }

However, the result is very regular, the first object executes, and then the second object executes, and it does not run against one another. As you can see in the JDK documentation, once the start () method is called, the Run () method is found through the JVM. Starting the Start () method starts the thread:

[Java] view plaincopy

1. Package Org.thread.demo;

2. Public class ThreadDemo01 {

3. Public Static void Main (string[] args) {

4. MyThread mt1=New MyThread ("Thread A");

5. MyThread mt2=New MyThread ("thread B");

6. Mt1.start ();

7. Mt2.start ();

8. }

This allows the program to complete the interactive operation normally. So why not use Start ();
Under the JDK installation path, Src.zip is the entire Java source program, and this code finds the definition of the start () method in thread, and you can see that the private native void Start0 () is used in this method; Where the Native keyword means that the underlying function of the operating system can be called, then such a technique is called JNI technology (Java Native Interface)

· Runnable interface
In real-world development, a multithreaded operation rarely uses the thread class, but is accomplished through the Runnable interface.

[Java] view plaincopy

1. package  org.runnable.demo;  

2. class   MYTHREAD&NBSP implements  runnable{  

3. private   string name;  

4. public  mythread (string name)  {   

5. this . name = name;  

6. }  

7. public  , void  run () {  

8. for ( int  i= 0 ; i< + ; i++) {  

9. System.out.println ( thread Start: + this . name+ ", i=" +i);   

10. }  

11. }  

12. }  

However, there is no start () method in a subclass defined with runnable, only in the thread class. There is a constructor method for observing the thread class at this point: public Thread (Runnable Targer)
This construction method takes a subclass instance of runnable, which means that the thread class can be used to start multithreading for runnable implementations. (Start () to coordinate the resources of the system):

[Java] view plaincopy

1. package  org.runnable.demo;  

2. import   org.runnable.demo.mythread;  

3. public   class   threaddemo01 {  

4. public   static   void  main (String[] args)  {  

5. mythread mt1= New  mythread ( "Thread A" );   

6. mythread mt2= new   MyThread ( "thread B" );   

7. new  thread (MT1). Start ();   

8. new  thread (MT2). Start ();   

9. }  

10. }  

The difference between the two ways of implementation and contact:
In the program development, as long as the multithreading is always to achieve runnable interface-based, because the implementation of runnable interface compared to
Inheriting the thread class has the following benefits:
To avoid the limitations of point inheritance, a class can inherit multiple interfaces.
--Suitable for resource sharing

Take the ticket selling procedure as an example, complete by the thread class:

[Java] view plaincopy

2. //Use thread to implement threads that cannot implement resource sharing

4. class MyThread extends Thread

6. {

8. Private int ticket=ten;

10. Private String name;

12. Public MyThread (String name) {

14. this. name=name;

16. }

18. Public void Run () {

20. for (int i=0;i<; i++) {

22. if (ticket>0) {

24. System.out.println ("thread"+name+"Sell ticket"+ (ticket--));

26. }

28. }

32. }

34. }

38. Public class Threadticket

40. {

42. Public Static void Main (String args[]) {

44. MyThread a = new MyThread ("a");

46. MyThread B = new MyThread ("B");

48. A.start ();

50. B.start ();

52. }

54. }

58. //Use runnable to implement threads for resource sharing

60. class MyThread implements Runnable

62. {

64. Private int ticket=ten;

66. Private String name;

68. Public MyThread (String name) {

70. this. name=name;

72. }

74. Public void Run () {

76. for (int i=1; i<=; i++) {

78. if (ticket>0) {

80. System.out.println ("thread"+name+"Sell ticket"+ (ticket--));

82. }

84. }

86. }

88. }

90. Public class Threadticket

92. {

94. Public Static void Main (String args[]) {

96. MyThread a = new MyThread ("a"); //Instantiate a thread to perform the task

98. Thread Ta = new thread (A); //Instance two thread object, actually passing a task

100. Thread Tb = new thread (A); //Because two threads are performing a task, resources are shared

102. Ta.start ();

104. Tb.start ();

106. }

108. }

Although the program now has two threads, but sold a total of 10 tickets, that is, the use of runnable implementation of multi-threading can achieve the purpose of resource sharing.

runnable The connection between the interface and the thread: Public class Thread extends Object implements Runnable
It is easy to see that the thread class is a subclass of the Runnable interface.

Java multithreaded--thread class and Runable interface