day37

今日内容概要

• 进程锁

• 进程之间数据隔离问题

• 如何查看进程的进程号

• 队列(Queue类，专业的队列)

• 生产者消费者模型

• 线程理论

• 如何开启线程(Thread)

• 线程类的参数、方法、属性

• 守护线程(守护进程)

• GIL全局解释器锁

进程锁

"""锁在IT界都是非常重要的，不但在Python中出现，尤其是数据库中得锁更多，比如：表锁、行锁、悲观锁、乐观锁、进程锁、互斥锁、递归锁、可重入锁、死锁等"""

# 使用锁的目的就是为了保证安全!
import time
from multiprocessing import Process, Lock
def task(i, lock):
    # 上一把锁
    lock.acquire()
    print("进程%s来了" % i)
    time.sleep(1)
    print("进程%s走了" % i)
    # 释放锁
    lock.release()
    """只要你上了锁，一定别忘了最后释放锁，否则的话，别的进程永远进不来"""
    # 加锁一定好码? 虽然保证了数据的安全，但是呢，执行的效率一定是降低了
    # 有些场景该加锁的时候一定要加锁，

if __name__ == '__main__':
    lock=Lock()  # 得到一把锁
    for i in range(3):
        p = Process(target=task, args=(i+1, lock))
        p.start()

如何查看进程号

import time
import os
from multiprocessing import Process, Lock
"""有了进程号，我们就可以通过进程号来结束进程的执行   kill 9176 kill -9 9176"""
# taskkill /pid {pid}
def task():
    print("task进程的进程号：", os.getpid()) # os.getpid() 写在哪个进程里面就会输出哪个进程的进程号
    print("task进程的父进程的进程号：", os.getppid()) # parent process
    import time
    time.sleep(20)
if __name__ == '__main__':
    p=Process(target=task, )
    p.start()

    print('子进程的进程号：', p.pid)
    print("主进程的进程号", os.getpid())
    time.sleep(10)

进程之间数据隔离问题

n=100

def task():
    global n
    n=1
    print("子进程")


from multiprocessing import Process

"""这两个进程之间的数据有没有通信? 么有通信"""
if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    """先让子进程先执行，让子进程去改值"""
    p.join()
    print("主进程中得值：", n)
    
"""问题是：如何让进程与进程之间数据通信? """

队列（Queue）

概念介绍----multiprocess.Queue

创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递
Queue([maxsize])创建共享的进程队列
参数：maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。底层队列使用管道和锁定实现

方法介绍

q.get:返回q中的一个项目。如果q为空，此方法将阻塞，直到队列中有项目可用为止。block用于控制阻塞行为，默认为True，如果设置为False，将引发Queue.Empty异常（定义在Queue模块中）。timeout是可选超时时间，用在阻塞模式中。如果在制定的时间间隔内没有项目变为可用，将引发Queue.Empty异常。

q.get_nowait():同q.get(False)

q.put:将item放入队列。如果队列已满，此方法将阻塞至有空间可用为止。

q.qsize():返回队列中目前项目的正确数量。此函数的结果并不可靠。

q.empty():如果调用此方法时q为空，返回True。

q.full():如果q已满，返回True。由于线程的存在，结果也是不可靠的

代码实例

单看队列用法

'''
multiprocessing模块支持进程间通信的两种主要形式:管道和队列
都是基于消息传递实现的,但是队列接口
'''

from multiprocessing import Queue
q=Queue(3)

#put ,get ,put_nowait,get_nowait,full,empty
q.put(3)
q.put(3)
q.put(3)
# q.put(3)   # 如果队列已经满了，程序就会停在这里，等待数据被别人取走，再将数据放入队列。
           # 如果队列中的数据一直不被取走，程序就会永远停在这里。
try:
    q.put_nowait(3) # 可以使用put_nowait，如果队列满了不会阻塞，但是会因为队列满了而报错。
except: # 因此我们可以用一个try语句来处理这个错误。这样程序不会一直阻塞下去，但是会丢掉这个消息。
    print('队列已经满了')

# 因此，我们再放入数据之前，可以先看一下队列的状态，如果已经满了，就不继续put了。
print(q.full()) #满了

