Python_Note_Day 9_threading.Thread_multiprocessing.Process_Queue

 Python多线程 不适合cpu密集操作型的任务，适合io操作密集型任务。

 注1：如果是I/O操作密集型，就用多线程，如果计算密集型，就用多进程去处理。

注2：进程之间不能资源共享，但线程间可以资源共享。

注3：线程只能自己控制线程数量，而多进程，则可以放入一个进程池里，可以控制线程的数量。所以可以利用Queue来控制线程的数量。

内容：

一、线程

二、进程

三、队列

一、协程

A,B,C进程依次请求CPU计算：

1. 单CPU，多进程，分片式循环执行多个进程。

A->B->C

2. 单CPU，多核，多进程，每个逻辑的核分片式循环行执行多个进程。现在物理最多18个核，逻辑最多36个核。

CPU CORE1: A1->B2->C1

CPU CORE2: B1->A2->A3

  

3. 多CPU，多核，多个进程，每个进程中多线程，每CPU的每个逻辑核循环分片行执行多个进程中的多个线程。进程A的多线程可在多CPU的多核上并行执行。

CPU1 CORE1: A1->B2

CPU2 CORE1: B1->C2

CPU1 CORE2: A2

CPU2 CORE2: C1

 

线程锁（Lock、RLock）

由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，当多个线程同时修改同一条数据时可能会出现脏数据，所以，出现了线程锁 - 同一时刻允许一个线程执行操作。（所以说，Python是假线程，同一时刻，cpu只能运行一个线程。但是在处理I/O操作时，Python线程的并发，还是比串行要快，因为在大量的I/O操作的时候，线程并发且不太占用CPU资源，无需等待（虽只能一次只能运行一个线程，但cpu的资源在进程中多线程共享），而串行的进程，cpu资源不能共享，要等待上一个进程运行等待完I/O操作，在进行下一个进程。20个线程，每个进程等待1s，等待时间是1s，而20个进程，等待时间是20s）==>I/O操作密集型，用线程，CPU密集型，用进程。

防止锁的功能是：即使在一个进程里有多个线程，要求只有一个线程被读出来，其他等待。（只有一个线程能被一个CPU核调用。）

解决方案：创建多个相同的进程，让多个进程中的不同线程被多个CPU调用。

缺点：线程是可以共享一个进程内的资源，但多进程之间是不能共享内存资源的。造成内存浪费。

 

 

1. 基本的多线程：

threading.Thread模块

• start()　　　　#线程准备就绪，等待CPU调度
• getName()　　#获取线程名称
• setName()　　#为线程设置名称
• isDaemon()
• setDaemon()　　#设置为后台线程或前台线程（默认）                 

                   　　　　如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止
                    　　　　如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止

• join(timeout)　  #逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义
• run()　　　　　#线程被cpu调度后自动执行线程对象的run方法　

 Thread执行过程：

1. 创建实例，执行构造函数，并把target和args赋值到Thread的构造函数中。

2. 调用了start方法。

3. run操作被触发时，执行了target方法（target方法是从Thread调用的方法）。

直接调用

import threading
import time

def run(n):　　　　　　　　　　　　#run的名字可以换
　　print("running %s" %n)

for i in range(10):
　　t = threading.Thread(target=run, args=(i,))　　　#逗号很重要，当只有一个参数时，一定加逗号才能正确解析出它是元组。
　　t.start()

print('finished')

#Outcome:

/usr/bin/python3.5 "/home/tlfox/PycharmProjects/PyScr/Day 9/Thread03.py"
running 0
running 1
running 2
running 3
running 4
running 5
running 6
running 7
running 8
finished

running 9　　#子线程和主线程是并列执行的。有时子线程执行比主线程慢

继承式调用

import threading
import time 
 
class MyThread(threading.Thread):
    def __init__(self,num):
        threading.Thread.__init__(self)   #继承threading.Thread函数，也可以写成：super(MyThread,self).__init__(self)     
        self.num = num
 
    def run(self):                        #定义每个线程要运行的函数 
        print("running on number:%s" %self.num)
 
        time.sleep(3)
 
if __name__ == '__main__':
 
    t1 = MyThread(1)
    t2 = MyThread(2)
    t1.start()
    t2.start()        

　　 

2. join：

import threading
import time

def run(n):
　　print("running %s" %n)
　　time.sleep(1)
　　print('task done')

t_res = []
for i in range(10):
　　t = threading.Thread(target=run, args=(i,))
　　t.setDaemon(True)　　　　　　　　　　　　
　　t.start()
　　t_res.append(t)
　　#print('starting thread', t.getName())

for k in t_res:
18 　　k.join()　　　　#等待线程结束 ，即使设置了守护进程，但是有了join()，就会等待子线程实行完后，再去执行主线程。k.join（5）等待5秒。
19 print('finished')

