Python多线程是什么意思?

发布网友发布时间：2022-04-23 13:02

共5个回答

懂视网时间：2022-04-29 16:22

示例1
我们将要请求五个不同的url：
单线程

import time 
import urllib2 
defget_responses(): 
urls=[ 
‘http://www.baidu.com', 
‘http://www.amazon.com', 
‘http://www.ebay.com', 
‘http://www.alibaba.com', 
‘http://www.gxlcms.com' 
 ] 
start=time.time() 
forurlinurls: 
printurl 
resp=urllib2.urlopen(url) 
printresp.getcode() 
print”Elapsed time: %s”%(time.time()-start) 
get_responses()

输出是：
http://www.baidu.com200
http://www.amazon.com200
http://www.ebay.com200
http://www.alibaba.com200
http://www.gxlcms.com200
Elapsed time:3.0814409256

解释：
url顺序的被请求
除非cpu从一个url获得了回应，否则不会去请求下一个url
网络请求会花费较长的时间，所以cpu在等待网络请求的返回时间内一直处于闲置状态。
多线程

import urllib2 
import time 
from threading import Thread 
classGetUrlThread(Thread): 
def__init__(self, url): 
self.url=url 
super(GetUrlThread,self).__init__() 
defrun(self): 
resp=urllib2.urlopen(self.url) 
printself.url, resp.getcode() 
defget_responses(): urls=[ 
‘http://www.baidu.com', 
‘http://www.amazon.com', 
‘http://www.ebay.com', 
‘http://www.alibaba.com', 
‘http://www.gxlcms.com' 
] 
start=time.time() 
threads=[] 
forurlinurls: 
t=GetUrlThread(url) 
threads.append(t) 
t.start() 
fortinthreads: 
t.join() 
print”Elapsed time: %s”%(time.time()-start) 
get_responses()

输出：
http://www.gxlcms.com200
http://www.baidu.com200
http://www.amazon.com200
http://www.alibaba.com200
http://www.ebay.com200
Elapsed time:0.689890861511

解释：

意识到了程序在执行时间上的提升
我们写了一个多线程程序来减少cpu的等待时间，当我们在等待一个线程内的网络请求返回时，这时cpu可以切换到其他线程去进行其他线程内的网络请求。
我们期望一个线程处理一个url，所以实例化线程类的时候我们传了一个url。
线程运行意味着执行类里的run()方法。
无论如何我们想每个线程必须执行run()。
为每个url创建一个线程并且调用start()方法，这告诉了cpu可以执行线程中的run()方法了。
我们希望所有的线程执行完毕的时候再计算花费的时间，所以调用了join()方法。
join()可以通知主线程等待这个线程结束后，才可以执行下一条指令。
每个线程我们都调用了join()方法，所以我们是在所有线程执行完毕后计算的运行时间。

关于线程：

cpu可能不会在调用start()后马上执行run()方法。
你不能确定run()在不同线程建间的执行顺序。
对于单独的一个线程，可以保证run()方法里的语句是按照顺序执行的。
这就是因为线程内的url会首先被请求，然后打印出返回的结果。

实例2

我们将会用一个程序演示一下多线程间的资源竞争，并修复这个问题。

from threading import Thread 
#define a global variable some_var=0 
classIncrementThread(Thread): 
defrun(self): 
#we want to read a global variable 
#and then increment it 
globalsome_var 
read_value=some_var 
print”some_var in %s is %d”%(self.name, read_value) 
some_var=read_value+1 
print”some_var in %s after increment is %d”%(self.name, some_var) 
defuse_increment_thread(): 
threads=[] 
foriinrange(50): 
t=IncrementThread() 
threads.append(t) 
t.start() 
fortinthreads: 
t.join() 
print”After 50 modifications, some_var should have become 50″ 
print”After 50 modifications, some_var is %d”%(some_var,) 
use_increment_thread()

多次运行这个程序，你会看到多种不同的结果。
解释：
有一个全局变量，所有的线程都想修改它。
所有的线程应该在这个全局变量上加 1 。
有50个线程，最后这个数值应该变成50，但是它却没有。
为什么没有达到50？
在some_var是15的时候，线程t1读取了some_var，这个时刻cpu将控制权给了另一个线程t2。
t2线程读到的some_var也是15
t1和t2都把some_var加到16
当时我们期望的是t1 t2两个线程使some_var + 2变成17
在这里就有了资源竞争。
相同的情况也可能发生在其它的线程间，所以出现了最后的结果小于50的情况。
解决资源竞争

