计算机基础知识35

进程和线程的比较

1. 进程的开销比线程的开销大很多
2. 进程之间的数据是隔离的，但是，线程之间的数据不隔离
3. 多个进程间的线程数据不共享----->让进程通信(IPC)---->进程下的线程也通信了---->队列

GIL全局解释器锁(重要理论)

# 虽然一个进程中开了多个线程，但在同一时刻只有一个线程在解释器中运行，全局解释器     锁(GIL)来保证

# 背景信息:

     1、Python代码运行在解释器上嘛，有解释器来执行或者解释

      2、 Python解释器的种类：CPython、IPython、PyPy、Jython、IronPython

                                                    官方下载  交互式   提高速度  Java字节码
     3. 当前市场使用的最多(95%)的解释器就是CPython解释器
     4. GIL全局解释器锁是存在于CPython中
     5. 同一时刻只有一个线程在执行，GIL全局解释器锁是为了避免多个线程抢夺资源的情况

# 在设计之初，在解释器上添加了一把锁  GIL

       哪个线程想执行，必须拿到这把锁，等释放掉，别的线程才能拿

## 问题：

     1. python有GIL锁的原因，同一个进程下多个线程，实际上同一时刻只有一个线程在执行
     2. 只有在python上开进程用的多，其他语言一般不开多进程，只开多线程就够了
     3. cpython解释器开多线程不能利用多核优势，只有开多进程才能利用多核优势，其他语               言不存在这个问题
     4. 8核cpu电脑，充分利用起我这个8核
     5. 如果不存在GIL锁，一个进程下，开启8个线程，它就能够充分利用cpu资源，跑满cpu
     6. cpython解释器中好多代码，模块都是基于GIL锁机制写起来的，改不了了----》开启多            进程---》每个进程下开启的线程，可以被多个cpu调度执行
     7. cpython解释器：io密集型使用多线程，计算密集型使用多进程

互斥锁

"""在多线程的情况下，同时执行一个数据，会发生数据错乱的问题"""

n = 10
from threading import Lock
import time
def task(lock):lock.acquire()global ntemp = ntime.sleep(0.5)n = temp - 1lock.release()
from threading import Threadif __name__ == '__main__':tt = []lock=Lock()for i in range(10):t = Thread(target=task, args=(lock, ))t.start()tt.append(t)for j in tt:j.join()print("主", n)

# 拿时间换空间，空间换时间 时间复杂度

# 面试题：既然有了GIL锁，为什么还要互斥锁? (多线程下)

     1. 第一个线程来了，拿到a=0，开始执行a=a+1,这个时候结果a就是1了
     2. 第一个线程得到的结果1还没有赋值回去给a,这个时候，第二个线程来了，拿到的a是             0，继续执行, a=a+1结果还是1
     3. 加了互斥锁，就能够解决多线程下操作同一个数据，发生错乱的问题

# 线程执行过快，还未赋值，下一个线程就上来了，所以加个互斥锁

    GIL锁同时只能执行 一 个线程

线程队列

# 队列可以解决数据隔离问题（进程）

   队列可以保持数据的安全（线程）

# 线程队列：1. 先进先出     2. 后进先出       3. 优先级的队列

"""进程"""
from multiprocessing import Queue
"""线程"""
import queue
queue.Queue()

# queue.Queue的缺点是它的实现涉及多个锁和条件变量，因此可能会影响性能和内存效率

"""先进先出"""
import queue
q=queue.Queue()  # 无限大、
q.put('first')
q.put('second')
print(q.get())
print(q.get())

"""后进先出"""
import queue
# Lifo：last in first out
q=queue.LifoQueue()
q.put('first')
q.put('second')
print(q.get())
print(q.get())

"""优先级队列"""
import queue
q=queue.PriorityQueue()
q.put((20,'a'))   # put进入一个元组,元组的第一个元素是优先级,数字越小优先级越高
q.put((10,'b'))
q.put((30,'c'))
print(q.get())    # 数字越小优先级越高,优先级高的优先出队
print(q.get())
print(q.get())

进程池和线程池的使用(concurrent模块)

# 池：池子、容器类型，可以盛放多个元素

# 进程池：提前定义好一个池子，然后，往这个池子里面添加进程，以后，只需要往这个进     程池里面丢任务就行了，然后，有这个进程池里面的任意一个进程来执行任务

# 线程池：由任意一个线程来执行任务

# 开进程池

def task(n, m):return n+m
def task1():return {'username':'kevin', 'password':123}from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def callback(res):print(res) # Future at 0x1ed5a5e5610 state=finished returned int>print(res.result()) # 3
def callback1(res):print(res) # Future at 0x1ed5a5e5610 state=finished returned int>print(res.result()) # {'username': 'kevin', 'password': 123}print(res.result().get('username'))if __name__ == '__main__':pool=ProcessPoolExecutor(3)   # 定义一个进程池，里面有3个进程# pool=ThreadPoolExecutor(3)  改一下就是线程pool.submit(task, m=1, n=2).add_done_callback(callback)   ## 2. 往池子里面丢任务pool.submit(task1).add_done_callback(callback1)

# 回调函数，等执行回调用这个函数

# 拿结果：print(res.result())

进程池中先主后子，如果想子进程都执行完再执行主进程：

pool.shutdown()    # join + close
print(123)

协程理论

# 进程：资源分配的基本单位
    线程： 执行的最小单位
    协程：是程序员自己想出来的，不存在于操作系统中
    并发：切换+保存状态

# 协程就是单线程下的并发   # 遇到I/O时

# 协程是最节省资源的，进程是最消耗资源的，其次是线程

   监测有没有遇到IO，本质上就是最大限度的利用CPU资源

            import gevent 模块      先安装，不是内置：pip install gevent 

猴子补丁：就可以把gevent.sleep(2) 写成time.sleep(2)

from gevent import monkey;
monkey.path_all()

gevent.joinall([g1,g2])
# 相当于g1.join()   g2.join()

今日思维导图：