Shulou(Shulou.com)06/02 Report--

This article mainly introduces "Python multithreading, that is, related concept analysis". In daily operation, I believe many people have doubts about Python multithreading, that is, related concept analysis. The editor consulted all kinds of data and sorted out simple and easy-to-use operation methods. I hope it will be helpful for you to answer the doubts of "Python multithreading is related concept analysis". Next, please follow the editor to study!

What is a thread?

Thread, as its name implies, is a process of assembly line work, an assembly line must belong to a workshop, the work process of a workshop is a process. The workshop is responsible for integrating resources together, which is a resource unit, and there is at least one assembly line in a workshop. Therefore, the process is only used to bring resources together (the process is just a resource unit, or resource collection), and the thread is the execution unit on the cpu.

Summarize the differences between processes and threads:

'' process: resource unit thread: the executing unit thread is the real worker. The resources needed in the work are provided by the process in which the thread resides. Each process must have its own thread and multiple threads can be created within each process. Open process: apply for space copy code to consume resources. Open threads: create multiple threads in the same process without the need for the above two operations Consumption of resources is relatively small.

The concept of multithreading (that is, multiple control threads) is that there are multiple control threads in a process, and multiple control threads share the address space of the process, which is equivalent to multiple pipelines in a workshop, all sharing the resources of a workshop.

2. Two ways to start a thread 1. 1from threading import Threadimport time# method 1: def task (name): print (% s is running'% name) time.sleep (1) print (% s is over'% name) # you don't need to execute code under main to start a thread You can write directly # but habitually write the startup command under main t = Thread (target=task, args= ('egon',)) t.start () # the overhead of creating a thread is very small, almost as soon as the code is executed, the print (' master')''has been created.

Running result:

Egon is running

Master

Egon is over

''

2. 2from threading import Threadclass MyThread (Thread): def _ _ init__ (self, name): # rewrites other people's methods, but doesn't know what's in them. Call the parent method super (). _ init__ () self.name = name def run (self): print ('% s is running'% self.name) time.sleep (1) print ('% s is over'% self.name) if _ _ name__ = ='_ main__': t = MyThread ('egon') t.start () print (' main')'

Running result:

Egon is running

Master

Egon is over

''

Third, the jion method of thread object ()

Friends who have read my article on processes must know the function of jion. The jion method of a thread is similar to the jion method of a process-wait for one thread to finish execution before executing the next thread.

From threading import Threaddef task (name): print ('% s is running'% name) time.sleep (1) print ('% s is over'% name) if _ _ name__ = ='_ main__': t=Thread (target=task,args= ('egon',)) t.start () t.join () # wait for the child thread to finish running before executing print (' main')

