python之多线程与多进程入门

python之多线程与多进程

关键词: GIL锁,IO繁忙,线程安全,线程同步,进程池,进程通信,队列

  • GIL锁;

    全局解释锁,Global Interpretor Lock,
    作用:单位时间内只允许一个线程运行。
    结果:无法利用多核实现并发功能,cpu繁忙的任务无效甚至效率更低(进程切换需要耗费资源),因此在python中不建议使用多线程,而使用多进程代替

  • cpu繁忙与io繁忙

    cpu繁忙:内存操作多

    io繁忙:硬盘或其他存储介质读写多,比如各种数据中心,网络存储和云存服务器

  • 线程同步:

    单位时间只能有一个线程访问某个资源

  • 线程安全:

    使用了线程同步,保证资源正确调用

  • python实现多进程的方法:

    • 主角:multiprocessing

    • 工具:Process(进程转化为类), Pool(进程池), Queue(队列,用于进程通讯)

    • 初级实现:

      class Myprocess(Process): #自定义线程类
      
          def __init__(self, wait_ime):
              Process.__init__(self)
              self.wait_ime = wait_ime
      
          def run(self):#重写run方法!!!!!!重要
              n = 0
              while n < 4:
                  print ("subProcess %s run," % os.getpid(), "{0}".format(time.ctime()))
                  time.sleep(self.wait_ime)
                  n += 1
      if __name__ == "__main__":
      
          p=Myprocess(2)
          q=Myprocess(0.5)
          p.start() #启动进程
          q.start()
          p.join()  #等待p进程结束,主进程才能往下运行(简称阻塞)
          q.join()
          print('结束')
      
    • 结果

      subProcess 6600 run, Thu Nov 22 16:19:57 2018  # 两个同进程
      subProcess 3012 run, Thu Nov 22 16:19:57 2018
      subProcess 3012 run, Thu Nov 22 16:19:58 2018
      subProcess 3012 run, Thu Nov 22 16:19:58 2018
      subProcess 3012 run, Thu Nov 22 16:19:59 2018
      subProcess 6600 run, Thu Nov 22 16:19:59 2018
      subProcess 6600 run, Thu Nov 22 16:20:01 2018
      subProcess 6600 run, Thu Nov 22 16:20:03 2018
      结束
      
    • 进程池

      def example(wait_ime):
              n = 0
              while n < 4:
                  print ("subProcess %s run," % os.getpid(), "{0}".format(time.ctime()))
                  time.sleep(wait_ime)
                  n += 1
      if __name__ == "__main__":
          pool=Pool(5)
      
          for i in (0.1,1.2,0.5):
              pool.apply_async(example,(i,))#非阻塞模式,不会等一个进程运行完才运行下一个进程
          pool.close()
          pool.join()
          print('结束')
      
    • 队列(实现生产者与消费者模式的核心工具)

     class MultiProcessProducer(multiprocessing.Process):#生产者类
        def __init__(self, num, queue):              # 传出队列queue
           """Constructor"""
           multiprocessing.Process.__init__(self)
           self.num = num
           self.queue = queue
     
        def run(self):                                   #存入数字
           t1 = time.time()
           print('producer start ' + str(self.num))
           for i in range(1000):
              self.queue.put((i, self.num))          #插入队列
              time.sleep(0.1)
              print ('producer put', i, self.num)
           t2 = time.time()
     
           print('producer exit ' + str(self.num))
           use_time = str(t2 - t1)
           print('producer ' + str(self.num) + ', \
           use_time: '+ use_time)
     
     
     
     class MultiProcessConsumer(multiprocessing.Process):# 消费者类
         def __init__(self, num, queue):
           """Constructor"""
           multiprocessing.Process.__init__(self)
           self.num = num
           self.queue = queue                            #传入队列
     
         def run(self):
             t1 = time.time()
             print('consumer start ' + str(self.num))
             while True:
                 d = self.queue.get()
                 print('get'+str(d))
             t2 = time.time()
             print('consumer exit ' + str(self.num))
             print('consumer ' + str(self.num) + ', use time:'+ str(t2 - t1))
     
     def main():
            # create queue
            queue = multiprocessing.Queue()
     
            # create processes
            producer = []
            for i in range(5):
               producer.append(MultiProcessProducer(i, queue))
     
            consumer = []
            for i in range(5):
               consumer.append(MultiProcessConsumer(i, queue))
     
            # start processes
            for i in range(len(producer)):
               producer[i].start()
     
            for i in range(len(consumer)):
               consumer[i].start()
     
            # wait for processs to exit
            for i in range(len(producer)):
               producer[i].join()
     
            for i in range(len(consumer)):
               queue.put(None)
     
            for i in range(len(consumer)):
               consumer[i].join()
     
            print('all done finish')
    
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成,浏览时请结合常识与多方信息审慎甄别。
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

相关阅读更多精彩内容

  • 写在前面的话 代码中的# > 表示的是输出结果 输入 使用input()函数 用法 注意input函数输出的均是字...
    FlyingLittlePG阅读 8,218评论 0 9
  • 一文读懂Python多线程 1、线程和进程 计算机的核心是CPU,它承担了所有的计算任务。它就像一座工厂,时刻在运...
    星丶雲阅读 5,384评论 0 4
  • 20180126,其实是词穷的,第一篇该怎么开始,可是却做好了结束的准备…重新认识,你好,在爵士!
    梁云凤老三阅读 1,409评论 0 0
  • iOS同学都清楚NSString方法可以将一个NSString对象转换成bool值,比如我们可以将服务端返回过来的...
    nuannuan_nuan阅读 5,510评论 0 0
  • 示例:architecture_spider Scrapy 相关 参考scrapy文档,scrapyd文档 scr...
    顾慎为阅读 3,287评论 0 1

友情链接更多精彩内容