from multiprocessing import Process
import os,time, random
def func():print('%s ruing '%os.getpid())time.sleep(0.2)print('%s end'%os.getpid())# p = Process(target=func) #在子进程内创建以个子进程，报错# p.start()if __name__ == '__main__':P = Process(target=func)P.daemon = TrueP.start()# P.join()# 使主进程必须等到子进程运行完毕print('主')

from multiprocessing import Process
from threading import Thread
import time
def foo():print(123)time.sleep(1)print("end123")def bar():print(456)time.sleep(3)print("end456")if __name__ == '__main__':p1=Process(target=foo)p2 = Process(target=bar)p1.daemon=Truep1.start()p2.start()print("main-------")#打印出“main”意味着主进程结束，守护进程也就结束了，然而p2并不是守护进行，主进程需等到p2运行完毕，才能结束，否则会产生孤儿进程

迷惑人的例子

from threading import Thread
import time, os, randomdef func():print('%s is ruing'% os.getpid())time.sleep(2)print("%s end"% os.getpid())t = Thread(target=time.sleep,args=(3,))t.start()if __name__ == '__main__':t = Thread(target=func)t.start()print('主')

from multiprocessing import Process
from threading import Thread
import time
def foo():print(123)time.sleep(1)print("end123")def bar():print(456)time.sleep(3)print("end456")if __name__ == '__main__':t1=Thread(target=foo)t2 = Thread(target=bar)t1.daemon=Truet1.start()t2.start()print("main-------")

迷惑人的例子

def func():# mutex.acquire()print('%s is runing'%os.getpid())time.sleep(2)print('%s end'%os.getpid())time.sleep(random.randint(1,3))# mutex.release()if __name__ == '__main__':p = Process(target=func)p1 = Process(target=func)p2= Process(target=func)p3 = Process(target=func)p.start()p1.start()p2.start()p3.start()# mutex = Lock()# p = Process(target=func,args=(mutex,))# p1 = Process(target=func,args=(mutex,))# p2 = Process(target=func,args=(mutex,))# p3 = Process(target=func,args=(mutex,))# p.start()# p1.start()# p2.start()# p3.start()

from multiprocessing import Process,Lock
import os,time
import json
from random import randint
# def sehch():
#     with open('text.txt',encoding='utf-8')as f:
#         dic = json.load(f)
#     print('%s 剩余票数%s'%(os.getpid(),dic['count']))
# def get():
#
#     with open('text.txt',encoding='utf-8')as f:
#         dic = json.load(f)
#     if dic['count'] > 0:
#         dic['count'] -=1
#         time.sleep(randint(1,3))
#         with open("text.txt",'w',encoding='utf-8')as f:
#             json.dump(dic,f)
#             print('购票成功%s'%os.getpid())
# def task(mutex):
#     sehch()
#     mutex.acquire()
#     get()
#     mutex.release()
# if __name__ == '__main__':
#     mutex = Lock()
#     for i in range(20):
#         p = Process(target=task,args=(mutex,))
#         p.start()

模拟抢票

from threading import Thread
import time, os, random
n = 100
def func():# global n# mutex.acquire()# tem = n# n = tem -1# mutex.release()global n# with mutex:tem = ntime.sleep(0.1)n = tem -1
if __name__ == '__main__':li = []# mutex = Lock()for i in range(100):t = Thread(target=func)li.append(t)t.start()  #在创建进程和线程时，使用的Thread, Process 时需要使用start进行启动for t in li:        #使用with时，可以省略使用acquire，和release 两个函数
        t.join()print(n)

结果为99

from threading import Thread
import time, os, random
n = 100
def func():# global n# mutex.acquire()# tem = n# n = tem -1# mutex.release()global nwith mutex:tem = nn = tem -1
if __name__ == '__main__':li = []mutex = Lock()for i in range(100):t = Thread(target=func)li.append(t)t.start()  #在创建进程和线程时，使用的Thread, Process 时需要使用start进行启动for t in li:        #使用with时，可以省略使用acquire，和release 两个函数
        t.join()print(n)

信号量。信号量是用于维持有限资源访问的信号。它们和锁类似，除了它们可以允许某个限制下的多个访问。它就像电梯一样只能够容纳几个人。一旦达到了限制，想要使用资源的进程就必须等待。其它进程释放了信号量之后，它才可以获得。例如，假设有许多进程需要读取中心数据库服务器的数据。如果过多的进程同时访问它，它就会崩溃，所以限制连接数量就是个好主意。如果数据库只能同时支持N=2的连接，我们就可以以初始值N=2来创建信号量。

>>> from threading import Semaphore
>>> db_semaphore = Semaphore(2) # set up the semaphore
>>> database = []
>>> def insert(data):db_semaphore.acquire() # try to acquire the semaphoredatabase.append(data)  # if successful, proceeddb_semaphore.release() # release the semaphore
>>> insert(7)
>>> insert(8)
>>> insert(9)