Thread in Javascript

Today, I am arguing with a colleague about the thread mechanism in the middle of javascripe. He argues that JavaScript has a thread, even if the Event Callback In The Middle Of Javascript is the implementation of the thread, I personally think there is no thread mechanism in javascript:

The reasons are as follows:

Introduced by <proficient in Javascript> JOHN resig:

1. <SCRIPT>
2. <! --
3. While (! Window. Loaded );
4. // Some operation
5. Window. Alert ();
6. -->
7. </SCRIPT>

The purpose of this Code is to block the current JS thread. After the page is fully loaded, execute the following operations, that is, "synchronization", but the effect is that the browser is suspended or dead. It can be seen that in JS, the wait cannot be paused by loop; it can be seen that the callback must be used in early JavaScript to achieve this effect, namely:

1. Wndow. onload = funcrion (){
3. // Some operation
5. }

However, callback is not the basis for supporting multithreading in JS language. We know that callback message mechanism is supported in windows; when we click a button, the system will call the event processing function, in the middle of windows, I want to bind a processing function to the start of the click event to maintain an event processing table, A click event in a space in the table corresponds to a function pointer for processing functions. When an event is clicked, the function pointer pointing to is called;

 

What is thread? I think we should start with a multi-threaded operating system. multithreading means that multiple processing processes are executed in turn, and this alternate time slice is very short, as short as we humans cannot perceive, this is why a single processor can also execute threads concurrently, and the callback we see above is actually like a method call, after the processor function is called, return to the original program segment for further execution. I think this is similar to the interrupt processing in the operating system.

Concept: We know that interrupt processing is supported by hardware. In a single processor system, multithreading is implemented by the operating system. Under my multi-threaded operating system, the operating system maintains multiple state thread queues and determines the Rotation Algorithm Used to switch between threads; he uses the rewrite time interrupt processor to call the process (thread) manager at the interval of a time slice to adjust the conversion and execution between the thread and the process. This shows that, the callback function similar to the interrupt processing function does not prove the existence of the thread (because the relationship between the two can be clearly seen from the above );

The following example can also clearly prove the so-called "Thread" of JS ":

1. <Script language = "JavaScript">
2. <! --
3. FunctionMain (){
4. For(VaRIndex = 0; index <10; index ++ ){
5. Alert ("main thread ");
6. SetTimeout (secondary, 20 );
7. }
8. }
10. FunctionSecondary (){
11. Alert ("secondary ");
12. }
14. Main ();
15. -->
16. </SCRIPT>

Because there is no process concept, it should have been executed alternately by the main and secondary here, and it has become the greedy scheduling after executing the main and then executing the secondary; then, in this understanding, there is no thread concept in Javascript. How can we implement the thread mechanism on our own? It is like how we implement the thread concept in the interrupt processing mechanism; since the system (JS engine) does not maintain the thread list and Scheduling for us, we can implement the scheduling algorithm and)

 

1. <Script language = "JavaScript">
2. <! --
3. VaRThread_one_time = 0;
4. VaRThread_two_time = 0;
5. FunctionThread_one (){
6. Thread_one_time ++;
7. Alert (thread_one_time );
8. }
11. FunctionThread_two (){
12. Thread_two_time ++;
13. Alert (thread_two_time );
14. }
15. }
18. Setinterval (FIG, 100 );
19. Setinterval (FIG, 100 );
20. -->
21. </SCRIPT>

Here, we can see that two subprograms are executed alternately. In fact, if we look at them from the thread's perspective, there are three threads here, one is thread_one, the other is thread_two, and the other is main_thread (but the execution has been completed). Don't believe it. You can simply add and modify it as follows:

1. <Script language = "JavaScript">
2. <! --
3. VaR thread_one_time = 0;
4. VaR thread_two_time = 0;
5. Function thread_one (){
6. Thread_one_time ++;
7. Alert (thread_one_time );
8. }
11. Function thread_two (){
12. Thread_two_time ++;
13. Alert (thread_two_time );
14. }
17. Setinterval (FIG, 100 );
18. Setinterval (FIG, 100 );
20. For (VAR I = 0; I <10; I ++ ){
21. Alert (I + "Main ");
22. }
23. -->
24. </SCRIPT>

 

