from multiprocessing import Process
import time
def clock(interval):
    while True:
        print(‘当前的时间是：‘,time.ctime())
        time.sleep(interval)


if __name__ == ‘__main__‘:
    p=Process(target=clock,args=(3,),name=‘子进程‘)
    p.start()
    print(p.is_alive())
    print(p.name)
    print(p.pid)
    print(‘父进程‘)

from multiprocessing import Process
import time
def clock(interval):
    while True:
        print(‘当前的时间是：‘,time.ctime())
        time.sleep(interval)


if __name__ == ‘__main__‘:
    p=Process(target=clock,args=(3,),name=‘子进程‘)
    p.daemon = True #设为守护进程
    p.start()
    print(‘父进程‘)

from multiprocessing import Process
import time
def clock(interval):
    while True:
        print(‘当前的时间是：‘,time.ctime())
        time.sleep(interval)


if __name__ == ‘__main__‘:
    p=Process(target=clock,args=(3,),name=‘子进程‘)
    p.start()
    # p.join() #一直等，等到p执行完了再往下执行代码，试试打开注释的效果
    # p.join(2) #只等2秒，完了继续往下执行代码，
    print(‘父进程‘)

from multiprocessing import Process
import time
def clock(interval):
    while True:
        print(‘当前的时间是：‘,time.ctime())
        time.sleep(interval)


if __name__ == ‘__main__‘:
    p=Process(target=clock,args=(3,),name=‘子进程‘)
    p.daemon=True #打开注释，打开注释p.join(2)
    p.start()
    # p.join()
    p.join(2)
    print(‘父进程‘)
    
‘‘‘
结果
当前的时间是： Sun May  7 00:30:47 2017
父进程
‘‘‘

from multiprocessing import Process
import time
def clock(interval):
    while True:
        print(‘当前的时间是：‘,time.ctime())
        time.sleep(interval)


if __name__ == ‘__main__‘:
    p=Process(target=clock,args=(3,),name=‘子进程‘)
    p.start()
    print(p.is_alive())

    p.terminate() #终止p，进程清理并不会立刻就清理感觉，得有一段时间，于是下一个打印仍然为True
    # time.sleep(3) #打开这个注释，3秒内操作系统肯定将进程回收干净了，下面的打印才会是False
    print(p.is_alive())
    p.join()
    print(‘父进程‘)

‘‘‘
结果:
True
True
父进程
‘‘‘

from multiprocessing import Process
from threading import Thread
import time
def work(f,line):
    time.sleep(2)
    f.write(line)


if __name__ == ‘__main__‘:
    f=open(‘a.txt‘,‘w‘)
    for i in range(5):
        # p=Process(target=work,args=(f,str(i),),name=‘子进程%s‘ %i) #抛出异常，子进程无法共享父进程的f
        p=Thread(target=work,args=(f,str(i),),name=‘子进程%s‘ %i) #线程是可以的
        p.start()

from multiprocessing import Process
import time

class Clock(Process):
    def __init__(self,interval):
        # Process.__init__(self)
        super().__init__()
        self.interval=interval
    def run(self):
        while True:
            print(‘当前的时间是: ‘,time.ctime())
            time.sleep(self.interval)

if __name__ == ‘__main__‘:
    c=Clock(3)
    c.start()
    c.join(2)
    print(‘主进程‘)

q=JoinableQueue()
for i in range(1000):
    q.put(i)

for i in range(1000):
    print(q.get())
    q.task_done()

q.join()

from multiprocessing import Process,Queue,JoinableQueue
import time
def consumer(out_q):
    while True:
        baozi=out_q.get()
        print(‘收到包子:%s‘ %baozi)
        out_q.task_done()

def producer(in_q):
    for i in range(10):
        in_q.put(i)
        # time.sleep(1)
if __name__ == ‘__main__‘:
    q=JoinableQueue()

    c=Process(target=consumer,args=(q,))
    c.daemon=True #一定要射成守护进程，否则在q.join之后，打印完了，会一直卡在out_q.get()
    c.start()

    producer(q)
    q.join()
    print(‘主进程‘)

#_*_coding:utf-8_*_
#!/usr/bin/env python
import time
from multiprocessing import Process,Queue,JoinableQueue


def consumer(q,name):
    while True:
        baozi=q.get()
        print(‘%s 吃包子 %s‘ %(name,baozi))
        q.task_done()

def producer(seq,q):

    for i in seq:
        q.put(i)
        time.sleep(1)
    q.join() #一定是：生产者调用该方法
