"Learn Python with me" python multithreading

In fact, the self-feeling Python multithreading is similar to the multithreading mechanism of Java, but more flexible than Java multithreading. In the early Python multithreading implementation, the thread module was adopted. For example:

Python code

2. From time import Ctime,sleep
4. From thread import start_new_thread
6. Def LOOP1 ():
8. print "Enter Loop1:", CTime ();
10. Sleep (3);
12. print "Leave Loop1:", CTime ();
16. Def LOOP2 ():
18. print "Enter LOOP2:", CTime ();
20. Sleep (5);
22. print "Leave loop2:", CTime ();
26. def main ():
28. print "main begin:", CTime ();
30. Start_new_thread (Loop1, ());
32. Start_new_thread (Loop2, ());
34. Sleep (8);
36. print "main end:", CTime ();
40. If __name__=="__main__":
42. Main ();

A brief introduction to the function in this block of code, sleep is the thread sleeping time, almost equivalent to Thread.Sleep in Java (millionseconds)

Start_new_thread is a method that instantiates a thread and runs, the first parameter of the method accepts a function object executed by a thread at run time, and the second parameter is the parameter that is required when the method executes and is passed in as a tuple.

This is probably the earliest Python multithreading implementation, note the code in the main Line thread sleep (8). The sleeping time here can only be larger than 3+5, but not small. If it is less than this time, the main main thread exits prematurely, causing the thread break exception to be thrown, regardless of whether its child thread is a background thread, which is similar to Java's threadinterruptexception. This deadly effect is almost the culprit behind the late abandonment of this module.

Of course, in the early Python multi-threading, you can use the lock mechanism to avoid this situation. Change the above code slightly:

Python code

2. Import thread;
4. From time import sleep,ctime;
6. From random import Choice
8. #The first param means the thread number
10. #The second param means how long it sleep
12. #The third param means the Lock
14. def loop (Nloop,sec,lock):
16. print "Thread", Nloop,"Start and would sleep", sec;
18. Sleep (sec);
20. print "Thread", Nloop,"End", sec;
22. Lock.release ();
26. def main ():
28. seconds=[4,2];
30. Locks=[];
32. For I in range (len (seconds)):
34. Lock=thread.allocate_lock ();
36. Lock.acquire ();
38. Locks.append (lock);
42. print "main Thread begins:", CTime ();
44. For I,lock in Enumerate (locks):
46. Thread.start_new_thread (Loop, (I,choice (seconds), lock));
48. For lock in locks:
50. While lock.locked ():
52. Pass;
54. print "main Thread Ends:", CTime ();
58. If __name__=="__main__":
60. Main ();

Here, the Python thread runs with a lock monitoring mechanism that introduces several methods of red font flags (in fact, the lock in the red font is the Thread.locktype instance.) )：

As you can see from the above introduction, this lock class is very similar to the java.util.concurrent.locks in JDK5.0. Lock. don't know if Doug Lea is involved in the development of this module, haha ~ ~ (purely yy), just more than the lock class in Java a method locked, to detect whether the lock object is still in the lock state.

So the previous example works by adding a lock to each thread when the thread is started, until the thread runs the description, and then releases the lock. At the same time, a while loop is used in the main thread of Python to constantly judge that each thread lock has been freed. Although this method avoids the artificial time control in the first example, it is not convenient and efficient.

Therefore, in newer versions of Python, it is recommended to use the threading module.

Looking at the API of the threading module, the Java development experience will find it very close to the Java.lang.Thread class. One thing to say here is that the threading Run method can return a function value, which is useful for tracking and judging whether a thread is running properly or not.

The threading module supports three methods of creating threads. The first two methods are related to their thread classes. Look at the brief description of it:

Python code

1. Class Thread (_verbose):
2. __init__ (self, group=None, target=None, Name=None, args= (), kwargs=None, verbose=None) /c6>

