Python网络编程学习_Day10

一、进程与线程

1.区别

进程：一个程序要运行时所需要的所有资源的集合，进程是资源的集合。

一个进程至少需要一个线程，这个线程称为主线程

一个进程里面可以有多个线程

两个进程之间的数据是完全独立，不能互相访问。

线程：一道单一的指令控制流，寄生在进程中。

单一进程里多个进程是共享数据的，多个线程在涉及修改同一个数据时，要加锁。

2.线程调用方法

import threading
import time

def sayhi(num): #定义每个线程要运行的函数

    print("running on number:%s" %num)

    time.sleep(3)

if __name__ == '__main__':

    t1 = threading.Thread(target=sayhi,args=(1,)) #生成一个线程实例
    t2 = threading.Thread(target=sayhi,args=(2,)) #生成另一个线程实例

    t1.start() #启动线程
    t2.start() #启动另一个线程

    print(t1.getName()) #获取线程名
    print(t2.getName())

　　

 import threading
 import time

 def sayhi(num): #定义每个线程要运行的函数

     print("running on number:%s" %num)

     time.sleep(3)

 if __name__ == '__main__':

     t1 = threading.Thread(target=sayhi,args=(1,)) #生成一个线程实例
     t2 = threading.Thread(target=sayhi,args=(2,)) #生成另一个线程实例

     t1.start() #启动线程
     t2.start() #启动另一个线程

     print(t1.getName()) #获取线程名
     print(t2.getName())

3.守护线程

守护线程一旦退出，其子线程都会退出。

代码举例如下：

 import time
 import threading

 def run(n):

     print('[%s]------running----\n' % n)
     time.sleep(2)
     print('--done--')

 def main():
     for i in range(5):
         t = threading.Thread(target=run,args=[i,])
         t.start()
         t.join(1)
         print('starting thread', t.getName())

 m = threading.Thread(target=main,args=[])
 m.setDaemon(True) #将main线程设置为Daemon线程,它做为程序主线程的守护线程,当主线程退出时,m线程也会退出,由m启动的其它子线程会同时退出,不管是否执行完任务
 m.start()
 m.join(timeout=2)
 print("---main thread done----")

4.线程锁

多个线程修改同一个数据时要加锁。

 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 )

5.semaphore(信号量)

 import threading,time

 def run(n):
     semaphore.acquire()
     time.sleep(1)
     print("run the thread: %s\n" %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()

 while threading.active_count() != 1:
     pass #print threading.active_count()
 else:
     print('----all threads done---')
     print(num)

6.Event

event有三个指令，event.set()，event.wait()，event.clear()，通过event实现多个线程间的交互。

交通指挥灯实例：

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Liumj
 import threading
 import time
 def lighter():
     count = 0
     while True:
         if count<30:
             if not event.is_set():
                 event.set()
             print("\033[32;1m绿灯--\033[0m")
         elif count <34:
             print("\033[33;1m黄灯--\033[0m")
         elif count<60:
             if event.is_set():
                 event.clear()
             print("\033[31;1m红灯--\033[0m")
         else:
             count = 0
         count +=1
         time.sleep(0.5)
 def car(n):
     count = 0
     while True:
         event.wait()
         print("car [%s] is running..." % n)
         count +=1
         time.sleep(1)
 event = threading.Event()
 red_light = threading.Thread(target=lighter)
 red_light.start()
 c1 = threading.Thread(target=car,args=(2,))
 c1.start()

二、queue队列

三种类型：

class queue.Queue(maxsize=0) #先入先出

class queue.LifoQueue(maxsize=0) #last in fisrt out 

class queue.PriorityQueue(maxsize=0) #存储数据时可设置优先级的队列

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Liumj
 import queue
 #q = queue.Queue(maxsize = 2) #先进先出
 #q = queue.LifoQueue() #后进先出
 q = queue.PriorityQueue(maxsize=3) #后进先出
 #q.put(1)
 #q.put(2)
 #q.put(3)
 q.put([1,"alex"])
 q.put([5,"eric"])
 q.put([3,"liumj"])
 print(q.empty())
 print(q.full())
 print(q.get())
 print(q.get())
 print(q.get())

三、生产者消费者模型

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Liumj
 import threading
 import queue
 import time
 def consumer(name):
     while True:
         print("%s 取到骨头[%s]吃了" %(name,q.get()))
         time.sleep(0.5)
 def producer(name):
     count = 0
     while q.qsize() <5:
         print("%s 生产了骨头" %name,count)
         q.put(count)
         count+=1
         time.sleep(3)
 q = queue.Queue(maxsize=4)
 p = threading.Thread(target=producer,args=("alex",))
 p2 = threading.Thread(target=producer,args=("eric",))
 c = threading.Thread(target=consumer,args=("李闯",))
 p.start()
 p2.start()
 c.start()

四、多进程

multiprocessing是一个包，它支持使用类似于线程模块的API来生成进程。 多进程包提供本地和远程并发，通过使用子进程而不是线程有效地旁路全局解释器锁。 因此，多处理模块允许编程人员充分利用给定机器上的多个处理器。 它在Unix和Windows上运行

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Liumj
 from multiprocessing import Process,Manager
 def f(d,l,n):
     d[n] = n
     l.append(n)
     #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,i))
             p.start()
             p_list.append(p)
         for res in p_list:
             res.join()
         print(d)
         print(l)

五、进程间通信

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

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

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Liumj
from multiprocessing import Process,Pipe
def f(conn):
    conn.send([42,None,'hello'])
    conn.send([41,None,'hello'])
    print("from parent",conn.recv())
    print("from 2",conn.recv())
if __name__ == '__main__':
    parent_conn,child_conn = Pipe()
    p = Process(target=f,args=(child_conn,))
    p.start()
    print(parent_conn.recv())
    parent_conn.send('hello son')
    p.join()

manager多进程

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Liumj
 from multiprocessing import Process,Manager
 def f(d,l,n):
     d[n] = n
     l.append(n)
     #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,i))
             p.start()
             p_list.append(p)
         for res in p_list:
             res.join()
         print(d)
         print(l)

 输入结果：
 {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9}
 [0, 1, 2, 3, 4, 3, 2, 1, 0, 6, 4, 8, 5, 7, 9]

六、进程池

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

from  multiprocessing import Process,Pool
import time

def Foo(i):
    time.sleep(2)
    return i+100

def Bar(arg):
    print('-->exec done:',arg)

pool = Pool(5)

for i in range(10):
    pool.apply_async(func=Foo, args=(i,),callback=Bar)
    #pool.apply(func=Foo, args=(i,))

print('end')
pool.close()
pool.join()#进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭。