Differences between Java start and run startup threads

We know that we start a thread by invoking the Start method of the thread, so can we call the Run method directly to start a thread?

Let's look at the following code:

[Java]View PlainCopy

2. Public class Test {
4. public static void Main (string[] args) {
6. //TODO auto-generated method stub
8. Testthread TT = new Testthread ();
10. Tt.run ();
12. }
14. }
18. Class Testthread extends Thread {
20. static int i = 0;
22. final static int max_i = 10;
26. @Override
28. public Void Run () {
30. //TODO auto-generated method stub
32. While (I < max_i) {
34. System.out.println (i++);
36. }
38. }
40. }

The results of the operation are as follows:

[Java]View PlainCopy

1. 0
2. 1
3. 2
4. 3
5. 4
6. 5
7. 6
8. 7
9. 8
10. 9

Perhaps someone will come to the conclusion that it is possible to start a thread so that we can modify the program a little bit, and you will find a problem:

[Java]View PlainCopy

2. Public class Test {
4. public static void Main (string[] args) {
6. //TODO auto-generated method stub
8. Testthread TT = new Testthread ();
10. Tt.run ();
12. System.out.println ("Printed by main thread");
14. }
16. }
20. Class Testthread extends Thread {
22. static int i = 0;
24. final static int max_i = 10;
28. @Override
30. public Void Run () {
32. //TODO auto-generated method stub
34. While (I < max_i) {
36. System.out.println (i++);
38. }
40. }
44. }

Here, only one line of code is added to the main thread, and a line of "printed by main thread" is printed, and the result is as follows:

[XHTML]View PlainCopy

1. 0
2. 1
3. 2
4. 3
5. 4
6. 5
7. 6
8. 7
9. 8
10. 9
11. Printed by main thread

Skilled multithreaded development to find the problem, why "printed by main thread" will be printed in the last line? Does the Testthread class hold the time period?

Our analysis of the above code, in fact very simple, this is just a common class in the method call, is actually a single-threaded execution, we have to modify the code to further verify this point:

[Java]View PlainCopy

2. Public class Test {
4. public static void Main (string[] args) {
6. //TODO auto-generated method stub
8. Testthread TT = new Testthread ();
10. Tt.run ();
12. System.out.println (Thread.CurrentThread (). GetName ());
14. System.out.println ("Printed by main thread");
16. }
18. }
22. Class Testthread extends Thread {
24. static int i = 0;
26. final static int max_i = 10;
30. @Override
32. public Void Run () {
34. //TODO auto-generated method stub
36. System.out.println (Thread.CurrentThread (). GetName ());
38. While (I < max_i) {
40. System.out.println (i++);
42. }
44. }
46. }

This code prints the current thread name, respectively, in the main thread and our Testthread method, and runs the following result:

[XHTML]View PlainCopy

1. Main
2. 0
3. 1
4. 2
5. 3
6. 4
7. 5
8. 6
9. 7
10. 8
11. 9
12. Main
13. Printed by main thread

The same thread is running in the Testthread class and the main thread, stating that it is not possible to use multithreading when calling run directly, then change the call of the above run method to the transfer of the Start method and look at:

[Java]View PlainCopy

2. Public class Test {
4. public static void Main (string[] args) {
6. //TODO auto-generated method stub
8. Testthread TT = new Testthread ();
10. Tt.start ();
12. System.out.println (Thread.CurrentThread (). GetName ());
14. System.out.println ("Printed by main thread");
16. }
18. }
22. Class Testthread extends Thread {
24. static int i = 0;
26. final static int max_i = 10;
30. @Override
32. public Void Run () {
34. //TODO auto-generated method stub
36. System.out.println (Thread.CurrentThread (). GetName ());
38. While (I < max_i) {
40. System.out.println (i++);
42. }
44. }
46. }

The results of the operation are as follows:

[XHTML]View PlainCopy

1. Main
2. Thread-0
3. 0
4. 1
5. 2
6. 3
7. 4
8. 5
9. 6
10. 7
11. 8
12. Printed by main thread
13. 9

Obviously, this is what we want to see, so the conclusion is that only the thread's Start method is called, which is controlled by the JVM to produce multi-threading, and the direct call to the Run method is just a common single-regulation regulation.

Differences between Java start and run startup threads