Where target refers to a specific function, or a callable class instance (in this case, a class instance that implements the __call__ method)

The first method: Specifies the function called when the thread is running. Examples are as follows:

Python code

2. From time import Ctime,sleep
4. Import threading;
6. From random import Choice
10. def loop (number,sec):
12. print "Thread", Number,"begins and would sleep", sec,"at", CTime ();
14. Sleep (sec);
16. print "Thread", Number,"ends at", CTime ();
20. def main ():
22. seconds=[2,4];
24. Threads=[];
26. Array=range (len (seconds));
28. For i in array:
30. T=threading. Thread (target=loop,args= (I,choice (seconds)));
32. Threads.append (t);
34. print "main Thread begins at", CTime ();
36. For T in Threads:
38. T.start ();
40. For T in Threads:
42. T.join ();
44. print "main Thread ends at", CTime ();
48. If __name__=="__main__":
50. Main ();

As can be seen here, target points to a specific function object, and args passes the parameters necessary for the method invocation. Here comes an immediate sleep time. Where thread.join means to wait for the thread to terminate, as in Java Thread.Join (long millionseconds), if you do not specify a specific time, you will always wait.

The second method is to specify a callable class instance that is actually very close to the previous one. As shown below:

Python code

2. From time import Ctime,sleep
4. Import threading;
6. From random import Choice
10. Class ThreadFunc (object):
12. def __init__ (self,func,args,name):
14. Self.func=func;
16. Self.args=args;
18. Self.name=name;
22. def __call__ (self):
24. Self.func (*Self.args);
28. def loop (number,sec):
30. print "Thread", Number,"begins and would sleep", sec,"at", CTime ();
32. Sleep (sec);
34. print "Thread", Number,"ends at", CTime ();
38. def main ():
40. seconds=[2,4];
42. Threads=[];
44. Array=range (len (seconds));
46. For i in array:
48. T=threading. Thread (Target=threadfunc (Loop, (I,choice (seconds)), loop.__name__));
50. Threads.append (t);
52. print "main Thread begins at", CTime ();
54. For T in Threads:
56. T.start ();
58. For T in Threads:
60. T.join ();
62. print "main Thread ends at", CTime ();
66. If __name__=="__main__":
68. Main ();

This is just pointing at Target from a function object into a callable class instance.

The third approach, with inheritance threading, is the key recommendation. Thread way to implement threading, a friend of the Java multithreaded application will be very familiar with the following example.

Python code

2. From time import Ctime,sleep
4. Import threading;
6. From random import Choice
10. Class MyThread (threading. Thread):
12. def __init__ (self,func,args,name):
14. Super (MyThread, Self). __init__ ();
16. Self.func=func;
18. Self.args=args;
20. Self.name=name;
24. def run (self):
26. self.result=Self.func (*Self.args);
30. def getresult (self):
32. return Self.result;
36. def loop (number,sec):
38. print "Thread", Number,"begins and would sleep", sec,"at", CTime ();
40. Sleep (sec);
42. print "Thread", Number,"ends at", CTime ();
46. def main ():
48. seconds=[2,4];
50. Threads=[];
52. Array=range (len (seconds));
54. For i in array:
56. T=mythread (Loop, (I,choice (seconds)), loop.__name__);
58. Threads.append (t);
60. print "main Thread begins at", CTime ();
62. For T in Threads:
64. T.start ();
66. For T in Threads:
68. T.join ();
70. print "main Thread ends at", CTime ();
74. If __name__=="__main__":
76. Main ();

It can be seen from the above that Mythread inherits the Threading.thread class and performs the necessary parameter assignment in the initialization method. It is important to note that in the case of Java class inheritance, if you do not display the constructor method that specifies calling the parent class, the default constructor method of the parent class is called. In Python, there is no initiative to invoke. So here we need to show the initialization method of calling the parent class.

Recommend a website: program life

"Learn Python with me" python multithreading