单例模式

面试中，就被问到了这个问题，你知道用python怎么创建一个单例模式吗？ 单例模式是什么？ 就是这个对象只能被创建一次。 每次实例化，都是同一个对象。

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例 模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约 系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

全局解释器锁 （GIL）

即使电脑有多核CPU，单个时刻也只能运行1个线程，遇到io之后转换到另一个线程运行。

为什么要有这个GIL，为了解决多线程之间数据完整性和状态同步问题。有了GIL简化了Python对于共享 资源的管理。

Python 多进程

进程

进程时系统分配资源的单位，一个进程可以有多个线程；

进程的状态有：新建，就绪，运行，等待，死亡。

并行：真的多任务； 并发： 假的多任务；

multiprocessing

import multiprocessing
import time
 
food="aaaaa"
  
def singing():
    while True:
        print("singing...")
        time.sleep(1)
def dancing():
    while True:
        print("dancing...")
        time.sleep(1)
def main():
    p1 = multiprocessing.Process(target=singing)
    p2 = multiprocessing.Process(target=dancing)
    p1.start()
    p2.start()
if __name__ == "__main__":
    main()

多进程的创建与多线程极其相似。线程一般是共享主进程的一些变量，而进程可以理解为将主进程的资 源复制一份，相比于线程，进程耗费的资源较多。

同一台电脑启动两个微信，就是两个进程。而一个微信，开多个聊天框，就是多线程。

进程是完全独立的，于线程不同，需要某个介质，实现线程之间的通信

通过队列完成进程通信

队列，先进先出。

from multiprocessing import Queue
##
myque = Queue(3)
myque.put(1)
myque.put(2)
myque.put(3)
myque.put(4) # 超过队列长度 ，会等待
myque.get() 
myque.get()
myque.get()
myque.get()# 先放谁 先取谁。如果为空，就会等待，阻塞

生产者消费者线程，利用队列进行通信

from multiprocessing import Process,Queue,set_start_method,get_context
import time
def download_from_web(q):
    i=0
    while True:
        i += 1
        q.put(i)
        print(f'放入{i}')
        time.sleep(1)
def analysis_data(q):
    """处理数据"""
    watting_analysis_data = list()
    while True:
        data = q.get()
        watting_analysis_data.append(data)
        print(watting_analysis_data)
        time.sleep(4)
        # if q.empty(): # 如果放的很慢 就会停掉消费者
        #     break
    # print(watting_analysis_data)
def main():
    q = Queue(10)
    # 放入和取出 两边都while true，这样队列没有的话，不能取，会等待放入
    # 队列满了的话 不能放，会等待取出
    ctx = get_context('fork')
    p1 = ctx.Process(target=download_from_web,args=(q,))
    p2 = ctx.Process(target=analysis_data,args=(q,))
    p1.start()
    p2.start()
if __name__ == "__main__":
    main()

进程池

当要创建的进程数量不多时，可以利用multiprocessing中的Procss动态生成多个进程，但如果需要创建 成千上百个目标，可以利用进程池Pool方法。

from multiprocessing import Pool
import os, time, random
def work(i):
    
    time.sleep(random.random()*3)
    print("进程{} running ....".format(i),"--pid {}".format(os.getpid()))
if __name__ == '__main__':
    po = Pool(3)
    for i in range(10):
        po.apply_async(work,(i,))
    print("-----start-------")
    po.close()
    po.join()
    print("-----end-------")

线程池里的Queue用multiprocessing下的manager.queue