线程进程补充内容,协程,io模型

最新推荐文章于 2023-02-28 21:51:25 发布

yikenaoguazi

最新推荐文章于 2023-02-28 21:51:25 发布

阅读量137

点赞数

分类专栏： start all over again

本文链接：https://blog.csdn.net/yikenaoguazi/article/details/108258808

版权

start all over again 专栏收录该内容

133 篇文章 2 订阅

订阅专栏

day40

一.昨日回顾
二.今日内容

一.昨日回顾

1.GIL锁: 全局解释器锁,因为垃圾回收线程不是线程安全的,所有线程必须拿到这把锁,才能执行
2.GIL跟互斥锁的区别? GIL锁不能保证我们自己的数据安全,自己使用互斥锁保证自己的数据安全
3.不同线程数据交互两种方式:

  -共享变量:不同线程修改同一份数据要加锁(互斥锁)
  -通过queue:不需要考虑数据安全问题(线程安全了)

4.死锁现象:

-1.A线程拿到了A锁,等待B锁,B线程拿到了B锁,等待A锁,相互等待,永远等下去
-2.A线程拿到了A锁,再去拿A锁

5.递归锁(可重入锁):当前线程可以多次获得锁,每获得一次,计数器加一,每释放一次,计数器减一,只有计数器为0,其他线程才能获得
6.Event事件:(了解)

-event.set():发信号
-event.wait():阻塞等信号,只要收到set信号,就会继续往下执行

7.信号量:(了解),类似于锁,允许多条线程同时修改数据(有一些词,在不同语境下意思不一样)
8.Queue :三个:先进先出,后进先出,优先级(线程Queue,跟进程的不是一个Queue)
9.池:尺子,用来做缓冲
10.线程池:

from concurrent.futures import ThreadPoolExecutor
pool = ThreadingPoolExecutor(5)
pool.submit(task,参数1,参数2).add_done_callback(回调函数)
#task执行完的数据如何给回调函数,回调函数会接收一个f对象,
对象中有要的数据(task的return结果),f.result()

11.进程池同理,用法完全一样,只是换一个类

 # 了解:(以前会用的方法,现在已经不用了)
 from multiprocessing import Pool
 p=Pool(3)
 for url in urls:
  	p.apply_async(get_page,args=(url,),callback=pasrse_page)

12.并发与并行

并发:同一时间段内,多个任务执行(单核CPU可以实现)
人跑步,鞋带开了,停下系鞋带,然后继续跑步,5分钟内,它干了两个事

并行:同一时刻,多个任务执行(单核CPU实现不了,必须多核),人跑步的同时听着歌

13.多核多线程比单核多线程更差,IO密集型用多线程,CPU(计算)密集型用多进程

 -FastApi,django3.0,sanic,tornado:支持异步,有协程

二.今日内容

1.线程池shutdown

主线程等待所有任务执行完成

from concurrent.futures import ThreadPoolExecutor
import time

pool = ThreadPoolExecutor(3)


def task(name):
    print('%s 开始'%name)
    time.sleep(1)
    print('%s 结束'%name)


if __name__ == '__main__':
    for i in range(20):
        pool.submit(task, '屌丝%s' % i)

    # 放到for外面，等待所有任务执行完成，主线程再继续走
    pool.shutdown(wait=True)  # 等待所有任务完成，并且把池关闭
    # # 问题，关了还能提交任务吗？不能再提交了
    # pool.submit(task,'sdddd')
    print('主') # 立马执行，20个线程都执行完了，再执行

# pool.shutdown()括号内的wait=True是默认的,可以不写

2.定时器(了解)

指定n秒后执行某一个任务

# 多长时间之后执行一个任务
from threading import Timer

def task(name):
    print('我是大帅比--%s'%name)

if __name__ == '__main__':
    # t = Timer(2, task,args=('lqz',))  # 本质是开了个线程，延迟一秒执行
    t = Timer(2, task,kwargs={'name':'lqz'})  # 本质是开了个线程，延迟一秒执行
    t.start()

3.协程

协程出现的背景:
无论是创建多进程还是创建多线程来解决问题，都要消耗一定的时间来创建进程、创建线程、以及管理他们之间的切换。

为了提高效率,我们基于单线程来实现并发,也就是只用一个主线程（很明显可利用的cpu只有一个）情况下实现并发。这样就可以节省创建线进程所消耗的时间。

协程：是单线程下的并发，又称微线程，纤程。英文名Coroutine。
一句话说明什么是协程：协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的。

