当前位置:网站首页>Is multithreading really faster than single threading?

Is multithreading really faster than single threading?

2020-11-09 12:25:17 Cold moon sky

in fact ,Python Another important topic of multithreading is ,GILGlobal Interpreter Lock, Global interpreter lock ).

Multithreading is not necessarily faster than single threading

stay Python in , It can be done through multiple processes 、 Multithreading and multiprocessing to achieve multitasking . Can multithreading be faster than a single thread ?

Now I use a piece of code to prove my point of view .

'''
@Author: Runsen
@ WeChat official account : Python King 
@ Blog : https://blog.csdn.net/weixin_44510615
@Date: 2020/6/4
'''

import threading, time
def my_counter():
 i = 0
 for _ in range(100000000):
 i = i+1
 return True

def main1():
 start_time = time.time()
 for tid in range(2):
 t = threading.Thread(target=my_counter)
 t.start()
 t.join() #  The first time around join Method causes the main thread to block , But the second thread doesn't start , So the two threads are executed sequentially 

 print(" Single thread sequential execution total_time: {}".format(time.time() - start_time))

def main2():
 thread_ary = {}
 start_time = time.time()
 for tid in range(2):
 t = threading.Thread(target=my_counter)
 t.start()
 thread_ary[tid] = t

 for i in range(2):
 thread_ary[i].join() #  Both threads have started , So two threads are concurrent 

 print(" Multithreaded execution total_time: {}".format(time.time() - start_time))

if __name__ == "__main__":
 main1()
 main2()
 Copy code 

Running results

 Single thread sequential execution total_time: 17.754502773284912
 Multithreaded execution total_time: 20.01178550720215
 Copy code 

I'm afraid you'll say I'll make a mess of it , I'd like to take a picture and see it clearly

At this time , I doubt that : Is there something wrong with my machine ? It's not like that , In essence Python The thread of is invalid , It doesn't work in parallel .

Python The thread of , It does encapsulate the underlying operating system threads , stay Linux In the system is Pthread( Its full name is POSIX Thread), And in the Windows In the system is Windows Thread. in addition ,Python The thread of , And it's completely managed by the operating system , For example, coordinating when to implement 、 Managing memory resources 、 Management interruption and so on .

GIL No Python Characteristics of

GIL In a simple sentence , Namely Any moment , No matter how many threads , A single CPython The interpreter can only execute one bytecode . This definition needs attention :

The first thing to be clear is GIL Not at all Python Characteristics of , It's about achieving Python Parser (CPython) A concept introduced by .

C++ It's a set of languages ( grammar ) standard , But different compilers can be used to compile executable code . Famous compilers such as GCC,INTEL C++,Visual C++ etc. .

Python It's the same thing , The same piece of code can be passed through CPython,PyPy,Psyco Such as different Python Execution environment to execute .

other Python The interpreter doesn't have to have GIL. for example Jython (JVM) and IronPython (CLR) No, GIL, and CPython,PyPy Yes GIL;

because CPython Is the default in most environments Python execution environment . So in many people's concepts CPython Namely Python, Take it for granted GIL It comes down to Python The flaw of language . So let's be clear here :GIL Not at all Python Characteristics of ,Python It can be completely independent of GIL

GIL The essence is a mutually exclusive lock

GIL The essence is a mutually exclusive lock , Since it's a mutex , The essence of all mutexes is the same , It's all about making concurrent runs serial , In this way, the shared data can only be modified by one task in the same time , To ensure data security .

One thing for sure is : Securing different data , We should add different locks .

GIL How it works : So let's take this picture , It's just one. GIL stay Python Working example of the program . among ,Thread 1、2、3 Take turns to execute , When each thread starts executing , Will lock up GIL, To prevent other threads from executing ; alike , After each thread finishes executing a section , Will release GIL, To allow other threads to start using resources .

Computationally intensive

Computing intensive tasks are characterized by a large number of calculations , Consume CPU resources .

Let's start with a simple computationally intensive example :

'''
@Author: Runsen
@ WeChat official account : Python King 
@ Blog : https://blog.csdn.net/weixin_44510615
@Date: 2020/6/4
'''
import time
COUNT = 50_000_000

def count_down():
 global COUNT
 while COUNT > 0:
 COUNT -= 1

s = time.perf_counter()
count_down()
c = time.perf_counter() - s
print('time taken in seconds - >:', c)

time taken in seconds - >: 9.2957003

 Copy code 

This is a single thread , Time is 9s, Let's use two threads to see what the results are :

'''
@Author: Runsen
@ WeChat official account : Python King 
@ Blog : https://blog.csdn.net/weixin_44510615
@Date: 2020/6/4
'''
import time
from threading import Thread

COUNT = 50_000_000

def count_down():
 global COUNT
 while COUNT > 0:
 COUNT -= 1

s = time.perf_counter()
t1 = Thread(target=count_down)
t2 = Thread(target=count_down)
t1.start()
t2.start()
t1.join()
t2.join()
c = time.perf_counter() - s
print('time taken in seconds - >:', c)

time taken in seconds - >: 17.110625

 Copy code 

The main operation of our program is to calculate , CPU No waiting , And after changing to multithreading , After adding threads , Frequent switching between threads , Increased time cost , Time will certainly increase .

Another type is IO intensive , Network involved 、 disk IO The tasks of are IO Intensive task , This kind of task is characterized by CPU Consume little , Most of the time the task is waiting IO Operation is completed ( because IO The speed is much lower than CPU And the speed of memory ). about IO Intensive task , The more tasks ,CPU The more efficient , But there is also a limit . Most common tasks are IO Intensive task , such as Web application .

summary : about io Intensive work (Python Reptiles ), Multithreading can greatly improve code efficiency . Yes CPU Computationally intensive (Python Data analysis , machine learning , Deep learning ), Multithreading may be slightly less efficient than a single thread . therefore , In the field of data, there is no saying that multithreading can improve efficiency , Only will CPU Upgrade to GPU,TPU To improve computing power .


author : Liu Runsen
link :https://juejin.im/post/6892747972933910535
source : Nuggets
The copyright belongs to the author . Commercial reprint please contact the author for authorization , Non-commercial reprint please indicate the source .

版权声明
本文为[Cold moon sky]所创,转载请带上原文链接,感谢