if __name__ == ‘__main__‘:
    q=JoinableQueue()

    p1=Process(target=consumer,args=(q,‘小白1‘))
    p1.daemon=True
    p1.start()

    p2 = Process(target=consumer, args=(q, ‘小白2‘))
    p2.daemon = True
    p2.start()

    p3 = Process(target=consumer, args=(q, ‘小白3‘))
    p3.daemon = True
    p3.start()

    p4=Process(target=producer,args=([i for i in range(10)],q))
    p4.start()

    p4.join()
    print(‘主进程‘)

from multiprocessing import Process,Queue,JoinableQueue

import time,os
def consumer(out_q,name):
    while True:
        baozi=out_q.get()
        if baozi is None:break
        print(‘%s 收到包子:%s‘ %(name,baozi))
        out_q.task_done()
    print(‘%s down‘ %name)
def producer(seq,in_q):
    for i in seq:
        in_q.put(i)
        # time.sleep(1)
if __name__ == ‘__main__‘:
    q=JoinableQueue()

    c1=Process(target=consumer,args=(q,‘c1‘))
    c1.start()

    c2=Process(target=consumer,args=(q,‘c2‘))
    c2.start()

    c3=Process(target=consumer,args=(q,‘c3‘))
    c3.start()

    #在成产中，seq代表要发送给使用者的项目序列，可以是生产器的形式发送
    seq=(i for i in range(10))
    producer(seq,q)
    q.join()
    print(‘主进程‘)
    q.put(None)
    q.put(None)
    q.put(None)

from multiprocessing import Process,Pipe

import time,os
def consumer(p,name):
    left,right=p
    left.close()
    while True:
        try:
            baozi=right.recv()
            print(‘%s 收到包子:%s‘ %(name,baozi))
        except EOFError:
            right.close()
            break
def producer(seq,p):
    left,right=p
    right.close()
    for i in seq:
        left.send(i)
        # time.sleep(1)
    else:
        left.close()
if __name__ == ‘__main__‘:
    left,right=Pipe()

    c1=Process(target=consumer,args=((left,right),‘c1‘))
    c1.start()


    seq=(i for i in range(10))
    producer(seq,(left,right))

    right.close()
    left.close()

    c1.join()
    print(‘主进程‘)

from multiprocessing import Process,Pipe

import time,os
def adder(p,name):
    server,client=p
    client.close()
    while True:
        try:
            x,y=server.recv()
        except EOFError:
            server.close()
            break
        res=x+y
        server.send(res)
    print(‘server done‘)
if __name__ == ‘__main__‘:
    server,client=Pipe()

    c1=Process(target=adder,args=((server,client),‘c1‘))
    c1.start()

    server.close()

    client.send((10,20))
    print(client.recv())
    client.close()

    c1.join()
    print(‘主进程‘)

#coding: utf-8
from multiprocessing import Process,Pool
import time

def func(msg):
    print( "msg:", msg)
    time.sleep(1)
    return ‘hahaha‘

if __name__ == "__main__":
    pool = Pool(processes = 3)
    res_l=[]
    for i in range(10):
        msg = "hello %d" %(i)
        res=pool.apply_async(func, (msg, ))   #维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去
        res_l.append(res)
    print("==============================>")
    pool.close() #关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成
    pool.join()   #调用join之前，先调用close函数，否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束
    print("Sub-process(es) done.")
    for i in res_l:
        print(res.get())

 使用进程池（阻塞,apply）

#coding: utf-8
from multiprocessing import Process,Pool
import time

def func(msg):
    print( "msg:", msg)
    time.sleep(0.1)
    return ‘hahaha‘

if __name__ == "__main__":
    pool = Pool(processes = 3)
    res_l=[]
    for i in range(10):
        msg = "hello %d" %(i)
        res=pool.apply(func, (msg, ))   #维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去
        res_l.append(res) #同步执行，即执行完一个拿到结果，再去执行另外一个
    print("==============================>")
    pool.close() 
    pool.join()   #调用join之前，先调用close函数，否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束
    print("Sub-process(es) done.")
    print(res_l)
    for i in res_l: #apply是同步的，所以直接得到结果，没有get()方法
        print(res)

#coding: utf-8
import multiprocessing
import os, time, random

def Lee():
    print("\nRun task Lee-%s" %(os.getpid())) #os.getpid()获取当前的进程的ID
    start = time.time()
    time.sleep(random.random() * 10) #random.random()随机生成0-1之间的小数
    end = time.time()
    print(‘Task Lee, runs %0.2f seconds.‘ %(end - start))

def Marlon():
    print("\nRun task Marlon-%s" %(os.getpid()))
    start = time.time()
    time.sleep(random.random() * 40)
    end=time.time()
    print(‘Task Marlon runs %0.2f seconds.‘ %(end - start))