from threading 
import Lock, Thread 
lock=Lock() 
some_var=0 
classIncrementThread(Thread): 
defrun(self): 
#we want to read a global variable 
#and then increment it 
globalsome_var 
lock.acquire() 
read_value=some_var 
print”some_var in %s is %d”%(self.name, read_value) 
some_var=read_value+1 
print”some_var in %s after increment is %d”%(self.name, some_var) 
lock.release() 
defuse_increment_thread(): 
threads=[] 
foriinrange(50): 
t=IncrementThread() 
threads.append(t) 
t.start() 
fortinthreads: 
t.join() 
print”After 50 modifications, some_var should have become 50″ 
print”After 50 modifications, some_var is %d”%(some_var,) 
use_increment_thread()

再次运行这个程序，达到了我们预期的结果。
解释：
Lock 用来防止竞争条件
如果在执行一些操作之前，线程t1获得了锁。其他的线程在t1释放Lock之前，不会执行相同的操作
我们想要确定的是一旦线程t1已经读取了some_var，直到t1完成了修改some_var，其他的线程才可以读取some_var
这样读取和修改some_var成了逻辑上的原子操作。
实例3
让我们用一个例子来证明一个线程不能影响其他线程内的变量（非全局变量）。
time.sleep()可以使一个线程挂起，强制线程切换发生。

from threading import Thread 
import time 
classCreateListThread(Thread): 
defrun(self): 
self.entries=[] 
foriinrange(10): 
time.sleep(1) 
self.entries.append(i) 
printself.entries 
defuse_create_list_thread(): 
foriinrange(3): 
t=CreateListThread() 
t.start() 
use_create_list_thread()

运行几次后发现并没有打印出争取的结果。当一个线程正在打印的时候，cpu切换到了另一个线程，所以产生了不正确的结果。我们需要确保print self.entries是个逻辑上的原子操作，以防打印时被其他线程打断。
我们使用了Lock()，来看下边的例子。

from threading import Thread, Lock 
import time 
lock=Lock() 
classCreateListThread(Thread): 
defrun(self): 
self.entries=[] 
foriinrange(10): 
time.sleep(1) 
self.entries.append(i) 
lock.acquire() 
printself.entries 
lock.release() 
defuse_create_list_thread(): 
foriinrange(3): 
t=CreateListThread() 
t.start() 
use_create_list_thread()

这次我们看到了正确的结果。证明了一个线程不可以修改其他线程内部的变量（非全局变量）。

热心网友时间：2022-04-29 13:30

简单地说就是作为可能是仅有的支持多线程的解释型语言（perl的多线程是残疾，PHP没有多线程），Python的多线程是有compromise的，在任意时间只有一个Python解释器在解释Python bytecode。
UPDATE：如评论指出，Ruby也是有thread支持的，而且至少Ruby MRI是有GIL的。
如果你的代码是CPU密集型，多个线程的代码很有可能是线性执行的。所以这种情况下多线程是鸡肋，效率可能还不如单线程因为有context switch
但是：如果你的代码是IO密集型，多线程可以明显提高效率。例如制作爬虫（我就不明白为什么Python总和爬虫联系在一起…不过也只想起来这个例子…），绝大多数时间爬虫是在等待socket返回数据。这个时候C代码里是有release GIL的，最终结果是某个线程等待IO的时候其他线程可以继续执行。
反过来讲：你就不应该用Python写CPU密集型的代码…效率摆在那里…
如果确实需要在CPU密集型的代码里用concurrent，就去用multiprocessing库。这个库是基于multi process实现了类multi thread的API接口，并且用pickle部分地实现了变量共享。
再加一条，如果你不知道你的代码到底算CPU密集型还是IO密集型，教你个方法：
multiprocessing这个mole有一个mmy的sub mole，它是基于multithread实现了multiprocessing的API。
假设你使用的是multiprocessing的Pool，是使用多进程实现了concurrency
from multiprocessing import Pool
如果把这个代码改成下面这样，就变成多线程实现concurrency
from multiprocessing.mmy import Pool
两种方式都跑一下，哪个速度快用哪个就行了。
UPDATE:
刚刚才发现concurrent.futures这个东西，包含ThreadPoolExecutor和ProcessPoolExecutor，可能比multiprocessing更简单

