[Learn Python with me] multiple threads in Python and multiple threads in python

[Learn Python with me] multiple threads in Python and multiple threads in python

In fact, I feel that Python multithreading is similar to Java's multithreading mechanism, but it is more flexible than JAVA's multithreading. In the early implementation of Python multithreading, the thread module was used. For example:

Python code

1. From time import ctime, sleep
2. From thread import start_new_thread
3. Def loop1 ():
4. Print "enter loop1:", ctime ();
5. Sleep (3 );
6. Print "leave loop1:", ctime ();
8. Def loop2 ():
9. Print "enter loop2:", ctime ();
10. Sleep (5 );
11. Print "leave loop2:", ctime ();
13. Def main ():
14. Print "main begin:", ctime ();
15. Start_new_thread (loop1 ,());
16. Start_new_thread (loop2 ,());
17. Sleep (8 );
18. Print "main end:", ctime ();
20. If _ name __= = "_ main __":
21. Main ();

 

 

 

A Brief Introduction to the function functions in this code block. sleep is the Thread sleep time, which is almost equivalent to Thread. sleep (millionseconds) in JAVA)

Start_new_thread is the method for instantiating a thread and running it. The first parameter of the method accepts the function object executed during the running of the thread, and the second parameter is the parameter required for the method execution, input in the form of a tuples.

This is probably the earliest multi-threaded Python implementation. Pay attention to sleep (8) in the main thread in the code ). The sleep time here is only 3 + 5, not small. If it is less than this time, the main thread will exit early, resulting in thread interruption exceptions, similar to ThreadInterruptException in Java, regardless of whether its sub-thread is a background thread. This fatal impact is almost the culprit of this module being abandoned later.

Of course, in the early versions of Python multithreading, you can use the locking mechanism to avoid this situation. Slightly modify the above Code:

Python code

1. Import thread;
2. From time import sleep, ctime;
3. From random import choice
4. # The first param means the thread number
5. # The second param means how long it sleep
6. # The third param means the Lock
7. Def loop (nloop, sec, lock ):
8. Print "Thread", nloop, "start and will sleep", sec;
9. Sleep (sec );
10. Print "Thread", nloop, "end", sec;
11. Lock. release ();
13. Def main ():
14. Seconds = [4, 2];
15. Locks = [];
16. For I in range (len (seconds )):
17. Lock = thread. allocate_lock ();
18. Lock. acquire ();
19. Locks. append (lock );
21. Print "main Thread begins:", ctime ();
22. For I, lock in enumerate (locks ):
23. Thread. start_new_thread (loop, (I, choice (seconds), lock ));
24. For lock in locks:
25. While lock. locked ():
26. Pass;
27. Print "main Thread ends:", ctime ();
29. If _ name __= = "_ main __":
30. Main ();

 

 

 

The lock monitoring mechanism is added to the Python thread runtime to introduce several methods of red font mark (in fact, the lock in red font is actually a thread. lockType instance. ):

From the above introduction, we can see that this Lock class is very similar to java. util. concurrent. locks.Lock.I wonder if Doug Lea is involved in the development of this module. Haha ~~ (Purely YY), but there is only one more locked method than the LOCK class in JAVA, which is used to detect whether the Lock Object is still locked.

Therefore, the working principle of the previous example is to add a lock to each thread when starting the thread until the thread is introduced and then released. At the same time, A while LOOP is used in the main thread of Python to continuously judge that each thread lock has been released. Although this method avoids human time control in the first example, it is not convenient and efficient.

Therefore, the threading module is recommended in newer Python versions.

Check the threading module API. If you have JAVA development experience, you will find that it is very similar to the java. lang. Thread class. One thing to mention here is that the threading run method can return the function value, which is very useful in tracking and determining whether the thread is running normally.

The threading module supports three methods to create threads. The first two methods are related to the Thread class. Let's take a look at its brief description:

 

Python code

1. Class Thread (_ Verbose ):
2. _ Init _ (self, group = None, target = None, name = None, args = (), kwargs = None, verbose = None)

 

 

 

 

 

Specifically, target refers to a specific function or a callable class instance (here it refers to a class instance that implements the _ call _ method)

Method 1: Specify the function called when the thread is running. Example:

 

 

Python code

