进程、线程、协程

Process([group [, target [, name [, args [, kwargs]]]]])

　　group # 线程组，目前还没有实现，库引用中提示必须是None； 
　　target#要执行的方法； 
　　name #进程名； 
　　args/kwargs  # 要传入方法的参数。

实例方法：
　　is_alive() #返回进程是否在运行。
　　join([timeout]) #阻塞当前上下文环境的进程程，直到调用此方法的进程终止或到达指定的timeout（可选参数）。
　　start()#进程准备就绪，等待CPU调度

　　run() #strat()调用run方法，如果实例进程时未制定传入target，这star执行t默认run()方法。
　　terminate()#不管任务是否完成，立即停止工作进程
　　p.getpid()#当前进程id
　　p.getppid() #父进程id

属性：
　　daemon#和线程的setDeamon功能一样,不过变了属性，设置守护进程的属性
　　name#进程名字。
　　pid　　#进程号

from multiprocessing import Process,Lock

def prt(i,lock):
    lock.acquire()
    print(‘love is ‘,i)
    lock.release()

if __name__ ==‘__main__‘:
    l=Lock()
    for i in range(1,11):
        p = Process(target=prt,args=(i,l))
        p.start()

from  multiprocessing import Process,Pool
import time,os

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

def Bar(arg):

    print(os.getpid())
    print(os.getppid())
    print(‘logger:‘,arg)

pool = Pool(5) #如果不传参，默认为电脑核数
Bar(1)
for i in range(10):
    #pool.apply(func=Foo, args=(i,))  #同步
    #pool.apply_async(func=Foo, args=(i,)) #异步
    pool.apply_async(func=Foo, args=(i,),callback=Bar) #回调函数，要有且仅有一个参数。进程池有个回调函数参数，回调函数是子进程执行完一次任务后，由主进程执行的函数。

pool.close()
pool.join() #注意一下，这里格式是死的，只要用进程词，close()后再join()一下，两者去其一，要么报错要么不执行
print(‘end‘)

from multiprocess import Queue,Pipe，Manager
进程队列
q = multiprocess.Queue()

管道,类似于socket的用法
son_pipe,parent_pipe = Pipe()
son_pipe.send([‘love‘])
data=parent_pip.recv()
son_pipe.close()

Manager
with Manager() as manager
    d=manager.dict()
    l=manager.list(range(6))
#使用时注意：是将d，l等对象当做进程函数参数传过去

t.join()等用于waitforsingleobject，在子线程执行完之前，父线程会一直阻塞，注意只是父线程。
t.setDaemeon(True) 设为守护线程，在t.start()之前调用
t.start()，因为线程一被创建默认被挂起，这个是用来启动的（其实也没有真正跑起来，只是让线程处于‘就绪‘状态）
t.isAlive() 判断线程是否还在运行。

t.getname、t.setname，设置线程名字，如果不设的话有默认的名字
threading.active_count() 此时此刻到底有几个线程在活动。 
threading.current_thread() 自己所在线程的名字

#常用：主线程等待子线程结束
#等待所有线程运行完毕
def wait_allcomplete(self):
    for item in self.threads:
        if item.isAlive():
            item.join()

#总结来说：继承threading.Thread ,覆写run（self），创建对象后t.start()
import threading
import time

class MyThread(threading.Thread):
    def __init__(self,num):
        threading.Thread.__init__(self)  # 等同于 super().__init__()
        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()
    
    print("ending......")

import threading

# 创建全局ThreadLocal对象:
local_school = threading.local()

def process_student():
    print ‘Hello, %s (in %s)‘ % (local_school.student, threading.current_thread().name)

def process_thread(name):
    # 绑定ThreadLocal的student:
    local_school.student = name
    process_student()

t1 = threading.Thread(target= process_thread, args=(‘Alice‘,), name=‘Thread-A‘)
t2 = threading.Thread(target= process_thread, args=(‘Bob‘,), name=‘Thread-B‘)
t1.start()
t2.start()
t1.join()
t2.join()

lock.acquie()
temp=num #这一部分代码变串行了
time.sleep(0.1)
temp=num-1
lock.release()

a=100
b = 0
lock =  threading.local()
lock.acquire()
lock.acquire()
a-=1
b+=2
lock.release()
lock.release()

event =threading.Event()  #一个event对象可以用到多个线程里面去
event.wait()  #如果没有set设定的条件，该函数会一直阻塞，有的话无视该函数
event.set()  #设置同步条件
event.clear()  #清除同步条件
event.isSet() #检查标志是否有设定

num = 100
def a():
    if semaphore.acquire():  ###
        global num
        num1=num
        time.sleep(0.1)
        num=num1-1
        semaphore.release()####
li =[]
if __name__ == ‘__main__‘:

    semaphore=threading.Semaphore(5) ### 最多只能由五个线程同时处理处理
    for i in range(100):
        t = threading.Thread(target=a)
        t.start()
        li.append(t)
    for i in li:
        i.join()
    print(num)

import queue
q = queue.Queue() #可以传参，表示队列大小
q.put(‘xx‘) #若队列满了，该函数会阻塞线程，若block参数为False则直接报错
q.get()  #若队列没数据，则该函数会阻塞线程，若block参数为False则直接报错
q.qsize()
q.empty() #是否为空？
q.full()    #是否满了？
q.put_notwait()  #不阻塞满直接报错
q.get_nowait()    

q.task_done() #在完成一项工作之后，q.task_done() 函数向任务已经完成的队列发送一个信号
q.join() #接收到由q.task_done函数发送的信号（队列为空）后才继续走，否则就一直阻塞

q =queue.LifoQueue() 　　#先进后出
 q=queue.PriorityQueue() 　　#优先级队列
#优先级高的先出来，压进去的时候带优先级，数据都是[优先级，数据]
#例如：q.put([10,‘info‘]),10是优先级

import time,random
import queue,threading

q = queue.Queue()

def Producer(name):
  count = 0
  while count <10:
    print("making........")
    time.sleep(random.randrange(3))
    q.put(count)
    print(‘Producer %s has produced %s baozi..‘ %(name, count))
    count +=1
    #q.task_done()
    #q.join()
    print("ok......")
def Consumer(name):
  count = 0
  while count <10:
    time.sleep(random.randrange(4))
    if not q.empty():
        data = q.get()
        #q.task_done()
        #q.join()
        print(data)
        print(‘\033[32;1mConsumer %s has eat %s baozi...\033[0m‘ %(name, data))
    else:
        print("-----no baozi anymore----")
    count +=1

p1 = threading.Thread(target=Producer, args=(‘A‘,))
c1 = threading.Thread(target=Consumer, args=(‘B‘,))
# c2 = threading.Thread(target=Consumer, args=(‘C‘,))
# c3 = threading.Thread(target=Consumer, args=(‘D‘,))
p1.start()
c1.start()
# c2.start()
# c3.start()

#用法
g1=gevent.spawn(func,1,,2,3,x=4,y=5)创建一个协程对象g1，spawn括号内第一个参数是函数名，如eat，后面可以有多个参数，可以是位置实参或关键字实参，都是传给函数eat的
g2=gevent.spawn(func2)
gevent.joinall([g1,g2])

g1.join() #等待g1结束
g2.join() #等待g2结束
#或者上述两步合作一步：gevent.joinall([g1,g2])
g1.value#拿到func1的返回值