VB.net 2010 视频教程 VB.net 2010 视频教程 python基础视频教程
SQL Server 2008 视频教程 c#入门经典教程 Visual Basic从门到精通视频教程
当前位置:
首页 > temp > 简明python教程 >

  • python基础(32):进程(二)(4)

)
  • # print('%s正在和网红脸聊天' %self.person)
  •  
  • p1=Myprocess('哪吒')
  • p1.start()
  • print(p1.pid) #可以查看子进程的进程id

    • 1.2 进程同步(multiprocess.Lock)

    1.2.1 锁--multiprocess.Lock

    通过刚刚的学习，我们千方百计实现了程序的异步，让多个任务可以同时在几个进程中并发处理，他们之间的运行没有顺序，一旦开启也不受我们控制。尽管并发编程让我们能更加充分的利用IO资源，但是也给我们带来了新的问题。

    当多个进程使用同一份数据资源的时候，就会引发数据安全或顺序混乱问题。

    多进程抢占输出资源：

    
						
      
							
    1. 
								import os
      2. 
							
    2. 
								import time
      3. 
							
    3. 
								import random
      4. 
							
    4. 
								from multiprocessing import Process
      5. 
							
    5. 
								 
      6. 
							
    6. 
								def work(n):
      7. 
							
    7. 
								print('%s: %s is running' %(n,os.getpid()))
      8. 
							
    8. 
								time.sleep(random.random())
      9. 
							
    9. 
								print('%s:%s is done' %(n,os.getpid()))
      10. 
							
    10. 
								 
      11. 
							
    11. 
								if __name__ == '__main__':
      12. 
							
    12. 
								for i in range(3):
      13. 
							
    13. 
								p=Process(target=work,args=(i,))
      14. 
							
    14. 
								p.start()
      15. 
						
    
					
    
					
    
						使用锁维护执行顺序：
    
					
    
						
    
						
      
							
    1. 
								# 由并发变成了串行,牺牲了运行效率,但避免了竞争
      2. 
							
    2. 
								import os
      3. 
							
    3. 
								import time
      4. 
							
    4. 
								import random
      5. 
							
    5. 
								from multiprocessing import Process,Lock
      6. 
							
    6. 
								 
      7. 
							
    7. 
								def work(lock,n):
      8. 
							
    8. 
								lock.acquire()
      9. 
							
    9. 
								print('%s: %s is running' % (n, os.getpid()))
      10. 
							
    10. 
								time.sleep(random.random())
      11. 
							
    11. 
								print('%s: %s is done' % (n, os.getpid()))
      12. 
							
    12. 
								lock.release()
      13. 
							
    13. 
								if __name__ == '__main__':
      14. 
							
    14. 
								lock=Lock()
      15. 
							
    15. 
								for i in range(3):
      16. 
							
    16. 
								p=Process(target=work,args=(lock,i))
      17. 
							
    17. 
								p.start()
      18. 
						
    
					
    
					
    
						上面这种情况虽然使用加锁的形式实现了顺序的执行，但是程序又重新变成串行了，这样确实会浪费了时间，却保证了数据的安全。
    
					
    
						接下来，我们以模拟抢票为例，来看看数据安全的重要性。
    
					
    
						多进程同时抢购余票：
    
					
    
						
    
						
      
							
    1. 
								#文件db的内容为：{"count":1}
      2. 
							
    2. 
								#注意一定要用双引号，不然json无法识别
      3. 
							
    3. 
								#并发运行，效率高，但竞争写同一文件，数据写入错乱
      4. 
							
    4. 
								from multiprocessing import Process,Lock
      5. 
							
    5. 
								import time,json,random
      6. 
							
    6. 
								def search():
      7. 
							
    7. 
								dic=json.load(open('db'))
      8. 
							
    8. 
								print('\033[43m剩余票数%s\033[0m' %dic['count'])
      9. 
							
    9. 
								 
      10. 
							
    10. 
								def get():
      11. 
							
    11. 
								dic=json.load(open('db'))
      12. 
							
    12. 
								time.sleep(0.1) #模拟读数据的网络延迟
      13. 
							
    13. 
								if dic['count'] >0:
      14. 
							
    14. 
								dic['count']-=1
      15. 
							
    15. 
								time.sleep(0.2) #模拟写数据的网络延迟
      16. 
							
    16. 
								json.dump(dic,open('db','w'))
      17. 
							
    17. 
								print('\033[43m购票成功\033[0m')
      18. 
							
    18. 
								 
      19. 
							
    19. 
								def task():
      20. 
							
    20. 
								search()
      21. 
							
    21. 
								get()
      22. 
							
    22. 
								 
      23. 
							
    23. 
								if __name__ == '__main__':
      24. 
							
    24. 
								for i in range(100): #模拟并发100个客户端抢票
      25. 
							
    25. 
								p=Process(target=task)
      26. 
							
    26. 
								p.start()
      27. 
						
    
					
    
					
    
						使用锁来保证数据安全：
    
					
    
						
    
						
      
							
    1. 
								#文件db的内容为：{"count":5}
      2. 
							
    2. 
								#注意一定要用双引号，不然json无法识别
      3. 
							
    3. 
								#并发运行，效率高，但竞争写同一文件，数据写入错乱
      4. 
							
    4. 
								from multiprocessing import Process,Lock
      5. 
							
    5. 
								import time,json,random
      6. 
							
    6. 
								def search():
      7. 
							
    7. 
								dic=json.load(open('db'))
      8. 
							
    8. 
								print('\033[43m剩余票数%s\033[0m' %dic['count
      



  
    
  
  
    
   
  
    
  
 
 
    
 
 
  
 
 
 
 

    




 



    


    相关教程