#outcome:

/usr/bin/python3.5 "/home/tlfox/PycharmProjects/PyScr/Day 9/Thread03.py"
running 0
running 1
running 3
running 4
running 2
running 5
running 6
running 7
running 8
running 9
task done
task done
task done
task done
task done
task done
task done
task done
task done
task done　　　　#必须等待所有线程都执行完，再执行主程序。
finished 

3. setDaemon：

import threading
import time

def run(n):
　　print("running %s" %n)
　　time.sleep(1)
　　print('task done')

t_res = []
for i in range(10):
　　t = threading.Thread(target=run, args=(i,))
　　t.setDaemon(True)　　　　#守护进程，当主进程结束，子进程也随之结束。默认情况下，守护进程是false。可以用isDaemon()来查看。
　　t.start()
　　t_res.append(t)
15 print('finished')

#outcomes：

/usr/bin/python3.5 "/home/tlfox/PycharmProjects/PyScr/Day 9/Thread03.py"
running 0
running 1
running 2
running 3
running 4
running 5
running 6
running 7
running 8
running 9
finished　　　　#主程序结束了，子线程就会结束，不会再继续进行了。task done将无法再打印。

 4. run（）

from threading import Thread
import time
class MyThread(Thread):　　　　　　#继承Thread的构造函数（__init__()）
    def run(self):
        time.sleep(10)
        print(‘I am a Thread’)

def Bar():
    print('bar')

t1 = MyThread(target = Bar)　　　#执行了Thread的构造函数，并将bar赋值给了Thread构造函数__target（self.__target=target（__xx为私有字段，只能在函数内部调用。））。
t1.start()
print('over')

#Outcome: 

5. Mutex Locks

注：不要在3.x上运行，不知为什么，3.x上的结果总是正确的，可能是自动加了锁

import time
import threading
 
def addNum():
    global num 　　　　　#在每个线程中都获取这个全局变量
    print('--get num:',num )
    time.sleep(1)
    lock.acquire() 　　 #修改数据前加锁
    num  -=1 　　　　　　#对此公共变量进行-1操作
    lock.release()　　　#修改后释放 　　
 
num = 100  　　　　　　  #设定一个共享变量
thread_list = []
lock = threading.Lock() #生成全局锁
for i in range(100):
    t = threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)
 
for t in thread_list:  #等待所有线程执行完毕
    t.join()
 
print('final num:', num )

6. 信号量（Semaphore）

互斥锁 同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据 ，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。

import threading,time
 
def run(n):
    semaphore.acquire()
    time.sleep(1)
    print("run the thread: %s" %n)
    semaphore.release()
 
if __name__ == '__main__':
    num= 0
    semaphore  = threading.BoundedSemaphore(5) #最多允许5个线程同时运行
    for i in range(20):
        t = threading.Thread(target=run,args=(i,))
        t.start()

 7.事件（event）: traffic_light

python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法 set、wait、clear。

事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，如果“Flag”值为True，那么event.wait 方法时便不再阻塞。

• clear：将“Flag”设置为False
• set：将“Flag”设置为True

import threading,time

def traffic_light():
　　counter = 0
　　event.set()
　　while True:
　　　　if counter < 10:
　　　　　　print('green light')
　　　　elif counter < 13:
　　　　　　print('yellow light')
　　　　elif counter < 20:
　　　　　　if event.is_set():
　　　　　　　　event.clear()
　　　　　　print('red light')
　　　　else:
　　　　　　counter = 0
　　　　　　event.set()
　　　　time.sleep(1)
　　　　counter += 1

def car(name):
　　while True:
　　if event.is_set():
　　　　print("car[%s] is running" %name)
　　else:
　　　　print("car[%s] is waiting" %name)
　　time.sleep(0.5)

if __name__ == '__main__':
　　event=threading.Event()
　　Light = threading.Thread(target=traffic_light)
　　Light.start()
　　for i in range(4):
　　　　Car = threading.Thread(target=car,args=(i,))
　　　　Car.start()

8. 条件（Condition）

使得线程等待，只有满足某条件时，才释放n个线程

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()

def condition_func():
    ret = False
    inp = input('>>>')
    if inp == '1':
        ret = True

    return ret

def run(n):
    con.acquire()
    con.wait_for(condition_func)
    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()

  

 二、进程（Process）

1. 进程调用：

from multiprocessing import Process
import os
 