进程,线程,协程
协程是为了实现单线程下的并发,属于线程下
协程要解决的问题:保存状态+切换
yield:生成器,只要函数中有yield关键字,这个函数就是生成器,通过yield可以实现保存状态+切换

import time

# 串行执行
# def func1():
#     for i in range(100000000):
#         i += 1
#
#
# def func2():
#     for i in range(100000000):
#         i += 1
#
#
# if __name__ == '__main__':
#     ctime = time.time()
#     func1()
#     func2()
#     print(time.time() - ctime)  # 7s多一些



# 通过yield，实现保存状态加切换（自定义的切换，并不是遇到io才切，所以它并不能节约时间）
# 单纯的切换，不但不会提高效率，反而会讲低效率
def func1():
    for i in range(100000000):
        i += 1
        yield


def func2():
    g=func1() # 先执行一下func1
    for i in range(100000000):
        i += 1
        next(g) # 回到func1执行


if __name__ == '__main__':
    ctime = time.time()
    func2()
    print(time.time() - ctime) #14.764776706695557

协程并不是真实存在的某个东西，而是程序员臆想出来的
程序员控制，不让自己的程序遇到io，看上去，就实现并发了

优点如下：

协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
单线程内就可以实现并发的效果，最大限度地利用cpu

缺点如下：

协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程
协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程

总结协程特点：

必须在只有一个单线程里实现并发
修改共享数据不需加锁
用户程序里自己保存多个控制流的上下文栈(需要保存状态)
附加：一个协程遇到IO操作自动切换到其它协程（如何实现检测IO，yield、greenlet都无法实现，就用到了gevent模块（select机制））

4.greenlet模块

greenlet只是提供了一种比generator更加便捷的切换方式，当切到一个任务执行时如果遇到io，那就原地阻塞，仍然是没有解决遇到IO自动切换来提升效率的问题。

from greenlet import greenlet
import time
# 遇到io不会切，初级模块，gevent模块基于它写的，处理io切换
def eat():
    print('我吃了一口')
    time.sleep(1)
    p.switch()
    print('我又吃了一口')
    p.switch()


def play():
    print('我玩了一会')
    e.switch()
    print('我又玩了一会')


if __name__ == '__main__':
    e = greenlet(eat)
    p = greenlet(play)
    e.switch()
# 输出结果
'''
我吃了一口
我玩了一会
我又吃了一口
我又玩了一会
'''

5.gevent

Gevent 是一个第三方库，可以轻松通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet,
它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度。

gevent基于greenlet写的，实现了遇见io自动切换

# gevent基于greenlet写的，实现了遇见io自动切换


import gevent
import time

def eat(name):
    print('%s 吃了一口' % name)
    gevent.sleep(1)  # io操作
    print('%s 又吃了一口' % name)


def play(name):
    print('%s 玩了一会' % name)
    gevent.sleep(2)
    print('%s 又玩了一会' % name)


if __name__ == '__main__':
      # 这个程序执行完成，最少需要多长时间 2s多一点
    ctim = time.time()
    e = gevent.spawn(eat,'lqz')
    p = gevent.spawn(play,'lqz')
    e.join() # 等待e执行完成
    p.join()
    print('主')
    print(time.time() - ctim)  #2.0165154933929443


    # ctim=time.time()
    # eat('lqz')
    # play('lqz')
    # print(time.time()-ctim) # 3.0190377235412598

猴子补丁

功能:拥有在模块运行时替换的功能

例如: 一个函数对象赋值给另外一个函数对象(把函数原本的执行的功能给替换了)见例1

# 以后使用,这一句必须写
from gevent import monkey;monkey.patch_all()
import gevent
import time

def eat(name):
    print('%s 吃了一口' % name)
    time.sleep(1)  # io操作，被猴子补丁替换之后，gevent.sleep()
    print('%s 又吃了一口' % name)


def play(name):
    print('%s 玩了一会' % name)
    time.sleep(2)
    print('%s 又玩了一会' % name)


if __name__ == '__main__':
    ctim = time.time()
    e = gevent.spawn(eat,'lqz')
    p = gevent.spawn(play,'lqz')
    e.join() # 等待e执行完成
    p.join()
    print('主')
    print(time.time() - ctim)  #2.0165154933929443

例1:一个函数对象赋值给另外一个函数对象

class Monkey():
    def play(self):
        print('猴子在玩')


class Dog():
    def play(self):
        print('狗子在玩')
m=Monkey()
m.play()

m.play=Dog().play  # 这个过程就叫猴子补丁，在程序运行过程中，动态修改
m.play()