def Allen():
    print("\nRun task Allen-%s" %(os.getpid()))
    start = time.time()
    time.sleep(random.random() * 30)
    end = time.time()
    print(‘Task Allen runs %0.2f seconds.‘ %(end - start))

def Frank():
    print("\nRun task Frank-%s" %(os.getpid()))
    start = time.time()
    time.sleep(random.random() * 20)
    end = time.time()
    print(‘Task Frank runs %0.2f seconds.‘ %(end - start))

def Egon():
    print("\nRun task Egon-%s" %(os.getpid()))
    start = time.time()
    time.sleep(random.random() * 20)
    end = time.time()
    print(‘Task Egon runs %0.2f seconds.‘ %(end - start))

def Lily():
    print("\nRun task Lily-%s" %(os.getpid()))
    start = time.time()
    time.sleep(random.random() * 20)
    end = time.time()
    print(‘Task Lily runs %0.2f seconds.‘ %(end - start))

if __name__==‘__main__‘:
    function_list=  [Lee, Marlon, Allen, Frank, Egon, Lily]
    print("parent process %s" %(os.getpid()))

    pool=multiprocessing.Pool(4)
    for func in function_list:
        pool.apply_async(func)     #Pool执行函数，apply执行函数,当有一个进程执行完毕后，会添加一个新的进程到pool中

    print(‘Waiting for all subprocesses done...‘)
    pool.close()
    pool.join()    #调用join之前，一定要先调用close() 函数，否则会出错, close()执行后不会有新的进程加入到pool,join函数等待素有子进程结束
    print(‘All subprocesses done.‘)

多个进程池

import json,time,random
import multiprocessing
# with open(‘db.json‘,‘w‘) as f:
#     json.dump({‘count‘:1},f)
def work(dbname,user,lock):
    #购票
    # lock.acquire()
    with lock:
        with open(dbname,‘r‘) as f:
            dic=json.load(f)
        if dic[‘count‘] > 0:
            print(‘还有%s张票‘ %dic[‘count‘])
            dic[‘count‘]-=1
            time.sleep(random.randint(0,10))
            with open(dbname,‘w‘) as f:
                json.dump(dic,f)
                print(‘%s 买到一张票‘ %user)
    # lock.release()
if __name__ == ‘__main__‘:
    # work(‘db.json‘)
    lock=multiprocessing.Lock()
    p_l=[]
    for i in range(20):
        p=multiprocessing.Process(target=work,args=(‘db.json‘,‘路人%s‘ %i,lock))
        p.start()
        p_l.append(p)
        # p.join()

    for i in p_l:
        i.join()
    print(‘=============>‘)

from multiprocessing import Process,Semaphore
import time,random

def go_wc(sem,user):
    sem.acquire()
    print(‘%s 占到一个茅坑‘ %user)
    time.sleep(random.randint(0,3)) #模拟每个人拉屎速度不一样，0代表有的人蹲下就起来了
    sem.release()

if __name__ == ‘__main__‘:
    sem=Semaphore(5)
    p_l=[]
    for i in range(13):
        p=Process(target=go_wc,args=(sem,‘user%s‘ %i,))
        p.start()
        p_l.append(p)

    for i in p_l:
        i.join()
    print(‘============》‘)

#_*_coding:utf-8_*_
#!/usr/bin/env python

from multiprocessing import Process,Event
import time,random

