本节内容：
线程：
a:基本的使用:
创建线程：
1：方法
import threading def f1(x):
print(x) if __name__=='__main__':
t=threading.Thread(target=f1,args=(，))
t.start()
t=threading.Thread(target=f1,args=(1,))创建线程，target=动作（执行什么，需要是可被调用的函数）args参数元组，要求参数最后加个逗号。
当我们创建一个线程时候，t.start()之后，线程已经准备就绪等待cpu调度。
cpu通过触发threading.Thread类中的run方法来调用我们传入的target 函数。通过debug断点调试可以看到如下：
aaarticlea/png;base64,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" alt="" />
在看下run方法。
aaarticlea/png;base64,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*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" alt="" />
所以我们可以自定义咱们自己的run方法，来被cpu调度。
2：方法
import threading
class myclass(threading.Thread):
def __init__(self,x):
super().__init__()
self.x=x
def run(self):
print(self.x)
if __name__=='__main__':
obj=myclass()
obj.start()
通过我们自定义run方法来覆盖父类中的run方法。
并通过start方法 来让cpu调度我们的线程obj。
如上2个方法的本质是相同的。都是cpu的调度run方法实现。
对比1和2方法，1方法是我们常用的。不推荐第二种方法。
b：队列 queue
import queue q=queue.Queue()##先进先出的队列
q.put()#往队列里放数据。
q.put()
q.put()
print(q.qsize())#队列的长度
print(q.get())#队列取数据。
print(q.qsize())
import queue q=queue.Queue()##先进先出的队列,可以设置队列的长度，默认是没限制。
q.put()#往队列里放数据。
q.put()
print(q.qsize())
q.put(,timeout=)#当队列的数据满了之后，在往里放数据会阻塞，等待队列长度改变。可以设置超时间。超时时间之后，队列的长度没改变，会报错。
print(q.qsize())#队列的长度
print(q.get())#队列取数据。
print(q.qsize()) Traceback (most recent call last):
File "C:/Users/Administrator/PycharmProjects/S12/day11/s3.py", line , in <module>
q.put(,timeout=)#当队列的数据满了之后，在往里放数据会阻塞，等待队列长度改变。可以设置超时间。
File "E:\python3.6\lib\queue.py", line , in put
raise Full
queue.Full
也可以设置放数据不阻塞。参数问block=False 默认该参数是True
import queue q=queue.Queue()##先进先出的队列,可以设置队列的长度，默认是没限制。
q.put()#往队列里放数据。
q.put()
print(q.qsize())
q.put(,block=False)##设置队列不阻塞。
print(q.qsize())#队列的长度
get同样也有这些方法。超时、是否阻塞。
import queue q=queue.Queue()##先进先出的队列,可以设置队列的长度，默认是没限制。
q.put()#往队列里放数据。
q.put()
print(q.get())
print(q.get())#队列取数据。如果队列为空的时候获取数据的话，会阻塞。和get方法一样也可以设置超时间、是否阻塞。
print(q.get(timeout=))
print(q.qsize()) Traceback (most recent call last):
File "C:/Users/Administrator/PycharmProjects/S12/day11/s4.py", line , in <module>
print(q.get(timeout=))
File "E:\python3.6\lib\queue.py", line , in get
raise Empty
queue.Empty
import queue q=queue.Queue()##先进先出的队列,可以设置队列的长度，默认是没限制。
q.put()#往队列里放数据。
q.put()
print(q.get())
print(q.get())#队列取数据。如果队列为空的时候获取数据的话，会阻塞。和get方法一样也可以设置超时间、是否阻塞。
print(q.get(block=False))
print(q.qsize())
其他方法:join和task_done组合使用。
import queue
q=queue.Queue()
q.put()
q.task_done()# 需要在每次取数据的时候告诉队列，这个数据已经完成了。是每次。这样join就不会阻塞了。
q.put()
q.task_done()
q.join()##当队列中有任务的时候，没做处理。该方法会阻塞，知道队列里的任务完成。可以配合task_done方法使用
需要注意：每次取数据需要使用task_done方法来告诉队列这个数据已经完成。
aaarticlea/png;base64,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" alt="" />
qsize，查看当前队列的长度。
get_nowait()实际上调用get(bliock=Flase)
put_nowait()也是调用put(block=Flase)
full()该方法表示检查当前队列是否满，返回是布尔值。
empty()该方法检查当前队列是否空，返回是布尔值。
import queue
q=queue.Queue()#构造方法中maxsize表示队列最大的长度。
q.put()
q.put()
print(q.qsize())## 查看当前队列长度。
print(q.empty())
print(q.full()) False
True
如上的队列是进程在内存里的队列，在python退出的时候队列也清空。
其他队列：如下队列都是queue的基础上操作的，继承queue这个类（除双向队列）。
aaarticlea/png;base64,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" alt="" />
先进后出队列：
import queue q=queue.LifoQueue()##先进后出队列。first in last out
q.put()
q.put()
q.put()
print(q.get())
优先级队列，包含2个参数一个数据，一个是权重值。
import queue
q=queue.PriorityQueue()##权重优先队列，权重值越大，优先级越低。如果权重值一样，取第一个值。
q.put((,))
q.put((,))
q.put((,))
q.put((,))
print(q.get())
(, )
双向队列：可以在队列的两边进行数据的输入和输出。
import queue
q=queue.deque()#双向队列，可以在2边进行取数据和放数据。很多方法和列表类似。
q.append()
q.appendleft()
print(q.pop())
print(q.popleft())
c：消费者和生产者模型：
主要解决了什么？
1：解决程序的阻塞问题。变相提高程序的处理效率和并发。
2：降低程序之间的解耦性。在修改任意一方的程序的时候，减少彼此的影响。
通过什么来实现？
可以通过消息队列，来实现中间的转换过程。
比如一个网站，在客户端同时有大并发的请求时候，可以通过应用程序来获取客户端的请求，并把请求放在消息队列中（这个操作很短，不容易出现阻塞情况。），此时客户端的请求，断开，应用程序把客户端的自动转发到另一个查询页面，这个页面
自动刷新，客户端请求的结果。后端程序在从消息队列中获取客户端的请求，进行处理，并更新数据库信息。当数据库更新成功之后，客户端查询就会显示结果。
好处：
1：降低了程序之间的耦合。
2：一个web请求，到达服务器之后，有后台程序进行处理。如果处理的时间过长，那么这个进程会被挂起，应用服务器会维护这个进程。如果大并发的请求，那么服务端会挂起较多进程，那么服务器会较多的资源浪费，而服务器也会出现hang死或者无效的请求，
因为一个sokcet维护的等待队列是有限，nginx的最大连接也是有限的。而这个模型很好的解决这个问题，他把客户端请求和后台程序处理请求分开。如果客户端请求过多，消息积压，后端可以提高服务器的数量来提高并发，而且这个后台应用程序不会维护客户端连接，
后台程序直接进行有效的请求处理，然后更新数据库，用户只需要查询数据库来验证自己的请求。
import queue
import threading
import time
q=queue.Queue()
def productor(j):
while True:
print('the server %s deal request'%j,q.get())#队列获取消息。
time.sleep() def consumer(i):
q.put(' client NO:%s request'%i)#往队列中放消息。 for i in range():#后台3个程序在处理这个请求。
t=threading.Thread(target=productor,args=(i,))
t.start()
for j in range():
t=threading.Thread(target=consumer,args=(j,))##40个客户端请求。
t.start() the server deal request client NO: request
the server deal request client NO: request
the server deal request client NO: request
the server deal request client NO: request
the server deal request client NO: request
the server deal request client NO: request
......
d：线程锁：
线程是程序运行的最小单位，有时被称为轻量级进程（Lightweight Process，LWP），是程序执行流最小单元。一个标准线程是由线程ID，当前指令指针(pc)，寄存器集合和堆栈组合，另外线程是进程的一个实体，是被系统独立调度和分派的基本单位。
线程不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其他线程共享所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一个进程中的多个线程可以并发执行。由于线程之间的互相制约，致使线程在运行中呈现出间断性。
线程也有就绪、阻塞和运行的三种基本状态。就绪状态是指线程具备运行的所有条件，逻辑上可以运行，等待处理。运行状态是指线程占有cpu正在运行，阻塞状态是指线程在等待一个事件（如某个信号量），逻辑上不可执行。每个程序至少有一个线程，称为主线程。
在单个程序中同时运行多个线程完成不同工作，称为多线程。
基于线程和他的同一个进程所属的其他的线程共享资源，所以会出现以下情况：在多个线程共同对同一个数据进行修改的时候，会出现数据的不一致。
import threading
import time
x=
def f1(): global x
x -=
time.sleep()
print(x) for i in range():
t=threading.Thread(target=f1)
t.start() .......
a：如上所示当多个线程对同一份数据进行修改的话，会出现数据混乱，并不是我们想要的数据。
避免多个线程对同一份数据同一时间进行修改，出现了互斥锁。
互斥锁：当一个线程在对数据进行修改的时候，如果加上互斥锁，只有当前线程执行的“动作”结束之后，下一个线程才可以进行相应的动作。
如下是只允许一个线程加锁和解锁。
import threading
import time
x=
q=threading.RLock()
def f1(): global x
q.acquire()#加锁。递归锁
x -=
time.sleep()
q.release()#解锁。 print(x) for i in range():
t=threading.Thread(target=f1)
t.start()
互斥锁有一次性锁和递归锁（可以锁多次）。上面用的是递归锁，可以锁多层。我们一般用递归锁。如下是一次性锁。
import threading
import time
x=
q=threading.Lock()#一次性锁。
def f1(l): global x
l.acquire()#上锁。
x -=
time.sleep()
l.release()#开锁。 print(x) for i in range():
t=threading.Thread(target=f1,args=(q,))
t.start()
aaarticlea/png;base64,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" alt="" />
b：信号量：同一时间允许多个线程执行同一个动作。而不是上面的只允许单个线程同一时间执行同一个动作。
import threading
import time
x=
q=threading.Semaphore()# 信号量，同一时间允许多少个线程执行相应的动作。
def f1(l,i): global x
l.acquire()#上锁。
x -=
time.sleep()
l.release()#开锁。 print(x,'NO %s thread'%i) for i in range():
t=threading.Thread(target=f1,args=(q,i))
t.start()
NO thread
NO thread
NO thread
NO thread
NO thread
NO thread
NO thread
NO thread
NO thread
NO thread
c：EVENT（事件）：该事件是针对全部线程的动作，不是上面的单个或者多个。类似于红绿灯。红灯都不放行、绿灯都放行。
python线程的事件用于主线程控制其他线程执行，事件主要提供了三个方法：set wait clear。
事件处理机制：实际上python内部维护了一个全局的"flag"，如果flag值为Flase（红灯）（默认是Flase），当执行到even.wait()时候，线程会阻塞。反之如果为True（绿灯）时候，event.wait()方法不会阻塞。
event.wait():检查全局flag值。如果是False，阻塞全部线程。反之放行。
event.clear()主动设置成全局变量为False.默认 值是False
event.set()主动设置全局变量为True。
import threading
import time
x=
e=threading.Event()# 事件，同一时间阻塞所有线程或者同一时间放行所有线程。
def f1(l,i): global x
l.wait()#检查全局flag值。
x -= print(x,'NO %s thread'%i) for i in range():
t=threading.Thread(target=f1,args=(e,i))
t.start()
e.clear()#设置全局标志：flag=Flase 默认值是False。
if __name__=='__main__':
inp=input(">")
if inp=='':
e.set()##将全局标志：flag设置为True
d：Contidition 当满足一定条件时候，放行几个线程。
import threading
con=threading.Condition()#初始化一个Condition实例。 def func(c,i):
print(i)
c.acquire()
c.wait()
print(i+100)
c.release() for i in range(10):
t=threading.Thread(target=func,args=(con,i))
t.start() if __name__=="__main__":
while True:
inp=input('>>')
if inp=='q':
break
con.acquire()##固定语法，如果执行notify必须有acquire和release。
con.notify(int(inp))##表示满足inp不等于q的条件，放行几个线程。
con.release()
0
1
2
3
4
5
6
7
8
9
>>1
>>100
2
>>101
上面：
con.acquire()
con.notify()
con.release()
为固定用法，表示用户输入为数字的时候，通过notify方法通知程序放行几个线程。
也可以根据函数的返回的布尔值来判断是否放行线程如下，每次只放行一个线程：
1 import threading
2 con=threading.Condition()#初始化一个Condition实例。
3
4 def m():
5 inp=input('>')
6 if inp=='1':
7 return True
8 else:
9 return False
10 def func(c,i):
11 print(i)
12 c.acquire()
13 c.wait_for(m)##wait_for()1：可被调用的方法而且需要返回值是布尔型。如果返回为真放行一个线程。反之不放行。
14 print(i+100)
15 c.release()
16
17
18
19 for i in range(10):
20 t=threading.Thread(target=func,args=(con,i))
21 t.start()
e：计数器，表示超时之后开始执行。
1 import threading
2
3 def func():
4 print(100)
5
6
7 t=threading.Timer(2,func)##2表示多久之后执行，func为可执行函数。
8 t.start()
e:线程池：
1：线程的复用，而不是重新创建一个线程。如果任务过多，重复的创建新的线程，上下文的开销（维护线程的开销）较多，资源浪费。
2：当线程池里的线程取完，下一次任务需要等待线程执行完，在执行。
如下是简单版本的多线程：
import threading
import queue
import time class Thread_Poll:
q=queue.Queue()##定义队列。
def __init__(self,maxsize):
self.maxsize=maxsize#定义线程池队列的大小。 def put_thread(self):#往线程池里放线程类。
for i in range(self.maxsize):
Thread_Poll.q.put(threading.Thread) def get_thread(self):#返回一个线程类。
return Thread_Poll.q.get() def task(i):#执行的任务。
print(i)
time.sleep()
Thread_Poll.q.put(threading.Thread)#完成任务，需要补充线程池的线程。 if __name__=="__main__":
obj=Thread_Poll()
obj.put_thread()
for i in range():#执行任务。
t=obj.get_thread()(target=task,args=(i,))
t.start()
更新的第二版：
#!/usr/bin/env python
# -*- coding:utf- -*-
# Author:Alex Li
import queue
import threading
import contextlib
import time StopEvent = object()#赋值。当任务等于他的时候，表示任务执行完毕。 class ThreadPool(object): def __init__(self, max_num, max_task_num = None):
if max_task_num:#任务数。
self.q = queue.Queue(max_task_num)#创建队列，队列的长度为任务数。
else:
self.q = queue.Queue()#如果没有传入，创建一个没有限制的队列。
self.max_num = max_num#线程的最大数。
self.cancel = False#取消线程执行
self.terminal = False#取消线程执行。
self.generate_list = []#保存正在执行任务线程对象的列表。
self.free_list = []#保存空余线程的列表。 def run(self, func, args, callback=None):
"""
线程池执行一个任务
:param func: 任务函数
:param args: 任务函数所需参数
:param callback: 任务执行失败或成功后执行的回调函数，回调函数有两个参数1、任务函数执行状态；、任务函数返回值（默认为None，即：不执行回调函数）
:return: 如果线程池已经终止，则返回True否则None
"""
if self.cancel:#如果cancel=True表示任务执行完。
return
if len(self.free_list) == and len(self.generate_list) < self.max_num:#当没有空闲线程和正在运行的线程数量小于总线程大小。
self.generate_thread()#执行创建线程的方法。
w = (func, args, callback,)#创建一个元组。func任务函数、args表示任务函数参数。callback任务执行完回调函数（任务执行状态successful还是fail以及任务函数的返回值）。
self.q.put(w)#往队列里添加任务。 def generate_thread(self):
"""
创建一个线程，并执行相应的call方法。
"""
t = threading.Thread(target=self.call)
t.start() def call(self):
"""
循环去获取任务函数并执行任务函数
"""
current_thread = threading.currentThread#获取当前的线程。
self.generate_list.append(current_thread)#把当前的线程放在列表中。 event = self.q.get()#获取任务。
while event != StopEvent:#任务不为空即：任务不等StopEvent。 func, arguments, callback = event#赋值。
try:
result = func(*arguments)#执行任务函数。
success = True#执行完，赋值表示执行成功。
except Exception as e:#报错，表示任务执行失败。
success = False
result = None if callback is not None:#任务回调函数不为空。
try:
callback(success, result)#执行回调函数，参数为任务状态以及任务结果。
except Exception as e:#执行回调函数报错的情况处理。
pass with self.worker_state(self.free_list, current_thread):
print(self.terminal)
if self.terminal:
event = StopEvent
else:
event = self.q.get()
else: self.generate_list.remove(current_thread) def close(self):
"""
执行完所有的任务后，所有线程停止
"""
self.cancel = True
full_size = len(self.generate_list)
while full_size:
self.q.put(StopEvent)
full_size -= def terminate(self):
"""
无论是否还有任务，终止线程
"""
self.terminal = True while self.generate_list:
self.q.put(StopEvent) self.q.empty() @contextlib.contextmanager
def worker_state(self, state_list, worker_thread):
"""
用于记录线程中正在等待的线程数
"""
state_list.append(worker_thread)
try:
yield
finally:
state_list.remove(worker_thread) pool = ThreadPool() def callback(status, result):
# status, execute action status
# result, execute action return value
pass def action(i):
print(i) for i in range():
ret = pool.run(action, (i,), callback) # time.sleep()
# print(len(pool.generate_list), len(pool.free_list))
# print(len(pool.generate_list), len(pool.free_list))
更新第三版：
#!/usr/bin/env python
# -*- coding:utf- -*-
# Author:evil_liu
import queue
import threading
import contextlib
import time StopEvent = object()#赋值。当任务等于他的时候，表示任务执行完毕。
RES_LIST=[]
class ThreadPool():
count=
lock=threading.RLock()#线程锁
def __init__(self, max_num, max_task_num):
self.max_task_num=max_task_num# 任务计数。
if max_task_num:#任务数。
self.q = queue.Queue(max_task_num)#创建队列，队列的长度为任务数。
else:
self.q = queue.Queue()#如果没有传入，创建一个没有限制的队列。
self.req=queue.Queue(max_task_num)##结果队列。
self.max_num = max_num#线程的最大数。
self.cancel = False#取消线程执行
self.terminal = False#取消线程执行。
self.generate_list = []#保存正在执行任务线程对象的列表。
self.free_list = []#保存空余线程的列表。 def run(self, func, args, callback=None):
"""
线程池执行一个任务
:param func: 任务函数
:param args: 任务函数所需参数
:param callback: 任务执行失败或成功后执行的回调函数，回调函数有两个参数1、任务函数执行状态；、任务函数返回值（默认为None，即：不执行回调函数）
:return: 如果线程池已经终止，则返回True否则None
"""
if self.cancel:#如果cancel=True表示任务执行完。
return
if len(self.generate_list) < self.max_num:#当没有空闲线程和正在运行的线程数量小于总线程大小。
self.generate_thread()#执行创建线程的方法。
w = (func, args, callback,)#创建一个元组。func任务函数、args表示任务函数参数。callback任务执行完回调函数（任务执行状态successful还是fail以及任务函数的返回值）。
self.q.put(w)#往队列里添加任务。 def generate_thread(self):
"""
创建一个线程，并执行相应的call方法。
"""
t = threading.Thread(target=self.call)
t.start() def call(self):
"""
循环去获取任务函数并执行任务函数
"""
current_thread = threading.currentThread#获取当前的线程。
self.generate_list.append(current_thread)#把当前的线程放在列表中。 event = self.q.get()#获取任务。
while event != StopEvent:#任务不为空即：任务不等StopEvent。 func, arguments, callback = event#赋值。
# if ThreadPool.count <= self.max_task_num:
try:
result = func(*arguments)#执行任务函数。
success = True#执行完，赋值表示执行成功。
except Exception as e:#报错，表示任务执行失败。
success = False
result = None
if callback is not None:#任务回调函数不为空。
try:
callback(success, result)#执行回调函数，参数为任务状态以及任务结果。
except Exception as e:#执行回调函数报错的情况处理。
pass try:
event = self.q.get(timeout=)#获取数据超时。超时之后表示任务执行完成。
except queue.Empty as e:
self.generate_list.remove(threading.currentThread)##释放线程
break
def close(self):
"""
执行完所有的任务后，
"""
self.cancel = True
full_size = self.max_num
while full_size:
self.q.put(StopEvent)
full_size -= pool = ThreadPool(,)
# lock_1=threading.RLock()
def callback(status, result):
pass def action(i):
print("Now mssion is %s"%i)
time.sleep()
return True for i in range():
ret = pool.run(action, (i,), callback)
time.sleep()
print(len(pool.generate_list))
终极版：
#!/bin/env python
#author:evil_liu
#date:--
#description: thread pool import threading
import time
import queue class Thread_Poll:
'''
功能：该类主要实现多线程，以及线程复用。
'''
def __init__(self,task_num,max_size):
'''
功能：该函数是初始化线程池对象。
:param task_num: 任务数量。
:param max_size: 线程数量。
:return:无。
'''
self.task_num=task_num
self.max_size=max_size
self.q=queue.Queue(task_num)#设置任务队列的。
self.thread_list=[]
self.res_q=queue.Queue()#设置结果队列。 def run(self,func,i,call_back=None):
'''
功能：该函数是线程池运行主函数。
:param func: 传入任务主函数。
:param *args: 任务函数参数，需要是元组形式。
:param call_back: 回调函数。
:return: 无。
'''
if len(self.thread_list)<self.max_size:#如果目前线程数小于我们定义的线程的个数，进行创建。
self.creat_thread()
misson=(func,i,call_back)#往任务队列放任务。
self.q.put(misson) def creat_thread(self):
'''
功能：该函数主要是创建线程，并调用call方法。
:return: 无。
'''
t=threading.Thread(target=self.call)
t.start() def call(self):
'''
功能：该函数是线程循环执行任务函数。
:return: 无。
'''
cur_thread=threading.currentThread
self.thread_list.append(cur_thread)
event=self.q.get()
while True:
func,args,cal_ba=event#获取任务函数。
try:
res=func(*args)#执行任务函数。注意参数形式是元组形式。
flag="OK"
except Exception as e:
print(e)
res=False
flag="fail"
# print(flag)
self.res(res,flag)#调用回调函数，将执行结果返回到队列中。
try:
event=self.q.get(timeout=)#如果任务队列为空，获取任务超时2s超过2s线程停止执行任务，并退出。
except Exception:
self.thread_list.remove(cur_thread)
break
def res(self,res,status):
'''
功能：该方法主要是将执行结果方法队列中。
:param res: 任务函数的执行结果。
:param status: 执行任务函数的结果，成功还是失败。
:return: 无。
'''
da_res=(res,status)
self.res_q.put(da_res) def task(x,y):
'''
功能：该函数主要需要执行函数。
:param x: 参数。
:return: 返回值1，表示执行成功。
'''
print(x)
return x+y
def wri_fil(x):
'''
功能：该函数主要讲结果队列中的结果写入文件中。
:param x: 任务长度。
:return: 无。
'''
while True:#将执行结果，从队列中获取结果并将结果写入文件中。
time.sleep()
if pool.res_q.qsize()==x:#当队列当前的长度等于任务执行次数，表示任务执行完成。
with open('1.txt','w') as f1:
for i in range(pool.res_q.qsize()):
try:
data=pool.res_q.get(timeout=)
f1.write('mission result:%s,status:%s\n'%data)
except Exception:
break
break
else:
continue
if __name__ == '__main__':
pool=Thread_Poll(,)#初始化线程池对象。
for i in range():#循环任务。
pool.run(task,(,))
wri_fil()
以上版本在window pycharm运行有时候出现程序hang住无法结束。但是linux测试没有这个问题。
f:进程：
执行脚本的时候，别在window下创建多进程，因为python是调用os.fork创建，而window不支持，想执行需要用：if __name__=="__main__".
a：多进程的创建：
import multiprocessing def test(x):
print(x) if __name__ == '__main__':
p=multiprocessing.Process(target=test,args=(,))
p.start()
import multiprocessing
import time
def test(x):
time.sleep()
print(x) if __name__ == '__main__':
for i in range():
p=multiprocessing.Process(target=test,args=(i,))
p.start()
p.join()#这个参数的意思是：进程在这等待6秒，6秒之后就往下执行代码，后面的代码执行完，不终止。等待子进程执行完。不加该参数默认会等待进程执行完。
print('ok')
daemon=True表示进程不等待子进程执行完。结束程序。
import multiprocessing
import time
def test(x):
time.sleep()
print(x) if __name__ == '__main__':
for i in range():
p=multiprocessing.Process(target=test,args=(i,))
p.daemon = True##注意位置，在start之前。
p.start()
print('ok')
b:进程之间的数据共享：
进程之间数据不共享，单独维护一个块系统资源（内存空间.....）来维护自己的数据资源。
import multiprocessing
LI=[]
def test(x,li):
li.append(x)
print(li) if __name__ == '__main__':
for i in range():
p=multiprocessing.Process(target=test,args=(i,LI))
p.start()
[]
[]
数据共享可以用如下：Queue方法可以构造特殊的数据，该方法包含put、get等。
import multiprocessing
from multiprocessing.queues import Queue
li=Queue(,ctx=multiprocessing)
def test(y,x):
y.put(x)
print(y.qsize()) if __name__ == '__main__':
for i in range():
p=multiprocessing.Process(target=test,args=(li,i))
p.start()
c:Array() 数组的方法。来构建进程共享数据：不常用。
1）数组需要指定类型。
'c': ctypes.c_char, 'u': ctypes.c_wchar,
'b': ctypes.c_byte, 'B': ctypes.c_ubyte,
'h': ctypes.c_short, 'H': ctypes.c_ushort,
'i': ctypes.c_int, 'I': ctypes.c_uint,
'l': ctypes.c_long, 'L': ctypes.c_ulong,
'f': ctypes.c_float, 'd': ctypes.c_double 类型对应表
2）数组需要指定长度。
import multiprocessing def test(x,y):
x[y]=y+
for i in x:
print(i)
print("------------------") li=multiprocessing.Array('i',)
if __name__ == '__main__':
for i in range():
p=multiprocessing.Process(target=test,args=(li,i))
p.start()
在大多数语言中：数组类型的数据，在内存中是连续的一块内存，需要指定数据的大小、类型（类型的不同的占有的位置大小也不一样，需要提前指定。）python 的列表，具有可扩展、伸缩。在内存中的数据块地址是不连续的。是因为在内存中，内存数据块是通过链表的形式进行查看。
就是说一个数据记录上个数据的内存地址和下个数据的内存地址。这样的方式进行查找。
常用的方式：用multiprocessing模块的Manger()方法，使用字典形式的进行数据更改，没有数据类型的限制。
import multiprocessing def test(x,y):
x[y]=y+
for i in x.items():
print(i)
print("------------------")
obj=multiprocessing.Manager()
t=obj.dict()
# li=multiprocessing.Array('i',)
if __name__ == '__main__':
for i in range():
p=multiprocessing.Process(target=test,args=(t,i))
p.start()
p.join()##注意：需要加join等待子进程执行完。因为修改的是主进程的数据，主进程需要和子进程进行socket链接。如果不等子进程执行完，就执行子进程。会导致主进城和子进程通讯出现问题。
(, )
------------------
(, )
(, )
------------------
(, )
(, )
(, )
------------------
(, )
(, )
(, )
(, )
------------------
c:进程锁。
当进程的数据进行共享的时候，多个进程操作共享数据之后，获得数据的结果会出现混乱。
import multiprocessing
import time
LOCK=multiprocessing.Lock()
def test(x,l):
x[]-=
time.sleep()
print(x[])
obj=multiprocessing.Manager()
t=obj.dict()
if __name__ == '__main__':
t[]=
for i in range():
p=multiprocessing.Process(target=test,args=(t,LOCK))
p.start()
p.join()#####################注意join位置。
import multiprocessing
import time
LOCK=multiprocessing.Lock()
def test(x,l):
x[]-=
time.sleep()
print(x[])
obj=multiprocessing.Manager()
t=obj.dict()
if __name__ == '__main__':
t[]=
for i in range():
p=multiprocessing.Process(target=test,args=(t,LOCK))
p.start()
p.join()####################这个位置就是逐个执行。
加锁：同样进程也有进程普通锁、递归锁、event、condition等。和线程使用的方式类同！
import multiprocessing
import time
LOCK=multiprocessing.Lock()
def test(x,l):
x[]-=
time.sleep()
print(x[])
obj=multiprocessing.Manager()
t=obj.dict()
if __name__ == '__main__':
t[]=
for i in range():
p=multiprocessing.Process(target=test,args=(t,LOCK))
p.start()
p.join()
import multiprocessing
import time
LOCK=multiprocessing.Semaphore()##信号量。 def test(x,l):
LOCK.acquire()
x[]+=
time.sleep()
l.release()
print(x[])
obj=multiprocessing.Manager()
t=obj.dict()
t[]=
if __name__ == '__main__':
for i in range():
p=multiprocessing.Process(target=test,args=(t,LOCK))
p.start()
p.join()
event：
import multiprocessing
e=multiprocessing.Event() def test(x,l):
x[]+=
l.wait()
print(x[])
obj=multiprocessing.Manager()
t=obj.dict()
t[]=
for i in range():
p=multiprocessing.Process(target=test,args=(t,e))
p.start()
if __name__ == '__main__':
inp=input(">")
if inp=='':
e.set()
>
conditon()
import multiprocessing
e=multiprocessing.Condition() def test(x,l):
l.acquire()
l.wait()
x[]+=
print(x[])
l.release()
obj=multiprocessing.Manager()
t=obj.dict()
t[]=
for i in range():
p=multiprocessing.Process(target=test,args=(t,e))
p.start()
if __name__ == '__main__':
inp=input(">")
while True:
if inp!='q':
e.acquire()
e.notify(int(inp))
e.release()
d:进程池。
进程multiprocessing给我们提供了相应的方法。分别为：appy方法、app_async方法。
appy方法：并不是并发执行任务，而是当前进程执行完，才执行下个，串行执行。
import multiprocessing
import time def task(args):
time.sleep()
print(args) pool=multiprocessing.Pool()##初始化5个进程。
if __name__ == '__main__':
for i in range():
pool.apply(func=task,args=(i,))#从进程调用一个进程执行任务。
print("_____end_____") _____end_____
app_async()异步执行（从队列获取任务，执行任务。），这个比较常用。可以看做是并发执行任务。
import multiprocessing
import time def task(args):
time.sleep()
print(args) pool=multiprocessing.Pool()##初始化5个进程。
if __name__ == '__main__':
for i in range():
pool.apply_async(func=task,args=(i,))#从进程调用一个进程执行任务。
pool.close()##执行close或者terminal方法，要不然会报断言错误。terminnal方法表示任务立即终止。
pool.join()#主进程等待子进程执行完任务。
print("_____end_____")
协程：
原理：多线程、多进程是系统执行的。而协程是程序员”操纵“。将一个线程分解成多个“微线程”，执行不同的任务。比如说：多次URL请求。每次URL请求耗时3S。如果用多线程执行的话，会出现资源浪费（维护、等待3s），可以用协程，我们可以让线程循环执行url请求，而不是在等待执行结果。也就说。可以在等待的同时执行其他的任务。
aaarticlea/png;base64,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" alt="" />
通过gevnet和greenlet方法执行。genvent是对greenlet的封装，底层还是调用greenlet。
安装：pip install gevent（安装这个自动安装greenlet）
from greenlet import greenlet def test1():
print()
gr2.switch()
print()
gr2.switch() def test2():
print()
gr1.switch()
print() gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch()
如上代码：当执行到gr1.switch()的时候，会执行test1函数，执行到test1函数到gr2.switch()的时候执行test2， 遵循这个规则依次执行下去。也就是说通过greenlet来控制线程的执行流。
import gevent def foo():
print('Running in foo')
gevent.sleep()#执行切换。
print('Explicit context switch to foo again') def bar():
print('Explicit context to bar')
gevent.sleep()#执行切换。
print('Implicit context switch back to bar') gevent.joinall([
gevent.spawn(foo),
gevent.spawn(bar),
])##创建协程。
Running in foo
Explicit context to bar
Explicit context switch to foo again
Implicit context switch back to bar
IO操作：执行http请求。
from gevent import monkey; monkey.patch_all()
import gevent
import requests def f(url):
print('GET: %s' % url)
resp = requests.get(url)
data = resp.text
print('%d bytes received from %s.' % (len(data), url)) gevent.joinall([
gevent.spawn(f, 'https://www.python.org/'),
gevent.spawn(f, 'https://www.yahoo.com/'),
gevent.spawn(f, 'https://github.com/'),
])#创建协程、循环执行这个url
GET: https://www.python.org/
GET: https://www.yahoo.com/
GET: https://github.com/
bytes received from https://www.python.org/.
bytes received from https://github.com/.
bytes received from https://www.yahoo.com/.
monkey.patch_all()
底层封装socket，具有可以让线程可以一边执行url请求，一边可以收到url请求的结果。
应用场景：在python爬虫框架：scrapy就是用协程（gevent）来实现的，比较高效。
url存活检测（上线之后检测url的存活情况）。
一旦涉及到IO操作，比如http请求，gevent执行效率很高。
缓存：
本质：python通过socket连接服务端（缓存端）通过端口，建立连接 ，在服务端执行相应的命令。
安装memcache：
1：
wget http://memcached.org/latest
yum install -y libevent-devel.x86_64#64位操作系统。
./configure
make && make install
虚拟机用的是网易的源。yum配置文件：
[base_server]
name=base_server
baseurl=http://mirrors.163.com/centos/6.8/os/x86_64/
enabled=
gpgcheck=
启动：
memcached -d -m -u root -p -c -P /tmp/memcached.pid
参数说明：
参数说明:
-d 是启动一个守护进程
-m 是分配给Memcache使用的内存数量，单位是MB
-u 是运行Memcache的用户
-l 是监听的服务器IP地址
-p 是设置Memcache监听的端口,最好是1024以上的端口
-c 选项是最大运行的并发连接数，默认是1024，按照你服务器的负载量来设定
-P 是设置保存Memcache的pid文件
memcache处理的数据类型：
a)key value形式：
#!/usr/bin/env python
#-*-coding:utf--*-
# author:liumeide
import memcache mc = memcache.Client(['192.168.1.104:11211'], debug=True)
mc.set("OK", "evil")#设置键值对。
ret = mc.get('OK')#获取键值对。
print(ret)
evil
debug=True:表示运行过程中如果出现错误，显示错误信息。
b)支持集群操作：
python-memcached模块原生支持集群操作，其原理是在内存维护一个主机列表，且集群中主机的权重值和主机在列表中重复出现的次数成正比
主机 权重
10.10.1.1
10.10.1.2
10.10.1.3 那么在内存中主机列表为：
host_list = ["10.10.1.1", "10.10.1.2", "10.10.1.2", "10.10.1.3", ]
如果用户根据如果要在内存中创建一个键值对（如：k1 = "v1"），那么要执行一下步骤：
- 根据算法将 k1 转换成一个数字
- 将数字和主机列表长度求余数，得到一个值 N（ 0 <= N < 列表长度 ）
- 在主机列表中根据 第2步得到的值为索引获取主机，例如：host_list[N]
- 连接 将第3步中获取的主机，将 k1 = "v1" 放置在该服务器的内存中
aaarticlea/png;base64,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" alt="" />
代码实现如下：
mc = memcache.Client([('10.10.10.1:12000', ), ('10.10.1.2:12000', ), ('10.10.1.3:12000', )], debug=True)
mc.set('key1', 'value1')
c) add 添加一条键值对，如果有报错：MemCached: while expecting 'STORED', got unexpected response 'NOT_STORED'
mc = memcache.Client(['192.168.1.104:11211'], debug=True)
mc.add("ok", "tom")#添加键值对。
ret = mc.get('ok')#获取键值对。
print(ret)
tom
d)replace修改某个键值对。如果不存在报异常：MemCached: while expecting 'STORED', got unexpected response 'NOT_STORED'
import memcache mc = memcache.Client(['192.168.1.104:11211'], debug=True)
mc.replace("ok", "come")#添加键值对。
ret = mc.get('ok')#获取键值对。
print(ret)
come
e)set修改键值对，如果不存在话创建，存在的话进行修改，这个一对一。set_multi 是对多个键值对进行修改。注意多个时候，里面放的是字典key:value。
import memcache mc = memcache.Client(['192.168.1.104:11211'], debug=True)
mc.set("", "come")#如果存在，修改，不存在创建。
mc.set_multi({"ok": "bye","cc":})#如果存在，修改，不存在创建。
ret = mc.get('ok')#获取键值对。
ret1 = mc.get('')#获取键值对。
print(ret,ret1)
bye come
f) delet delet_multi删除键值对，删除多个键值对。需要注意删除里面是key值而且是列表。
import memcache mc = memcache.Client(['192.168.1.104:11211'], debug=True)
mc.delete("")#如果存在，修改，不存在创建。
mc.delete_multi(["ok","cc"])#如果存在，修改，不存在创建
g) get 和get_multi获取键值对、多个键值对。
import memcache mc = memcache.Client(['192.168.1.104:11211'], debug=True)
mc.set("", "come")#如果存在，修改，不存在创建。
mc.set_multi({"ok": "bye","cc":})#如果存在，修改，不存在创建。。
ret = mc.get('ok')#获取键值对。
ret1 = mc.get_multi(['','ok'])#获取多个键值对。
print(ret,ret1)
bye {'': 'come', 'ok': 'bye'}
h)append 和 prepend，append在修改指定的key值，在该值的后面追加内容，prepend则相反。
mc.append("",)
ret=mc.get("")
print(ret)
come22
mc.prepend("",)
ret=mc.get("")
print(ret)
22come22
i）decr和incr 将memcache中的一个值减少（默认是1）或者增加
ret=mc.get("cc")
mc.decr("cc")
ret1=mc.get("cc")
print(ret,ret1)
ret=mc.get("cc")
mc.incr("cc",)
ret1=mc.get("cc")
print(ret,ret1)
j)cas和gets
比如说：我们在淘宝进行抢购商品的时候，没抢购一次，相应的存货应该自减，但是如果在相同时间内程序获取相同的存货数据，修改提交。在memcache中，会出现数据的不一致。
这样导致数据的混乱，cas和gets就是解决这个问题。类似线程的互斥锁的作用，memcache内部：每当程序来获取数据的时候，返回当前一个数字和对应的键值，当用户提交修改的时候。
memcache会把当前的数字和程序提交的数字进行比对，如果相等，说明这段时间内没有程序进行修改，如果不相等，提交失败。修改不了。
v=mc.gets("cc")
time.sleep()
#在gets和cas之间如果有提交数据，在下面的cas不成功。我测试没出现异常？也正常修改。。。。
mc.cas("cc",)
安装redis
wget http://download.redis.io/releases/redis-3.0.6.tar.gz
tar xvzf redis-3.0..tar.gz
cd redis-3.0.
make PREFIX=/export/server/redis install
启动：
nohup /export/server/redis/bin/redis-server &
安装API：
pip.exe install redis
redis针对数据类型：
1：字符串string.
2:hash 操作。
3：列表操作。
4：集合操作。
5：排序操作，比如说：([(11,1),(12,2)])根据后面第二值进行操作。
6：管道
7：发布订阅
a)操作：
添加值：
import redis rc=redis.Redis(host="192.168.1.104",port=)
rc.set("test","ok")
v=rc.get("test")
print(str(v,encoding="utf-8"))
ok
注意：返回的结果是字节！！！！
b)连接方式：连接池
redis-py使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。默认，每个Redis实例都会维护一个自己的连接池。可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池
import redis pool = redis.ConnectionPool(host='192.168.1.104', port=)
r = redis.Redis(connection_pool=pool)
r.set('ok', '')
print(str(r.get('ok'),encoding="utf-8"))
c)操作：
字符串：redis中。字符串是按照一个name对应一个value来存储。
aaarticlea/png;base64,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" alt="" />
set(name, value, ex=None, px=None, nx=False, xx=False)
在Redis中设置值，默认，不存在则创建，存在则修改
参数：
ex，过期时间（秒）
px，过期时间（毫秒）
nx，如果设置为True，则只有name不存在时，当前set操作才执行
xx，如果设置为True，则只有name存在时，岗前set操作才执行
设置过期时间：
import redis pool = redis.ConnectionPool(host='192.168.1.104', port=)
r = redis.Redis(connection_pool=pool)
r.setex('ok', '',)
print(str(r.get('ok'),encoding="utf-8"))
mset(*args, **kwargs) 批量设置
批量设置值
如：
mset(k1='v1', k2='v2')
或
mget({'k1': 'v1', 'k2': 'v2'})
import redis pool = redis.ConnectionPool(host='192.168.1.104', port=)
r = redis.Redis(connection_pool=pool)
r.mset(a="",b="")
print(str(r.get("a"),encoding="utf-8"))
mget(keys, *args)批量获取值
批量获取
如：
mget('ylr', 'xi')
或
r.mget(['ylr', 'x'])
append(key, value)
# 在redis name对应的值后面追加内容 # 参数：
key, redis的name
value, 要追加的字符串
incrbyfloat(self, name, amount=1.0)
# 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。 # 参数：
# name,Redis的name
# amount,自增数（浮点型）
decr(self, name, amount=1)
# 自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减。 # 参数：
# name,Redis的name
# amount,自减数（整数）
Hash操作:
存储：如下图：
aaarticlea/png;base64,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" alt="" />
hset(name, key, value)
# name对应的hash中设置一个键值对（不存在，则创建；否则，修改） # 参数：
# name，redis的name
# key，name对应的hash中的key
# value，name对应的hash中的value # 注：
# hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建（相当于添加）
hmset(name, mapping)
# 在name对应的hash中批量设置键值对 # 参数：
# name，redis的name
# mapping，字典，如：{'k1':'v1', 'k2': 'v2'} # 如：
# r.hmset('xx', {'k1':'v1', 'k2': 'v2'})
hget(name,key)
# 在name对应的hash中获取根据key获取value
hmget(name, keys, *args)
# 在name对应的hash中获取多个key的值 # 参数：
# name，reids对应的name
# keys，要获取key集合，如：['k1', 'k2', 'k3']
# *args，要获取的key，如：k1,k2,k3 # 如：
# r.mget('xx', ['k1', 'k2'])
# 或
# print r.hmget('xx', 'k1', 'k2')
List操作：
aaarticlea/png;base64,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" alt="" />
lpush(name,values)
# 在name对应的list中添加元素，每个新的元素都添加到列表的最左边 # 如：
# r.lpush('oo', ,,)
# 保存顺序为: ,, # 扩展：
# rpush(name, values) 表示从右向左操作
import redis pool = redis.ConnectionPool(host='192.168.1.104', port=)
r = redis.Redis(connection_pool=pool)
r.lpush("oo",[,,])
lpushx(name,value)
# 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边 # 更多：
# rpushx(name, value) 表示从右向左操作
import redis pool = redis.ConnectionPool(host='192.168.1.104', port=)
r = redis.Redis(connection_pool=pool)
# r.lpush("oo",[,,])
r.lpush("oo",)
llen(name)
# name对应的list元素的个数
import redis pool = redis.ConnectionPool(host='192.168.1.104', port=)
r = redis.Redis(connection_pool=pool)
r.lpushx("oo",)
print(r.llen("oo"))
linsert(name, where, refvalue, value))
# 在name对应的列表的某一个值前或后插入一个新值 # 参数：
# name，redis的name
# where，BEFORE或AFTER
# refvalue，标杆值，即：在它前后插入数据
# value，要插入的数据
r.lset(name, index, value)
# 对name对应的list中的某一个索引位置重新赋值 # 参数：
# name，redis的name
# index，list的索引位置
# value，要设置的值
r.lrem(name, value, num)
# 在name对应的list中删除指定的值 # 参数：
# name，redis的name
# value，要删除的值
# num， num=，删除列表中所有的指定值；
# num=,从前到后，删除2个；
# num=-,从后向前，删除2个
import redis pool = redis.ConnectionPool(host='192.168.1.104', port=)
r = redis.Redis(connection_pool=pool)
r.lrem("oo",,-)
print(r.llen("oo"))
常用操作：
delete(*names)：根据删除redis中的任意数据类型
exists(name)：检测redis的name是否存在
keys(pattern='*')：
# 根据模型获取redis的name # 更多：
# KEYS * 匹配数据库中所有 key 。
# KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
# KEYS h*llo 匹配 hllo 和 heeeeello 等。
# KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo
expire(name ,time)：为某个redis的某个name设置超时时间
rename(src, dst)： 对redis的name重命名为
move(name, db))： 将redis的某个值移动到指定的db下
randomkey()：随机获取一个redis的name（不删除）
type(name)： 获取name对应值的类型
scan(cursor=0, match=None, count=None)
scan_iter(match=None, count=None)
同字符串操作，用于增量迭代获取key
c:管道：
如果在redis操作中，执行多个命令的时候可以用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。
import redis
pool = redis.ConnectionPool(host='192.168.1.104', port=)
r = redis.Redis(connection_pool=pool)
pipe = r.pipeline(transaction=True)
r.set('test', 'ok')
r.set('test1', 'cc')
print(r.get("test"))
print(r.get("test1"))
pipe.execute()
b'ok'
b'cc'
d：发布订阅：
aaarticlea/png;base64,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" alt="" />
小样：
#!/usr/bin/env python
# -*- coding:utf- -*- import redis class RedisHelper: def __init__(self):
self.__conn = redis.Redis(host='10.211.55.4')
self.chan_sub = 'fm104.5'
self.chan_pub = 'fm104.5' def public(self, msg):
self.__conn.publish(self.chan_pub, msg)
return True def subscribe(self):
pub = self.__conn.pubsub()
pub.subscribe(self.chan_sub)
pub.parse_response()
return pub
订阅者：
#!/usr/bin/env python
# -*- coding:utf- -*- from monitor.RedisHelper import RedisHelper obj = RedisHelper()
redis_sub = obj.subscribe() while True:
msg= redis_sub.parse_response()
print msg
发布者：
#!/usr/bin/env python
# -*- coding:utf- -*- from monitor.RedisHelper import RedisHelper obj = RedisHelper()
obj.public('hello')
更多redis和memcache 操作：http://www.cnblogs.com/wupeiqi/articles/5132791.html