1.GIL：全局解释锁，导致线程不能利用多核优势提高效率，只能用单个cpu运行。注：cpu只进行计算，如果多线程不涉及计算，则多线程可以提高效率；如果多线程中存在计算，由于GIL(全局解释锁)的存在，反而会降低效率。一个cpu只能同时运行一个进程。

注：cpu只进行计算，如果多线程不涉

2.多进程实现方式：函数式和继承式

（1）函数式实现多进程 

import multiprocessing,time
def run(name):
    time.sleep(5)
    print("来了",name)
if __name__=='__main__':0
    p1 = multiprocessing.Process(target=run,kwargs={"name":"老弟1"},name="L1")
    p2 = multiprocessing.Process(target=run,kwargs={"name":"老弟2"},name="L2")
    p3 = multiprocessing.Process(target=run,kwargs={"name":"老弟3"},name="L3")
    p1.start()
    p2.start()
    p3.start()
    #强制终止进程,但不会进行清理操作
    #p1.terminate()
    #判断进程是否存活
    print(p1.is_alive())
    time.sleep(6)
    print(p1.is_alive())

（2）继承式实现多进程

import multiprocessing,time
class MyProcess(multiprocessing.Process):9
    def __init__(self):
        multiprocessing.Process.__init__(self)
    def run(self):
        print("来了，老弟")
if __name__=="__main__":
    p1 = MyProcess()
    p2 = MyProcess()
    p1.start()
    p2.start()

 3.进程锁

 目的：可以保证在多个进程修改同一个数据时，只能有一个进程修改，其他进程不能同时访问。

加入锁后虽然影响速度效率，但保证了数据安全。 

import multiprocessing,time
#list = [i for i in range(100)]
def work(name,lock):
    lock.acquire()
    with open("b.txt",mode="r+",encoding="utf-8") as f:
        c = int(f.read())
        c -= 1
        time.sleep(1)
        print(name,c)
        f.write(str(c))
    lock.release()
if __name__ == '__main__':
    lock = multiprocessing.Lock()
    p1 = multiprocessing.Process(target=work,args=("p1",lock))
    p2 = multiprocessing.Process(target=work,args=("p2",lock))
    p3 = multiprocessing.Process(target=work,args=("p3",lock) )
    p1.start()
    p2.start()
    p3.start()

 4.进程间通信

（1）多个进程在运行时相对独立，在某些情况下需要进程间的通信来完成任务，可以使用multiprocessing模块的Queue实现多进程之间的数据传递。

（2） 进程间通信的两种方式：队列和管道（推荐使用队列）

队列式实现进程间通信： 

import multiprocessing,time
def work(q):
    if not q.empty():
        print(q.get())
if __name__ == '__main__':
    q = multiprocessing.Queue(maxsize=3)
    q.put(1)
    q.put(2)
    q.put(3)
    p1 = multiprocessing.Process(target=work,args=(q,))
    p2 = multiprocessing.Process(target=work,args=(q,))
    p1.start()
    p2.start()

注：1.maxsize是队列中允许最大项数，省略则无大小限制。 

        2.q.put方法用以插入数据到队列中
           put方法还有两个可选参数：blocked和timeout。
           如果blocked为True（默认值），并且timeout为正值，该方法会阻塞timeout指定的时间，直到该队列有剩余的空间。
           如果超时，会抛出Queue.Full异常。如果blocked为False，但该Queue已满，会立即抛出Queue.Full异常。
         3.q.get方法可以从队列读取并且删除一个元素。
           get方法有两个可选参数：blocked和timeout。
           如果blocked为True（默认值），并且timeout为正值，那么在等待时间内没有取到任何元素，会抛出Queue.Empty异常。
           如果blocked为False，有两种情况存在，如果Queue有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出Queue.Empty异常.

 管道式实现进程间通信：

import multiprocessing
#在管道中，接收方在左侧，发送方在右侧
def jieshou(left,right):
    right.close()#关闭
    print(left.recv())#接收
def fasong(left,right):
    left.close()
    right.send("我是被发送出去的数据")#发送
if __name__=='__main__':
    left,right = multiprocessing.Pipe()
    #创建两个进程
    p1 = multiprocessing.Process(target=jieshou,args=(left,right))
    p2 = multiprocessing.Process(target=fasong,args=(left,right))
    p1.start()
    p2.start()

注：必须在产生Process对象之前产生管道 

5.进程池

当创建的子进程数量不多时，可以通过Process来创建进；如果要创建的子进程数量较多，需要使用pool进程池来解决。初始化一个Pool时，可以指定一个最大进程数，如果超过这个数，那么请求就会等待，直到池中有进程结束，才会创建新的进程来执行。