热心网友时间：2022-04-29 14:48

多线程能让你像运行一个独立的程序一样运行一段长代码。这有点像调用子进程（subprocess），不过区别是你调用的是一个函数或者一个类，而不是独立的程序。
程基本上是一个独立执行流程。单个进程可以由多个线程组成。程序中的每个线程都执行特定的任务。例如,当你在电脑上玩游戏时，比如说国际足联，整个游戏是一个单一的过程。,但它由几个线程组成，负责播放音乐、接收用户的输入、同步运行对手等。所有这些都是单独的线程，负责在同一个程序中执行这些不同的任务。
每个进程都有一个始终在运行的线程。这是主线。这个主线程实际上创建子线程对象。子线程也由主线程启动。

热心网友时间：2022-04-29 16:22

几乎所有的操作系统都支持同时运行多个任务，一个任务通常就是一个程序，所有运行中的任务都对应一个进程。即当一个程序进入内存运行时，即变成一个进程。进程就是处于运行过程中的程序，并且具有一定的独立功能。进程是系统进行资源分配调度的一个独立单位，当一个程序运行时，内部可能包含多个顺序执流，每个顺序执行流就是一个线程。Python多线程的优势：
1、线程在程序中是独立的，并发的执行流，划分尺度小于进程，所有多线程程序的并发性高;
2、进程在执行过程中拥有独立的内存单元，而多个线程共享内存，可以极大地提高进程程序的运行效率;
3、线程比进程具有更高的性能，由于同一个进程中的线程都有共性，多个线程共享同一个进程的虚拟空间，可以很容易实现通信。操作系统在创建进程中，必须为该进程分配独立内存空间，分配大量相关资源，但创建线程则简单得多。

热心网友时间：2022-04-29 18:14

什么是线程

线程（Thread）也叫轻量级进程，是操作系统能够进行运算调度的最小单位，它被包涵在进程之中，是进程中的实际运作单位。线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一进程中的多个线程之间可以并发执行。

为什么要使用多线程

线程在程序中是独立的、并发的执行流。与分隔的进程相比，进程中线程之间的隔离程度要小，它们共享内存、文件句柄和其他进程应有的状态。

因为线程的划分尺度小于进程，使得多线程程序的并发性高。进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

线程比进程具有更高的性能，这是由于同一个进程中的线程都有共性多个线程共享同一个进程的虚拟空间。线程共享的环境包括进程代码段、进程的公有数据等，利用这些共享的数据，线程之间很容易实现通信。

操作系统在创建进程时，必须为该进程分配独立的内存空间，并分配大量的相关资源，但创建线程则简单得多。因此，使用多线程来实现并发比使用多进程的性能要高得多。

总结起来，使用多线程编程具有如下几个优点：

进程之间不能共享内存，但线程之间共享内存非常容易。

操作系统在创建进程时，需要为该进程重新分配系统资源，但创建线程的代价则小得多。因此，使用多线程来实现多任务并发执行比使用多进程的效率高。

Python 语言内置了多线程功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了 Python 的多线程编程。

python多线程能提高效率吗

在某些情况下，Python多线程可以提高程序的执行效率。多线程是指在一个程序中同时运行多个线程，每个线程可以执行不同的任务，从而实现并发执行。多线程可以提高效率的情况包括：1、并行任务：如果程序中有多个任务可以并行执行，即它们不会相互阻塞或依赖彼此的结果，那么使用多线程可以同时执行这些任务，从而...

什么是线程(多线程),Python多线程的好处

多线程则扩展了多进程的概念，使得同一个进程可以同时并发处理多个任务。线程（Thread）也被称作轻量级进程（Lightweight Process），线程是进程的执行单元。就像进程在操作系统中的地位一样，线程在程序中是独立的、并发的执行流。当进程被初始化后，主线程就被创建了。对于绝大多数的应用程序来说，通常仅...