The main program here can be regarded as a greedy main thread, which is equivalent to the Process Manager in the middle of the Operating System (implemented by the time interrupt processor). It schedules and switches to manage the thread queue of the entire system, the "scheduling algorithm" used here is very simple, that is, 100 seconds of time slice rotation, no priority, no interruption, No ........,

= JS process implementation code:

Thread. JS:

1. /**
2. * Thread management class
3. * @ Author zxub 2006-06-12
4. */
5. Function thread (_ task, _ delay, _ times)
6. {
7. This. runflag = false;
8. This. busyflag = false;
9. This. taskargs = array. Prototype. Slice. Call (arguments, 3 );
11. If (_ times! = Undefined)
12. {
13. This. Times = _ times;
14. }
15. Else
16. {
17. This. Times = 1;
18. }
20. VaR _ point = this;
22. This. timerid =-1;
24. This. Start = function ()
25. {
26. If (this. runflag = false)
27. {
28. This. timerid = Window. setinterval (_ point. Run, _ delay );
29. This. runflag = true;
30. }
31. }
33. This. Run = function ()
34. {
35. If (_ point. busyflag) return;
36. If (_ point. Times =-1) // Infinite Loop
37. {
38. _ Task (_ point. taskargs );
39. }
40. Else if (_ point. Times> 0)
41. {
42. _ Task (_ point. taskargs );
43. _ Point. Times-= 1;
44. If (_ point. Times = 0)
45. {
46. Window. clearinterval (this. timerid );
47. }
48. }
49. }
51. This. Sleep = function ()
52. {
53. This. busyflag = true;
54. }
56. This. Resume = function ()
57. {
58. This. busyflag = false;
59. }
61. This. Abort = function ()
62. {
63. Window. clearinterval (this. timerid );
64. }
65. }

Thread.html:

1. <HTML>
2. <Head>
3. <Title> test </title>
4. <Meta http-equiv = "Content-Type" content = "text/html; charset = UTF-8"/>
5. <SCRIPT type = "text/JavaScript" src = "thread. js"> </SCRIPT>
6. <Style type = "text/CSS">
7. <! --
8. Body, TR, TD {font-size: 12px ;}
9. -->
10. </Style>
11. </Head>
12. <Body>
13. <SCRIPT>
14. VaR func = function (_ o)
15. {
16. Document. getelementbyid (_ o). innerhtml = parseint (document. getelementbyid (_ o). innerhtml) + 1;
17. }
18. VaR T1 = new thread (func, 50,121, "T1 ");
19. VaR t2 = new thread (func, 200,20, "T2 ");
20. </SCRIPT>
21. <Input type = "button" value = "start1" onclick = 'T1. Start (); '> </input>
22. <Input type = "button" value = "sleep1" onclick = 'T1. Sleep (); '> </input>
23. <Input type = "button" value = "resume1" onclick = 'T1. Resume (); '> </input>
24. <Input type = "button" value = "abort1" onclick = 'T1. Abort (); '> </input>
25. <Input type = "button" value = "start2" onclick = 't2. Start (); '> </input>
26. <Input type = "button" value = "sleep2" onclick = 't2. Sleep (); '> </input>
27. <Input type = "button" value = "resume2" onclick = 't2. Resume (); '> </input>
28. <Input type = "button" value = "abort2" onclick = 't2. Abort (); '> </input>
29. <Div id = "T1"> 0 </div> | <Div id = "T2"> 0 </div>
30. <Input type = "button" value = "t1.timerid" onclick = 'alert (t1.timerid); '> </input>
31. <Input type = "button" value = "t2.timerid" onclick = 'alert (t2.timerid); '> </input>
32. </Body>
33. </Html>

The first thread I came into contact with was the Operating System. Due to the special nature of JS, some people say that the language of toys is not rigorous, while others say it is flexible and mixed, therefore, I have explained some of my views on JS threads in conjunction with the operating system. I am not sure that I am right, or that I am not sure what I mean, many times, the language cannot express your own understanding. If you have a deep understanding of it, you will have to work harder to express it to others. I have always been confused about Js, closure, object-oriented initialization, there are many places worth exploring, hope to learn from you; (refer to the source for conversion, csdn Corey)