'''

Running result:

Egon is running

Egon is over

Master

''

Add a point of knowledge: data sharing among multiple threads in the same process. Here is a simple example.

From threading import Threadmoney=100def task (): global money money=66if _ _ name__ = ='_ main__': t=Thread (target=task,args= ()) t.start () print (money)

# results: 66

4. Supplementary small case from threading import Threadimport os,timedef task (): print ('sub-pid:',os.getpid ()) if _ _ name__ = =' _ main__': t=Thread (target=task,args= ()) t.start () print ('main pid:',os.getpid ()) # the pid number of two threads is the same, indicating that under the same process

''

Running result:

Child pid: 13444

Main pid: 13444

''

# this is an easily confused case from threading import Thread,current_thread,active_countimport os,timedef task (n): print ('son', current_thread (). Name) time.sleep (n) # extend thread survival time if _ _ name__ = ='_ main__': t=Thread (target=task,args= (1,)) t1=Thread (target=task,args= (1) ) t.start () t1.start () t.join () # print ('main', current_thread () .name) # get thread name print (active_count ()) # count the number of currently active processes

''

Running result:

Child Thread-1

Child Thread-2

one

''

# it's easy to think that it's 3, but in fact, only one thread is active after running, and the other two threads stop running after they finish running.

Fifth, daemon thread

The concept of daemon thread is similar to that of daemon process. In fact, we can also notice that there are many knowledge points between process and thread, that is, the usage is similar, and we understand that one is similar to the other.

1. The daemon thread ends with the end of the main thread

2. The main thread will not end immediately after running, but will wait for all other non-daemon threads to finish.

3. Because the end of the main thread means the end of the process

From threading import Threadimport timedef task (name): print ('% s is running'%name) time.sleep (1) print ('% s is over'%name) if _ _ name__ = ='_ main__': t=Thread (target=task,args= ('egon',)) t.daemon=True # set t to the daemon thread t.start () print (' master')

''

Running result:

Egon is running

Master

''

# slightly confusing example from threading import Threadimport timedef foo (): print ('1234') time.sleep (1) print (' end1234') def func (): print ('5678') time.sleep (3) print (' end5678') if _ name__ = ='_ main__': t1=Thread (target=foo,args= ()) t2=Thread (target=func,args= ()) t1.daemon=True # T1 is set as the daemon thread T2 is a non-daemon thread t1.start () t2.start () print ('master.')

''

Running result:

1234

5678 Lord.

End1234

End5678

''

''

Because the main thread waits for the non-daemon thread to finish running

All main threads wait for T2 (non-daemon thread) to finish.

''

Thread mutex lock

When multiple threads operate on the same data, the problem of data confusion will occur.

In view of the above problems, the solution is to add locks.

From threading import Thread,Lockimport timemoney=100mutex=Lock () def task (): global money mutex.acquire () tmp=money time.sleep (0.1) # simulated network delay money=tmp-1 mutex.release () if _ _ name__ = ='_ _ main__': tweeter list = [] for i in range (100): t=Thread (target=task Args= () t.start () t_list.append (t) for t int _ list: t.join () print (money)

# Operation result: 0

# multiple individuals operate the same data, data confusion, lock processing

7. GTL- global interpreter

I believe everyone learning python knows that there are actually multiple versions of the python interpreter.

Cpython

Jpython

Pypython

But the Cpython interpreter is widely used.

In the Cpython interpreter, GIL is a mutex that prevents multiple threads under the same process from executing at the same time

Note that multiple threads under the same process cannot take advantage of multi-core advantage!

There must be a lot of doubt in everyone's mind: is the multithreading of pyhon useless?

Because memory management in Cpython is not thread-safe. Multithreading is not useless. When it comes to multi-IO operations, the advantages of multi-core will not be shown. In this case, the efficiency of multi-process and multi-thread is not much different, but at this time, multi-process is relatively a waste of resources, and multi-threading is more resource-saving.

Ps: memory management is the garbage collection mechanism:

1. Reference count

2. Mark removal

3. Zoning recovery

# GTL- global interpreter # key points: 1. GIL is not a feature of python but a feature of Cpython interpreter # 2, GIL ensures the security of data at the interpreter level # 3, GIL will cause multiple threads under the same process to be unable to perform at the same time (that is, unable to take advantage of multi-core advantage) # 4, different locks are still needed for different data # 5, common faults of interpreted language Multiple threads under the same process cannot take advantage of multi-core advantage

Whether multithreading is useful depends on the specific situation.

Verify multithreaded and multithreaded application scenarios # Compute-intensive (CPU works all the time There is no IO) (more suitable for multi-process) from multiprocessing import Processfrom threading import Threadimport os Time# multiprocess case def work (): res=0 for i in range (0Jing 10000000): res*=iif _ _ name__ = ='_ main__': l = [] print (os.cpu_count ()) # get the number of CPU cores of the current computer start_time=time.time () for i in range (8): # my computer is 8 cores p = Process (target=work Args= () p.start () l.append (p) for p in l: p.join () print (time.time ()-start_time)

''

Running result:

eight

2.0726492404937744

''

# multithreaded case from multiprocessing import Processfrom threading import Threadimport os,timedef work (): res=0 for i in range (0Jing 10000000): res*=iif _ _ name__ = ='_ _ main__': l = [] print (os.cpu_count ()) # get the current computer CPU core start_time=time.time () for i in range (8): # my computer is an 8-core t=Thread (target=work Args= () t.start () l.append (t) for p in l: p.join () print (time.time ()-start_time)

''

Running result:

eight

3.5790603160858154

''

# it is obvious: computationally intensive, more timely multi-processes

# IO-intensive (tasks always have IO) (multithreading is more appropriate) from multiprocessing import Processfrom threading import Threadimport os,time# multithreaded def work (): time.sleep (1) if _ _ name__ = ='_ _ main__': l = [] start_time=time.time () for i in range (40): t=Thread (target=work Args= () t.start () l.append (t) for p in l: p.join () print (time.time ()-start_time) # running result: 1.020515203475952 multiprocess from multiprocessing import Processfrom threading import Threadimport os Timedef work (): time.sleep (1) if _ _ name__ = ='_ _ main__': l = [] start_time=time.time () for i in range (40): P = Process (target=work,args= ()) # t=Thread (target=work) Args= () # t.start () # l.append (t) p.start () l.append (p) for p in l: p.join () print (time.time ()-start_time)

# Operation result: 5.927189588546753

# it is obvious that IO-intensive is more suitable for multithreading

At this point, the study on "Python multithreading, that is, related concept analysis" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.