print(q.get())
print(q.get())
print(q.get())
# print(q.get()) # 同put方法一样，如果队列已经空了，那么继续取就会出现阻塞。
try:
    q.get_nowait(3) # 可以使用get_nowait，如果队列满了不会阻塞，但是会因为没取到值而报错。
except: # 因此我们可以用一个try语句来处理这个错误。这样程序不会一直阻塞下去。
    print('队列已经空了')

print(q.empty()) #空了

上面这个例子还没有加入进程通信，只是先来看看队列为我们提供的方法，以及这些方法的使用和现象

子进程发送数据给父进程

import time
from multiprocessing import Process, Queue

def f(q):
    q.put([time.asctime(), 'from Eva', 'hello'])  #调用主函数中p进程传递过来的进程参数 put函数为向队列中添加一条数据。

if __name__ == '__main__':
    q = Queue() #创建一个Queue对象
    p = Process(target=f, args=(q,)) #创建一个进程
    p.start()
    print(q.get())
    p.join()

上面是一个queue的简单应用，使用队列q对象调用get函数来取得队列中最先进入的数据。接下来看一个稍微复杂一些的例子：批量生产数据放入队列再批量获得结果

批量生产数据放入队列再批量获取结果

import os
import time
import multiprocessing

# 向queue中输入数据的函数
def inputQ(queue):
    info = str(os.getpid()) + '(put):' + str(time.asctime())
    queue.put(info)

# 向queue中输出数据的函数
def outputQ(queue):
    info = queue.get()
    print ('%s%s%s'%(str(os.getpid()), '(get):',info))

# Main
if __name__ == '__main__':
    multiprocessing.freeze_support()
    record1 = []   # store input processes
    record2 = []   # store output processes
    queue = multiprocessing.Queue(3)

    # 输入进程
    for i in range(10):
        process = multiprocessing.Process(target=inputQ,args=(queue,))
        process.start()
        record1.append(process)

    # 输出进程
    for i in range(10):
        process = multiprocessing.Process(target=outputQ,args=(queue,))
        process.start()
        record2.append(process)

    for p in record1:
        p.join()

    for p in record2:
        p.join()

生产者消费者模型

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

基于队列实现生产者消费模型

from multiprocessing import Process,Queue
import time,random,os
def consumer(q):
    while True:
        res=q.get()
        time.sleep(random.randint(1,3))
        print('%s 吃 %s' %(os.getpid(),res))

def producer(q):
    for i in range(10):
        time.sleep(random.randint(1,3))
        res='包子%s' %i
        q.put(res)
        print('生产了 %s' %(os.getpid(),res))

if __name__ == '__main__':
    q=Queue()
    #生产者们:即厨师们
    p1=Process(target=producer,args=(q,))

    #消费者们:即吃货们
    c1=Process(target=consumer,args=(q,))

    #开始
    p1.start()
    c1.start()
    print('主')

线程

在一个进程中，线程就是必须存在的，至少要有一个线程来执行任务
一个进程中可以有多个线程，在一个进程中可有开启多个线程来执行任务
进程和线程都是有操作系统调度的
进程是操作系统分配资源的基本单位，线程是操作系统执行的最小单位

如何开启线程? 跟开进程是一样的
import time
def task(a, b):
    print("from task")
    time.sleep(2)
    print("aaa")


from  multiprocessing import Process
from threading import Thread
import threading
if __name__ == '__main__':
    # p=Process(target=task)
    # p.start()
    # deamon
    """开线程的资源非常小，以至于代码走到这一行就立马开起来了，所以就会立刻执行"""
    t=Thread(target=task, name='Thread-2', args=('a', ), kwargs={'b':1})
    # t.setDaemon(True)
    """设置为了守护进程：主进程结束，子进程跟着结束"""
    t.daemon = True # 把该线程设置为守护线程, 主线程执行完毕，子线程也结束
    """守护线程有什么用？"""
    t.start()
    # t.join()
    # print(t.name)
    """一个进程中如果只有一个线程，该线程称之为是主线程，其他线程称之为是子线程"""
    t.is_alive()
    print(t.getName()) # t.name
    t.setName('aaaa')
    # t.name = 'aaa'
    print("主线程")
    print(threading.currentThread())
    print(threading.enumerate())
    print(threading.activeCount())