线程--理论篇
线程概念的引入背景
进程
以前咱们已经了解了操做系统中进程的概念，程序并不能单独运行，只有将程序装载到内存中，系统为它分配资源才能运行，而这种执行的程序就称之为进程。程序和进程的区别就在于：程序是指令的集合，它是进程运行的静态描述文本；进程是程序的一次执行活动，属于动态概念。在多道编程中，咱们容许多个程序同时加载到内存中，在操做系统的调度下，能够实现并发地执行。这是这样的设计，大大提升了CPU的利用率。进程的出现让每一个用户感受到本身独享CPU，所以，进程就是为了在CPU上实现多道编程而提出的。python
有了进程为何要有线程
进程有不少优势，它提供了多道编程，让咱们感受咱们每一个人都拥有本身的CPU和其余资源，能够提升计算机的利用率。不少人就不理解了，既然进程这么优秀，为何还要线程呢？其实，仔细观察就会发现进程仍是有不少缺陷的，主要体如今两点上：mysql
-
进程只能在一个时间干一件事，若是想同时干两件事或多件事，进程就无能为力了。linux
-
进程在执行的过程当中若是阻塞，例如等待输入，整个进程就会挂起，即便进程中有些工做不依赖于输入的数据，也将没法执行。程序员
线程的出现
进程和线程的关系
线程的特色
TCB包括如下信息： （1）线程状态。 （2）当线程不运行时，被保存的现场资源。 （3）一组执行堆栈。 （4）存放每一个线程的局部变量主存区。 （5）访问同一个进程中的主存和其它资源。 用于指示被执行指令序列的程序计数器、保留局部变量、少数状态参数和返回地址等的一组寄存器和堆栈。
多个线程共享同一个进程的地址空间中的资源，是对一台计算机上多个进程的模拟，有时也称线程为轻量级的进程。算法
而对一台计算机上多个进程，则共享物理内存、磁盘、打印机等其余物理资源。多线程的运行也多进程的运行相似，是cpu在多个线程之间的快速切换。sql
不一样的进程之间是充满敌意的，彼此是抢占、竞争cpu的关系，若是迅雷会和QQ抢资源。而同一个进程是由一个程序员的程序建立，因此同一进程内的线程是合做关系，一个线程能够访问另一个线程的内存地址，你们都是共享的，一个线程干死了另一个线程的内存，那纯属程序员脑子有问题。编程
相似于进程，每一个线程也有本身的堆栈，不一样于进程，线程库没法利用时钟中断强制线程让出CPU，能够调用thread_yield运行线程自动放弃cpu，让另一个线程运行。小程序
线程一般是有益的，可是带来了不小程序设计难度，线程的问题是：windows
1. 父进程有多个线程，那么开启的子线程是否须要一样多的线程安全
2. 在同一个进程中，若是一个线程关闭了文件，而另一个线程正准备往该文件内写内容呢？
所以，在多线程的代码中，须要更多的心思来设计程序的逻辑、保护程序的数据。
用户级线程和内核级线程（了解）
线程的实现能够分为两类：用户级线程(User-Level Thread)和内核线线程(Kernel-Level Thread)，后者又称为内核支持的线程或轻量级进程。在多线程操做系统中，各个系统的实现方式并不相同，在有的系统中实现了用户级线程，有的系统中实现了内核级线程。
用户级线程
内核的切换由用户态程序本身控制内核切换,不须要内核干涉，少了进出内核态的消耗，但不能很好的利用多核Cpu。
在用户空间模拟操做系统对进程的调度，来调用一个进程中的线程，每一个进程中都会有一个运行时系统，用来调度线程。此时当该进程获取cpu时，进程内再调度出一个线程去执行，同一时刻只有一个线程执行。
内核级线程
内核级线程:切换由内核控制，当线程进行切换的时候，由用户态转化为内核态。切换完毕要从内核态返回用户态；能够很好的利用smp，即利用多核cpu。windows线程就是这样的。
用户级与内核级线程的对比
用户级线程和内核级线程的区别
1 内核支持线程是OS内核可感知的，而用户级线程是OS内核不可感知的。 2 用户级线程的建立、撤消和调度不须要OS内核的支持，是在语言（如Java）这一级处理的；而内核支持线程的建立、撤消和调度都需OS内核提供支持，并且与进程的建立、撤消和调度大致是相同的。 3 用户级线程执行系统调用指令时将致使其所属进程被中断，而内核支持线程执行系统调用指令时，只致使该线程被中断。 4 在只有用户级线程的系统内，CPU调度仍是以进程为单位，处于运行状态的进程中的多个线程，由用户程序控制线程的轮换运行；在有内核支持线程的系统内，CPU调度则以线程为单位，由OS的线程调度程序负责线程的调度。 5 用户级线程的程序实体是运行在用户态下的程序，而内核支持线程的程序实体则是能够运行在任何状态下的程序。
优势：当有多个处理机时，一个进程的多个线程能够同时执行。 缺点：由内核进行调度。
优势： 线程的调度不须要内核直接参与，控制简单。 能够在不支持线程的操做系统中实现。 建立和销毁线程、线程切换代价等线程管理的代价比内核线程少得多。 容许每一个进程定制本身的调度算法，线程管理比较灵活。 线程可以利用的表空间和堆栈空间比内核级线程多。 同一进程中只能同时有一个线程在运行，若是有一个线程使用了系统调用而阻塞，那么整个进程都会被挂起。另外，页面失效也会产生一样的问题。 缺点： 资源调度按照进程进行，多个处理机下，同一个进程中的线程只能在同一个处理机下分时复用
混合实现
用户级与内核级的多路复用，内核同一调度内核线程，每一个内核线程对应n个用户线程
linux操做系统的 NPTL
历史 在内核2.6之前的调度实体都是进程，内核并无真正支持线程。它是能过一个系统调用clone()来实现的，这个调用建立了一份调用进程的拷贝，跟fork()不一样的是,这份进程拷贝彻底共享了调用进程的地址空间。LinuxThread就是经过这个系统调用来提供线程在内核级的支持的(许多之前的线程实现都彻底是在用户态，内核根本不知道线程的存在)。很是不幸的是，这种方法有至关多的地方没有遵循POSIX标准，特别是在信号处理，调度，进程间通讯原语等方面。 很显然，为了改进LinuxThread必须获得内核的支持，而且须要重写线程库。为了实现这个需求，开始有两个相互竞争的项目：IBM启动的NGTP(Next Generation POSIX Threads)项目，以及Redhat公司的NPTL。在2003年的年中，IBM放弃了NGTP，也就是大约那时，Redhat发布了最初的NPTL。 NPTL最开始在redhat linux 9里发布，如今从RHEL3起内核2.6起都支持NPTL，而且彻底成了GNU C库的一部分。 设计 NPTL使用了跟LinuxThread相同的办法，在内核里面线程仍然被看成是一个进程，而且仍然使用了clone()系统调用(在NPTL库里调用)。可是，NPTL须要内核级的特殊支持来实现，好比须要挂起而后再唤醒线程的线程同步原语futex. NPTL也是一个1*1的线程库，就是说，当你使用pthread_create()调用建立一个线程后，在内核里就相应建立了一个调度实体，在linux里就是一个新进程，这个方法最大可能的简化了线程的实现。 除NPTL的1*1模型外还有一个m*n模型，一般这种模型的用户线程数会比内核的调度实体多。在这种实现里，线程库自己必须去处理可能存在的调度，这样在线程库内部的上下文切换一般都会至关的快，由于它避免了系统调用转到内核态。然而这种模型增长了线程实现的复杂性,并可能出现诸如优先级反转的问题，此外，用户态的调度如何跟内核态的调度进行协调也是很难让人满意。
线程和python
全局解释器锁GIL
Python代码的执行由Python虚拟机(也叫解释器主循环)来控制。Python在设计之初就考虑到要在主循环中，同时只有一个线程在执行。虽然 Python 解释器中能够“运行”多个线程，但在任意时刻只有一个线程在解释器中运行。
对Python虚拟机的访问由全局解释器锁(GIL)来控制，正是这个锁能保证同一时刻只有一个线程在运行。
在多线程环境中，Python 虚拟机按如下方式执行：
a、设置 GIL；
b、切换到一个线程去运行；
c、运行指定数量的字节码指令或者线程主动让出控制(能够调用 time.sleep(0))；
d、把线程设置为睡眠状态；
e、解锁 GIL；
d、再次重复以上全部步骤。
在调用外部代码(如 C/C++扩展函数)的时候，GIL将会被锁定，直到这个函数结束为止(因为在这期间没有Python的字节码被运行，因此不会作线程切换)编写扩展的程序员能够主动解锁GIL。
python线程模块的选择
Python提供了几个用于多线程编程的模块，包括thread、threading和Queue等。thread和threading模块容许程序员建立和管理线程。thread模块提供了基本的线程和锁的支持，threading提供了更高级别、功能更强的线程管理的功能。Queue模块容许用户建立一个能够用于多个线程之间共享数据的队列数据结构。
避免使用thread模块，由于更高级别的threading模块更为先进，对线程的支持更为完善，并且使用thread模块里的属性有可能会与threading出现冲突；其次低级别的thread模块的同步原语不多(实际上只有一个)，而threading模块则有不少；再者，thread模块中当主线程结束时，全部的线程都会被强制结束掉，没有警告也不会有正常的清除工做，至少threading模块能确保重要的子线程退出后进程才退出。
thread模块不支持守护线程，当主线程退出时，全部的子线程不论它们是否还在工做，都会被强行退出。而threading模块支持守护线程，守护线程通常是一个等待客户请求的服务器，若是没有客户提出请求它就在那等着，若是设定一个线程为守护线程，就表示这个线程是不重要的，在进程退出的时候，不用等待这个线程退出。
threading模块
multiprocess模块的彻底模仿了threading模块的接口，两者在使用层面，有很大的类似性，于是再也不详细介绍
线程的建立Threading.Thread类
线程的建立
线程的建立1
from threading import Thread
import time
def sayhi(name):
time.sleep(2)
print('%s say hello' %name)
if __name__ == '__main__':
t=Thread(target=sayhi,args=('egon',))
t.start()
print('主线程')
线程的from threading import Threaimport time
class Sayhi(Thread): def __init__(self,name): super().__init__() self.name=name def run(self): time.sleep(2) print('%s say hello' % self.name) if __name__ == '__main__': t = Sayhi('egon') t.start() print('主线程')
多线程与多进程
pid的比较
from threading import Thread
from multiprocessing import Process
import os
def work():
print('hello',os.getpid())
if __name__ == '__main__':
#part1:在主进程下开启多个线程,每一个线程都跟主进程的pid同样
t1=Thread(target=work)
t2=Thread(target=work)
t1.start()
t2.start()
print('主线程/主进程pid',os.getpid())
#part2:开多个进程,每一个进程都有不一样的pid
p1=Process(target=work)
p2=Process(target=work)
p1.start()
p2.start()
print('主线程/主进程pid',os.getpid())
开启效率的较量
from threading import Thread
from multiprocessing import Process
import os
def work():
print('hello')
if __name__ == '__main__':
#在主进程下开启线程
t=Thread(target=work)
t.start()
print('主线程/主进程')
'''
打印结果:
hello
主线程/主进程
'''
#在主进程下开启子进程
t=Process(target=work)
t.start()
print('主线程/主进程')
'''
打印结果:
主线程/主进程
hello
'''
内存数据的共享问题
from threading import Thread
from multiprocessing import Process
import os
def work():
global n
n=0
if __name__ == '__main__':
# n=100
# p=Process(target=work)
# p.start()
# p.join()
# print('主',n) #毫无疑问子进程p已经将本身的全局的n改为了0,但改的仅仅是它本身的,查看父进程的n仍然为100
n=1
t=Thread(target=work)
t.start()
t.join()
print('主',n) #查看结果为0,由于同一进程内的线程之间共享进程内的数据
同一进程内的线程共享该进程的数据？
多线程实现socket
sever服务端
#_*_coding:utf-8_*_
#!/usr/bin/env python
import multiprocessing
import threading
import socket
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind(('127.0.0.1',8080))
s.listen(5)
def action(conn):
while True:
data=conn.recv(1024)
print(data)
conn.send(data.upper())
if __name__ == '__main__':
while True:
conn,addr=s.accept()
p=threading.Thread(target=action,args=(conn,))
p.start()
clilend客户端
#_*_coding:utf-8_*_
#!/usr/bin/env python
import socket
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(('127.0.0.1',8080))
while True:
msg=input('>>: ').strip()
if not msg:continue
s.send(msg.encode('utf-8'))
data=s.recv(1024)
print(data)
Thread类的其余方法
Thread实例对象的方法 # isAlive(): 返回线程是否活动的。 # getName(): 返回线程名。 # setName(): 设置线程名。 threading模块提供的一些方法： # threading.currentThread(): 返回当前的线程变量。 # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。 # threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。
代码实例
from threading import Thread
import threading
from multiprocessing import Process
import os
def work():
import time
time.sleep(3)
print(threading.current_thread().getName())
if __name__ == '__main__':
#在主进程下开启线程
t=Thread(target=work)
t.start()
print(threading.current_thread().getName())
print(threading.current_thread()) #主线程
print(threading.enumerate()) #连同主线程在内有两个运行的线程
print(threading.active_count())
print('主线程/主进程')
'''
打印结果:
MainThread
<_MainThread(MainThread, started 140735268892672)>
[<_MainThread(MainThread, started 140735268892672)>, <Thread(Thread-1, started 123145307557888)>]
主线程/主进程
Thread-1
'''
join方法
from threading import Thread
import time
def sayhi(name):
time.sleep(2)
print('%s say hello' %name)
if __name__ == '__main__':
t=Thread(target=sayhi,args=('egon',))
t.start()
t.join()
print('主线程')
print(t.is_alive())
'''
egon say hello
主线程
False
'''
守护线程
不管是进程仍是线程，都遵循：守护xx会等待主xx运行完毕后被销毁。须要强调的是：运行完毕并不是终止运行
#1.对主进程来讲，运行完毕指的是主进程代码运行完毕 #2.对主线程来讲，运行完毕指的是主线程所在的进程内全部非守护线程通通运行完毕，主线程才算运行完毕
详细解释
#1 主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,而后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(不然会产生僵尸进程)，才会结束， #2 主线程在其余非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。由于主线程的结束意味着进程的结束，进程总体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。
守护线程程1
from threading import Thread
import time
def sayhi(name):
time.sleep(2)
print('%s say hello' %name)
if __name__ == '__main__':
t=Thread(target=sayhi,args=('egon',))
t.setDaemon(True) #必须在t.start()以前设置
t.start()
print('主线程')
print(t.is_alive())
'''
主线程
True
'''
守护线程2
from threading import Thread
import time
def foo():
print(123)
time.sleep(1)
print("end123")
def bar():
print(456)
time.sleep(3)
print("end456")
t1=Thread(target=foo)
t2=Thread(target=bar)
t1.daemon=True
t1.start()
t2.start()
print("main-------")
锁
同步锁
多个线程抢占资源的状况
from threading import Thread
import os,time
def work():
global n
temp=n
time.sleep(0.1)
n=temp-1
if __name__ == '__main__':
n=100
l=[]
for i in range(100):
p=Thread(target=work)
l.append(p)
p.start()
for p in l:
p.join()
print(n) #结果可能为99
引入同步锁
from threading import Thread,Lock
import os,time
def work():
global n
lock.acquire()
temp=n
time.sleep(0.1)
n=temp-1
lock.release()
if __name__ == '__main__':
lock=Lock()
n=100
l=[]
for i in range(100):
p=Thread(target=work)
l.append(p)
p.start()
for p in l:
p.join()
print(n) #结果确定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全
互斥锁与join的区别
#在这里有个疑问:既然加锁会让运行变成串行,那么我在start以后当即使用join,就不用加锁了啊,也是串行的效果啊 #没错:在start以后马上使用jion,确定会将100个任务的执行变成串行,毫无疑问,最终n的结果也确定是0,是安全的,但问题是 #start后当即join:任务内的全部代码都是串行执行的,而加锁,只是加锁的部分即修改共享数据的部分是串行的 #单从保证数据安全方面,两者均可以实现,但很明显是加锁的效率更高，并且高的不是一点半点
死锁与递归锁
进程也有死锁与递归锁，在进程那里忘记说了，放到这里一切说了额
所谓死锁： 是指两个或两个以上的进程或线程在执行过程当中，因争夺资源而形成的一种互相等待的现象，若无外力做用，它们都将没法推动下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，以下就是死锁
from threading import Lock as Lock import time mutexA=Lock() mutexA.acquire() mutexA.acquire() print(123) mutexA.release() mutexA.release()
解决方法，递归锁，在Python中为了支持在同一线程中屡次请求同一资源，python提供了可重入锁RLock。
这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源能够被屡次require。直到一个线程全部的acquire都被release，其余的线程才能得到资源。上面的例子若是使用RLock代替Lock，则不会发生死锁：
from threading import RLock as Lock import time mutexA=Lock() mutexA.acquire() mutexA.acquire() print(123) mutexA.release() mutexA.release()
典型问题：科学家吃面
下面死锁了
import time
from threading import Thread,Lock
noodle_lock = Lock()
fork_lock = Lock()
def eat1(name):
noodle_lock.acquire()
print('%s 抢到了面条'%name)
fork_lock.acquire()
print('%s 抢到了叉子'%name)
print('%s 吃面'%name)
fork_lock.release()
noodle_lock.release()
def eat2(name):
fork_lock.acquire()
print('%s 抢到了叉子' % name)
time.sleep(1)
noodle_lock.acquire()
print('%s 抢到了面条' % name)
print('%s 吃面' % name)
noodle_lock.release()
fork_lock.release()
for name in ['悟空','galen','高圆圆']:
t1 = Thread(target=eat1,args=(name,))
t2 = Thread(target=eat2,args=(name,))
t1.start()
t2.start()
递归锁解决死锁
import time
from threading import Thread,RLock
fork_lock = noodle_lock = RLock()
def eat1(name):
noodle_lock.acquire()
print('%s 抢到了面条'%name)
fork_lock.acquire()
print('%s 抢到了叉子'%name)
print('%s 吃面'%name)
fork_lock.release()
noodle_lock.release()
def eat2(name):
fork_lock.acquire()
print('%s 抢到了叉子' % name)
time.sleep(1)
noodle_lock.acquire()
print('%s 抢到了面条' % name)
print('%s 吃面' % name)
noodle_lock.release()
fork_lock.release()
for name in ['哪吒','egon','yuan']:
t1 = Thread(target=eat1,args=(name,))
t2 = Thread(target=eat2,args=(name,))
t1.start()
t2.start()
信号量
同进程的同样
Semaphore管理一个内置的计数器，
每当调用acquire()时内置计数器-1；
调用release() 时内置计数器+1；
计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其余线程调用release()。
实例：(同时只有5个线程能够得到semaphore,便可以限制最大链接数为5)：
from threading import Thread,Semaphore
import threading
import time
# def func():
# if sm.acquire():
# print (threading.currentThread().getName() + ' get semaphore')
# time.sleep(2)
# sm.release()
def func():
sm.acquire()
print('%s get sm' %threading.current_thread().getName())
time.sleep(3)
sm.release()
if __name__ == '__main__':
sm=Semaphore(5)
for i in range(23):
t=Thread(target=func)
t.start()
与进程池是彻底不一样的概念，进程池Pool(4)，最大只能产生4个进程，并且从头至尾都只是这四个进程，不会产生新的，而信号量是产生一堆线程/进程
事件
同进程的同样
线程的一个关键特性是每一个线程都是独立运行且状态不可预测。若是程序中的其 他线程须要经过判断某个线程的状态来肯定本身下一步的操做,这时线程同步问题就会变得很是棘手。为了解决这些问题,咱们须要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它容许线程等待某些事件的发生。在 初始状况下,Event对象中的信号标志被设置为假。若是有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程若是将一个Event对象的信号标志设置为真,它将唤醒全部等待这个Event对象的线程。若是一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行
event.isSet()：返回event的状态值； event.wait()：若是 event.isSet()==False将阻塞线程； event.set()： 设置event的状态值为True，全部阻塞池的线程激活进入就绪状态， 等待操做系统调度； event.clear()：恢复event的状态值为False。
例如，有多个工做线程尝试连接MySQL，咱们想要在连接前确保MySQL服务正常才让那些工做线程去链接MySQL服务器，若是链接不成功，都会去尝试从新链接。那么咱们就能够采用threading.Event机制来协调各个工做线程的链接操做
import threading
import time,random
from threading import Thread,Event
def conn_mysql():
count=1
while not event.is_set():
if count > 3:
raise TimeoutError('连接超时')
print('<%s>第%s次尝试连接' % (threading.current_thread().getName(), count))
event.wait(0.5)
count+=1
print('<%s>连接成功' %threading.current_thread().getName())
def check_mysql():
print('\033[45m[%s]正在检查mysql\033[0m' % threading.current_thread().getName())
time.sleep(random.randint(2,4))
event.set()
if __name__ == '__main__':
event=Event()
conn1=Thread(target=conn_mysql)
conn2=Thread(target=conn_mysql)
check=Thread(target=check_mysql)
conn1.start()
conn2.start()
check.start()
条件
使得线程等待，只有知足某条件时，才释放n个线程
Python提供的Condition对象提供了对复杂线程同步问题的支持。Condition被称为条件变量，除了提供与Lock相似的acquire和release方法外，还提供了wait和notify方法。线程首先acquire一个条件变量，而后判断一些条件。若是条件不知足则wait；若是条件知足，进行一些处理改变条件后，经过notify方法通知其余线程，其余处于wait状态的线程接到通知后会从新判断条件。不断的重复这一过程，从而解决复杂的同步问题。
import threading
def run(n):
con.acquire()
con.wait()
print("run the thread: %s" % n)
con.release()
if __name__ == '__main__':
con = threading.Condition()
for i in range(10):
t = threading.Thread(target=run, args=(i,))
t.start()
while True:
inp = input('>>>')
if inp == 'q':
break
con.acquire()
con.notify(int(inp))
con.release()
print('****')
定时器
定时器，指定n秒后执行某个操做
from threading import Timer
def hello():
print("hello, world")
t = Timer(1, hello)
t.start() # after 1 seconds, "hello, world" will be printed
线程队列
queue队列 ：使用import queue，用法与进程Queue同样
queue is especially useful in threaded programming when information must be exchanged safely between multiple threads.
-
class
queue.Queue(maxsize=0) #先进先出
import queue
q=queue.Queue()
q.put('first')
q.put('second')
q.put('third')
print(q.get())
print(q.get())
print(q.get())
'''
结果(先进先出):
first
second
third
'''
class (maxsize=0) #后进先出queue.LifoQueue
import queue
q=queue.LifoQueue()
q.put('first')
q.put('second')
q.put('third')
print(q.get())
print(q.get())
print(q.get())
'''
结果(后进先出):
third
second
first
'''
class (maxsize=0) #存储数据时可设置优先级的队列
queue.PriorityQueue
import queue q=queue.PriorityQueue() #put进入一个元组,元组的第一个元素是优先级(一般是数字,也能够是非数字之间的比较),数字越小优先级越高 q.put((20,'a')) q.put((10,'b')) q.put((30,'c')) print(q.get()) print(q.get()) print(q.get()) ''' 结果(数字越小优先级越高,优先级高的优先出队): (10, 'b') (20, 'a') (30, 'c') '''
Python标准模块--concurrent.futures
#1 介绍 concurrent.futures模块提供了高度封装的异步调用接口 ThreadPoolExecutor：线程池，提供异步调用 ProcessPoolExecutor: 进程池，提供异步调用 Both implement the same interface, which is defined by the abstract Executor class. #2 基本方法 #submit(fn, *args, **kwargs) 异步提交任务 #map(func, *iterables, timeout=None, chunksize=1) 取代for循环submit的操做 #shutdown(wait=True) 至关于进程池的pool.close()+pool.join()操做 wait=True，等待池内全部任务执行完毕回收完资源后才继续 wait=False，当即返回，并不会等待池内的任务执行完毕 但无论wait参数为什么值，整个程序都会等到全部任务执行完毕 submit和map必须在shutdown以前 #result(timeout=None) 取得结果 #add_done_callback(fn) 回调函数
- 1. 基础补充-多线程-理论篇
- 2. java之多线程理论篇
- 3. 线程理论
- 4. python线程理论
- 5. 网络编程-(理论篇)
- 6. 线程池理论 1
- 7. iOS多线程理论
- 8. Kubernetes理论篇
- 9. ZooKeeper理论篇
- 10. WebSocket - 理论篇
- 更多相关文章...
- • C# 多线程 - C#教程
- • CAP理论是什么？ - NoSQL教程
- • Docker 清理命令
- • Java 8 Stream 教程
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. js中 charCodeAt
- 2. Android中通过ViewHelper.setTranslationY实现View移动控制（NineOldAndroids开源项目）
- 3. 【Android】日常记录：BottomNavigationView自定义样式，修改点击后图片
- 4. maya 文件检查 ui和数据分离 （一）
- 5. eclipse 修改项目的jdk版本
- 6. Android InputMethod设置
- 7. Simulink中Bus Selector出现很多? ? ?
- 8. 【Openfire笔记】启动Mac版Openfire时提示“系统偏好设置错误”
- 9. AutoPLP在偏好标签中的生产与应用
- 10. 数据库关闭的四种方式
- 1. 基础补充-多线程-理论篇
- 2. java之多线程理论篇
- 3. 线程理论
- 4. python线程理论
- 5. 网络编程-(理论篇)
- 6. 线程池理论 1
- 7. iOS多线程理论
- 8. Kubernetes理论篇
- 9. ZooKeeper理论篇
- 10. WebSocket - 理论篇