def car(e,n):
    while True:
        if not e.is_set(): #Flase
            print(‘\033[31m红灯亮\033[0m，car%s等着‘ %n)
            e.wait()
            print(‘\033[32m车%s 看见绿灯亮了\033[0m‘ %n)
            time.sleep(random.randint(3,6))
            if not e.is_set():
                continue
            print(‘走你,car‘, n)
            break

def police_car(e,n):
    while True:
        if not e.is_set():
            print(‘\033[31m红灯亮\033[0m，car%s等着‘ % n)
            e.wait(1)
            print(‘灯的是%s，警车走了,car %s‘ %(e.is_set(),n))
            break

def traffic_lights(e,inverval):
    while True:
        time.sleep(inverval)
        if e.is_set():
            e.clear() #e.is_set() ---->False
        else:
            e.set()

if __name__ == ‘__main__‘:
    e=Event()
    # for i in range(10):
    #     p=Process(target=car,args=(e,i,))
    #     p.start()

    for i in range(5):
        p = Process(target=police_car, args=(e, i,))
        p.start()
    t=Process(target=traffic_lights,args=(e,10))
    t.start()

    print(‘============》‘)

from threading import Thread
import time

def work(n):
    while True:
        print(‘========>‘,n)
        time.sleep(3)

if __name__ == ‘__main__‘:
    for i in range(3):
        t=Thread(target=work,args=(i,))
        t.start()
    print(‘主线程=====================================>‘)

from threading import Thread
import time

class Work(Thread):
    def __init__(self,num,interval):
        super().__init__()
        self.num=num
        self.interval=interval
    def run(self):
        while True:
            print(‘========>‘,self.num)
            time.sleep(self.interval)

if __name__ == ‘__main__‘:
    for i in range(3):
        t=Work(i,3)
        t.start()
    print(‘主线程=====================================>‘)

from threading import Thread
import time

class Work(Thread):
    def __init__(self,num,interval):
        super().__init__()
        self.num=num
        self.interval=interval
    def run(self):
        while True:
            print(‘========>‘,self.num)
            time.sleep(self.interval)

if __name__ == ‘__main__‘:
    l=[]
    for i in range(3):
        t=Work(i,3)
        t.setDaemon(True)
        t.start()
        l.append(t)

    # for i in l:
    #     i.join()
    print(‘主线程=====================================>‘)

‘‘‘

定义：
In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple 
native threads from executing Python bytecodes at once. This lock is necessary mainly 
because CPython’s memory management is not thread-safe. (However, since the GIL 
exists, other features have grown to depend on the guarantees that it enforces.)

‘‘‘

import time
import threading

def addNum():
    global num #在每个线程中都获取这个全局变量
    #num-=1

    temp=num
    time.sleep(0.1)
    num =temp-1  # 对此公共变量进行-1操作

num = 100  #设定一个共享变量

thread_list = []

for i in range(100):
    t = threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)

for t in thread_list: #等待所有线程执行完毕
    t.join()

print(‘Result: ‘, num)

import threading

R=threading.Lock()

R.acquire()
‘‘‘
对公共数据的操作
‘‘‘
R.release()

import threading
import time

mutexA = threading.Lock()
mutexB = threading.Lock()
# mutexA=mutexB=threading.RLock()
class MyThread(threading.Thread):

    def __init__(self,num):
        threading.Thread.__init__(self)
        self.num=num
    def run(self):
        self.fun1()
        self.fun2()

    def fun1(self):

        mutexA.acquire()  # 如果锁被占用,则阻塞在这里,等待锁的释放

        print ("%s=======>拿到A锁" %self.num)

        mutexB.acquire()
        print ("%s=======>拿到B锁" %self.num)
        mutexB.release()

        mutexA.release()


    def fun2(self):

        mutexB.acquire()
        print("%s=======>拿到B锁" % self.num)
        time.sleep(0.2)

        mutexA.acquire()
        print("%s=======>拿到A锁" % self.num)
        mutexA.release()

        mutexB.release()

if __name__ == "__main__":
    for i in range(0, 10):
        my_thread = MyThread(i)
        my_thread.start()
        
‘‘‘
0=======>拿到A锁
0=======>拿到B锁
0=======>拿到B锁
1=======>拿到A锁
然后就卡住，死锁了
‘‘‘

 mutexA=mutexB=threading.RLock()

import threading
import time

semaphore = threading.Semaphore(5)

def func():
    if semaphore.acquire():
        print (threading.currentThread().getName() + ‘ get semaphore‘)
        time.sleep(2)
        semaphore.release()

for i in range(20):
  t1 = threading.Thread(target=func)
  t1.start()

event.isSet()：返回event的状态值；

event.wait()：如果 event.isSet()==False将阻塞线程；

event.set()： 设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度；

event.clear()：恢复event的状态值为False。

import threading
import time
import logging

logging.basicConfig(level=logging.DEBUG, format=‘(%(threadName)-10s) %(message)s‘,)

def worker(event):
    logging.debug(‘Waiting for redis ready...‘)
    event.wait()
    logging.debug(‘redis ready, and connect to redis server and do some work [%s]‘, time.ctime())
    time.sleep(1)

def main():
    readis_ready = threading.Event()
    t1 = threading.Thread(target=worker, args=(readis_ready,), name=‘t1‘)
    t1.start()

    t2 = threading.Thread(target=worker, args=(readis_ready,), name=‘t2‘)
    t2.start()

    logging.debug(‘first of all, check redis server, make sure it is OK, and then trigger the redis ready event‘)
    time.sleep(3) # simulate the check progress
    readis_ready.set()

if __name__=="__main__":
    main()

def worker(event):
    while not event.is_set():
        logging.debug(‘Waiting for redis ready...‘)
        event.wait(2)
    logging.debug(‘redis ready, and connect to redis server and do some work [%s]‘, time.ctime())
    time.sleep(1)

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

from threading import Timer
 
 
def hello():
    print("hello, world")
 
t = Timer(1, hello)
t.start()  # after 1 seconds, "hello, world" will be printed