1. From time import ctime, sleep
2. Import threading;
3. From random import choice
5. Def loop (number, sec ):
6. Print "Thread", number, "begins and will sleep", sec, "at", ctime ();
7. Sleep (sec );
8. Print "Thread", number, "ends at", ctime ();
10. Def main ():
11. Seconds = [2, 4];
12. Threads = [];
13. Array = range (len (seconds ));
14. For I in array:
15. T = threading. Thread (target = loop, args = (I, choice (seconds )));
16. Threads. append (t );
17. Print "main Thread begins at", ctime ();
18. For t in threads:
19. T. start ();
20. For t in threads:
21. T. join ();
22. Print "main Thread ends at", ctime ();
24. If _ name __= = "_ main __":
25. Main ();

 

 

 

As shown in the figure, target points to a specific function object, and args passes in the required parameters for this method call. A sleep time is introduced here. Thread. join indicates that the Thread is waiting for termination, which is the same as thread. join (long millionseconds) in java. If no specific time is specified, the Thread will remain waiting.

 

 

The second method is to specify an callable class instance, which is actually very close to the previous one. As follows:

Python code

1. From time import ctime, sleep
2. Import threading;
3. From random import choice
5. Class ThreadFunc (object ):
6. Def _ init _ (self, func, args, name ):
7. Self. func = func;
8. Self. args = args;
9. Self. name = name;
11. Def _ call _ (self ):
12. Self. func (* self. args );
14. Def loop (number, sec ):
15. Print "Thread", number, "begins and will sleep", sec, "at", ctime ();
16. Sleep (sec );
17. Print "Thread", number, "ends at", ctime ();
19. Def main ():
20. Seconds = [2, 4];
21. Threads = [];
22. Array = range (len (seconds ));
23. For I in array:
24. T = threading. Thread (target = ThreadFunc (loop, (I, choice (seconds), loop. _ name __));
25. Threads. append (t );
26. Print "main Thread begins at", ctime ();
27. For t in threads:
28. T. start ();
29. For t in threads:
30. T. join ();
31. Print "main Thread ends at", ctime ();
33. If _ name __= = "_ main __":
34. Main ();

 

 

 

Here, the target is directed from a function object to a callable class instance.

 

We recommend the third method to implement the Thread by inheriting threading. Thread. If you have a Java multi-threaded application, you will be familiar with the following example.

Python code

1. From time import ctime, sleep
2. Import threading;
3. From random import choice
5. Class MyThread (threading. Thread ):
6. Def _ init _ (self, func, args, name ):
7. Super (MyThread, self). _ init __();
8. Self. func = func;
9. Self. args = args;
10. Self. name = name;
12. Def run (self ):
13. Self. result = self. func (* self. args );
15. Def getResult (self ):
16. Return self. result;
18. Def loop (number, sec ):
19. Print "Thread", number, "begins and will sleep", sec, "at", ctime ();
20. Sleep (sec );
21. Print "Thread", number, "ends at", ctime ();
23. Def main ():
24. Seconds = [2, 4];
25. Threads = [];
26. Array = range (len (seconds ));
27. For I in array:
28. T = MyThread (loop, (I, choice (seconds), loop. _ name __);
29. Threads. append (t );
30. Print "main Thread begins at", ctime ();
31. For t in threads:
32. T. start ();
33. For t in threads:
34. T. join ();
35. Print "main Thread ends at", ctime ();
37. If _ name __= = "_ main __":
38. Main ();

From the above, we can see that MyThread inherits the threading. Thread class and executes necessary parameter values in the initialization method. It is worth noting that, in the inheritance of Java classes, if you do not specify to call the constructor of the parent class, the non-argument constructor of the parent class will be called by default. In Python, it does not take the initiative to call. Therefore, the initialization method of the parent class needs to be displayed here.

Recommend a Website: program life

Multithreading in Python

Python GIL requires that only one thread can access the python virtual machine at a time. Therefore, it is not worthwhile to use multiple threads of python for computing. However, for IO-intensive applications, such as network interaction, the multithreading of python is still very powerful.
If you are a computing-intensive task and must use python for parallel execution, you can use the following methods:
1. Use the python multiprocessing module to take advantage of multiple cores.
2. ironPython is used, but this can only be used in windows.
3. Use pypy to implement real multithreading.

Python Multithreading

That's of course. You can write it like this.
Self. p [:] = array

In this way, the pointer remains unchanged. Change content only. In this way, you can synchronize data.

Your writing method is to create an array and then use the pointer and ribbon self. p. If other threads have problems.

In addition, put your p before _ init. It is more reasonable to use T. p for reference.