例2:monkey patch的应用场景

这里有一个比较实用的例子,很多用到import json, 后来发现ujson性能更高,如果觉得把每个文件的import json改成import ujson as json成本较高, 或者说想测试一下ujson替换是否符合预期, 只需要在入口加上:

import json
import ujson

def monkey_patch_json():
    json.__name__ = 'ujson'
    json.dumps = ujson.dumps
    json.loads = ujson.loads
monkey_patch_json()


# 其实用的是ujson
aa=json.dumps({'name':'lqz','age':19})
print(aa)

7.asyncio模块(了解)

# 官方支持协程的库
import time
import asyncio

# 把普通函数变成协程函数
# 3.5以前这么写
@asyncio.coroutine
def task():
    print('开始了')
    yield from asyncio.sleep(1)  #asyncio.sleep(1)模拟io
    print('结束了')


loop=asyncio.get_event_loop()  # 获取一个时间循环对象#

# 协程函数加括号，并不会真正的去执行，它需要提交给loop，让loop循环着去执行
# 协程函数列表

ctime=time.time()
t=[task(),task()]
loop.run_until_complete(asyncio.wait(t))
loop.close()
print(time.time()-ctime)

import time
import asyncio
from threading import current_thread
# 表示我是协程函数,等同于3.5之前的装饰器
async def task():
    print('开始了')
    print(current_thread().name)
    await asyncio.sleep(3)  # await等同于原来的yield from
    print('结束了')

async def task2():
    print('开始了')
    print(current_thread().name)
    await asyncio.sleep(2)
    print('结束了')

loop=asyncio.get_event_loop()

ctime=time.time()
t=[task(),task2()]
loop.run_until_complete(asyncio.wait(t))
loop.close()
print(time.time()-ctime)

8.io模型(*****)

1.io操作本质:

io操作的本质就是数据复制,数据复制的过程不会消耗CPU

1 内存分为内核缓冲区和用户缓冲区
2 用户的应用程序不能直接操作内核缓冲区，需要将数据从内核拷贝到用户才能使用
3 而IO操作、网络请求加载到内存的数据一开始是放在内核缓冲区的

在这里插入图片描述

2.io模型:

-阻塞io(BIO)
用户进程从发起请求，到最终拿到数据前，一直挂起等待；数据会由用户进程完成拷贝
在这里插入图片描述

-非阻塞io(NIO)
用户进程发起请求，如果数据没有准备好，那么立刻告知用户进程未准备好；此时用户进程可选择继续发起请求、或者先去做其他事情，稍后再回来继续发请求，直到被告知数据准备完毕，可以开始接收为止；数据会由用户进程完成拷贝
在这里插入图片描述

-io多路复用() select(Windows支持,Windows不支持epoll,官方不提供redis的window版本),poll,epoll(Linux支持)
类似BIO，只不过找了一个代理，来挂起等待，并能同时监听多个请求；数据会由用户进程完成拷贝
在这里插入图片描述

-异步io:
-信号驱动io(理论,不在考虑范围内)
发起请求立刻得到回复，不用挂起等待；数据会由内核进程主动完成拷贝
在这里插入图片描述

9.补充内容之虚拟环境

1.解决不同项目依赖的模块版本不同的问题
2.pycharm中创建项目时选择

	-这个虚拟环境可不可以给其他项目使用(取决你是否选择)
	-基于系统解释器当前状态还是纯净状态来创建虚拟环境

3.装模块:

-cmd窗口下:pip3 install flask (装在哪里,一定要确认好)
-推荐用pycharm:setting ---> 那一套
-pycharm下的terminal下装(相当于cmd),比cmd好在,它有个提示

在这里插入图片描述

4.现在用了虚拟环境如何换到系统环境

5.环境变量的作用

-把一个路径加入到环境变量,以后该路径下的命令,可以在任意位置执行

yikenaoguazi

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
线程进程补充内容,协程,io模型

day40一.昨日回顾二.今日内容1.线程池shutdown2.定时器(了解)3.协程4.greenlet模块5.gevent猴子补丁例1:一个函数对象赋值给另外一个函数对象例2:monkey patch的应用场景7.asyncio模块(了解)8.io模型(*****)9.补充内容之虚拟环境一.昨日回顾1.GIL锁: 全局解释器锁,因为垃圾回收线程不是线程安全的,所有线程必须拿到这把锁,才能执行2.GIL跟互斥锁的区别? GIL锁不能保证我们自己的数据安全,自己使用互斥锁保证自己的数据安全3.不同线
复制链接

扫一扫

专栏目录