def info(title):
    print(title)
    print('module name:', __name__)
    print('parent process:', os.getppid())　　#父进程总是一个，子进程可以多个。
    print('process id:', os.getpid())
    print("

")
 
def f(name):
    info('33[31;1mfunction f33[0m')
    print('hello', name)
 
if __name__ == '__main__':
    info('33[32;1mmain process line33[0m')
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

注意：由于进程之间的数据需要各自持有一份，所以创建进程需要的非常大的开销。

2. 进程数据共享

进程各自持有一份数据，默认无法共享数据

from multiprocessing import Process
from multiprocessing import Manager 
import time
 
li = []
 
def foo(i):
    li.append(i)
    print('say hi',li)
  
for i in range(10):
    p = Process(target=foo,args=(i,))
    p.start()
     
print('ending',li)

• 方法一：Array:

from multiprocessing import Process,Array
temp = Array('i', [11,22,33,44])
 
def Foo(i):
    temp[i] = 100+i
    for item in temp:
        print(i,'----->',item)
 
for i in range(2):
    p = Process(target=Foo,args=(i,))
    p.start()

• 方法二：manage.dict()共享数据

from multiprocessing import Process,Manager
 
manage = Manager()
dic = manage.dict()
 
def Foo(i):
    dic[i] = 100+i
    print dic.values()
 
for i in range(2):
    p = Process(target=Foo,args=(i,))
    p.start()
    p.join()

 

3. 进程池  

进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，直到进程池中有可用进程为止。

from multiprocessing import Process,Pool
import time

def f(x):
    time.sleep(0.5)
    print(x*x)
    return(x*x)

p = Pool(5)                                        # 进程池中5个进程。
print(p.map(f,[1,2,3,4,5,6,7,8,9]))      # 生成并去进程池里取进程。多个进程共同跑。

进程池中有两个方法：

• apply
• apply_async

from  multiprocessing import Process,Pool
import time
  
def Foo(i):
    time.sleep(2)
    return i+100
  
def Bar(arg):
    print arg
  
pool = Pool(5)
#print pool.apply(Foo,(1,))　　　　#启动进程，并等待他完成。串行运行。
#print pool.apply_async(func =Foo, args=(1,)).get()　　#并行运行。
  
for i in range(10):
    pool.apply_async(func=Foo, args=(i,),callback=Bar)　　#无需用.start()启用。
  　#等于Process(target=Foo, args=(i,)).start()。
print 'end'
pool.close()
pool.join()#进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭。

#上面的部分相当于 print pool.map(f,range(10))

4. 进程同步

Without using the lock output from the different processes is liable to get all mixed up.

from multiprocessing import Process
from threading import Thread
import time

#Process 乱序输出
def f(i):
    print('hello world',i)

for num in range(10):
    Process(target=f,args=(num,)).start()

time.sleep(3)

#Thread正序输出
def f1(i):
    print('hello world2',i)

for num in range(10):
    Thread(target=f1,args=(num,)).start()

#Outcome:

tlfox@tlfox-virtual-machine:~/Homework/08day7$ python3.5 process_lock.py 
hello world 0
hello world 1
hello world 3
hello world 2
hello world 4
hello world 8
hello world 5
hello world 6
hello world 9
hello world 7

hello world2 0
hello world2 1
hello world2 2
hello world2 3
hello world2 4
hello world2 5
hello world2 6
hello world2 7
hello world2 8
hello world2 9　　

 解决方法：

• join()

from multiprocessing import Process

def f(i):
    print('hello world',i)

for num in range(10):
    p=Process(target=f,args=(num,))
    p.start()
    p.join()

• Lock()

from multiprocessing import Process, Lock
 
def f(l, i):
    l.acquire()
    try:
        print('hello world', i)
    finally:
        l.release()
 
if __name__ == '__main__':
    lock = Lock()
 
    for num in range(10):
        Process(target=f, args=(lock, num)).start()

5. 进程间通信 　　－＞可以先看Queue的例子 

三、Queue

1. 线程Queue

• class queue.Queue(maxsize=0)　　　　 　　#First In First Out
• class queue.LifoQueue(maxsize=0)　　　　 #last in fisrt out 
• class queue.PriorityQueue(maxsize=0) 　　#存储数据时可设置优先级的队列 

Queue.qsize()
Queue.empty() #return True if empty  
Queue.full() # return True if full 
Queue.put(item, block=True, timeout=None)
Put item into the queue. If optional args block is true and timeout is None (the default), block if necessary until a free slot is available. If timeout is a positive number, it blocks at most timeout seconds and raises the Full exception if no free slot was available within that time. Otherwise (block is false), put an item on the queue if a free slot is immediately available, else raise the Full exception (timeout is ignored in that case).

Queue.put_nowait(item)
Equivalent to put(item, False).

Queue.get(block=True, timeout=None)
Remove and return an item from the queue. If optional args block is true and timeout is None (the default), block if necessary until an item is available. If timeout is a positive number, it blocks at most timeout seconds and raises the Empty exception if no item was available within that time. Otherwise (block is false), return an item if one is immediately available, else raise the Empty exception (timeout is ignored in that case).

Queue.get_nowait()
Equivalent to get(False).

Two methods are offered to support tracking whether enqueued tasks have been fully processed by daemon consumer threads.

Queue.task_done()
Indicate that a formerly enqueued task is complete. Used by queue consumer threads. For each get() used to fetch a task, a subsequent call to task_done() tells the queue that the processing on the task is complete.

If a join() is currently blocking, it will resume when all items have been processed (meaning that a task_done() call was received for every item that had been put() into the queue).

Raises a ValueError if called more times than there were items placed in the queue.

Queue.join() block直到queue被消费完毕

FIFO， LILO，PirorityQueue

import queue,threading

#FIFO
q = queue.Queue(20)
for i in range(10):
    q.put(i)

while not q.empty():
    print(q.get())

#LILO
q = queue.LifoQueue(10)
for i in range(10):
    q.put(i)

while not q.empty():
    print(q.get())

#Priority Queue
class Task:
    def __init__(self,priority,description):
        self.priority= priority
        self.description = description

    def __lt__(self,other):
        return(self.priority <other.priority)
q = queue.PriorityQueue()
q.put(Task(1, 'Important task'))
q.put(Task(10, 'Normal task'))
q.put(Task(100, 'Lazy task'))

def job(q):
    while True:
        task = q.get()
        print('Task: %s
' %task.description)
        q.task_done()

threads = [threading.Thread(target=job, args=(q,)),threading.Thread(target=job, args=(q,))]
for t in threads:
    t.setDaemon(True)
    t.start()
q.join()

生产者消费者模型

• 为什么要使用生产者和消费者模式

　　在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

• 什么是生产者消费者模式

　　生产者消费者模型是解决效率和解耦。异步是在不同模块间，使独立性变的非常强，减少阻塞，他们之间的联系变成空耦合。这样，在分布式开发的时候（协作开发的时候），效率才更高，并且程序的运行速度也更高。

import threading
import queue
 
def producer():
    for i in range(10):
        q.put("骨头 %s" % i )
 
    print("开始等待所有的骨头被取走...")
    q.join()
    print("所有的骨头被取完了...")
 
 
def consumer(n):
 
    while q.qsize() >0:
 
        print("%s 取到" %n  , q.get())
        q.task_done() #告知这个任务执行完了 
 
q = queue.Queue() 
p = threading.Thread(target=producer,)
p.start()
 
c1 = consumer("李闯")

import time,random
import queue,threading
q = queue.Queue()
def Producer(name):
  count = 0
  while count <20:
    time.sleep(random.randrange(3))
    q.put(count)
    print('Producer %s has produced %s baozi..' %(name, count))
    count +=1
def Consumer(name):
  count = 0
  while count <20:
    time.sleep(random.randrange(4))
    if not q.empty():
        data = q.get()
        print(data)
        print('33[32;1mConsumer %s has eat %s baozi...33[0m' %(name, data))
    else:
        print("-----no baozi anymore----")　　　　#当吃比产快时候。
    count +=1
p1 = threading.Thread(target=Producer, args=('A',))
c1 = threading.Thread(target=Consumer, args=('B',))
p1.start()
c1.start()

2.进程Queue

#不同进程间内存是不共享的，要想实现两个进程间的数据交换，可以用以下方法：Queues，Pipes，Managers

• MultiProcessing Queue　　#Process Queue 其实是不能共享内存的，他们之间得用序列化的方式传输数据。

from multiprocessing import Process, Queue
 
def f(q):
    q.put([42, None, 'hello'])
 
if __name__ == '__main__':
    q = Queue()
    p = Process(target=f, args=(q,))
    p.start()
    print(q.get())    # prints "[42, None, 'hello']"
    p.join()

• Multiprocessing Pipe 　　#Each connection object has send() and recv() methods (among others)， by default is duplex (two-way).

from multiprocessing import Process, Pipe

def f(conn):
    conn.send([42, None, 'hello'])
    conn.close()
 
if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p = Process(target=f, args=(child_conn,))
    p.start()
    print(parent_conn.recv())   # prints "[42, None, 'hello']"
    p.join()

• Managers

from multiprocessing import Process, Manager
 
def f(d, l):
    d[1] = '1'
    d['2'] = 2
    d[0.25] = None
    l.append(1)
    print(l)
 
if __name__ == '__main__':
    with Manager() as manager:
        d = manager.dict() 
        l = manager.list(range(5))
        p_list = []
        for i in range(10):
            p = Process(target=f, args=(d, l))
            p.start()
            p_list.append(p)
        for res in p_list:
            res.join()
 
        print(d)
        print(l)