p46318075
/
CodePattern
1
0
Fork 3
Code Issues Pull Requests Packages Projects Releases Wiki Activity

06

Browse Source
dev
zj3D 6 days ago
parent e5b9607dce
commit 35e58525f1
5 changed files with 433 additions and 11 deletions
Show Stats Download Patch File Download Diff File

8
B 高性能模式/01 高性能模式.md
Unescape View File

@ -1,10 +1,10 @@
本文从计算机系统结构的角度探讨提高 Python 代码任务执行速度的方法，涵盖硬件与软件交互的优化策略。以下是一些关键方法：
从计算机系统结构的角度探讨提高 Python 代码任务执行速度的方法，涵盖硬件与软件交互的优化策略。以下是一些关键方法：
### 计算单元层面利用多核并行计算
- 对于 CPU 密集型任务，使用多进程，每个进程拥有独立的 Python 解释器和内存空间运行在独立的内核上，实现并行计算。
对于 CPU 密集型任务，使用多进程，每个进程拥有独立的 Python 解释器和内存空间运行在独立的内核上，实现并行计算。
### I/O 层面减少等待时间
@ -43,3 +43,7 @@
计算设备方面提升办法：使用多机、更快的 CPU、更多核的CPU、更多的内存、更快的存储、使用 GPU 、 FPGA 、TPU加速 。
此外，随着Python社区的发展，新的技术和工具不断涌现，开发者应持续关注最新的进展，以便更好地优化自己的代 。

85
B 高性能模式/02 操作系统相关知识.md
Unescape View File

@ -0,0 +1,85 @@
### 内存管理
段：存放的是全局变量和静态变量
栈：系统自动分配释放，函数参数值，局部变量，返回地址等在此
堆：存放动态分配的数据，由开发人员自行管理
进程表会记录进程在内存的位置，PID 是多少，以及当前什么状态，内存给它分配了多大使用空间以及属于哪个用户
每个用户态线程通过系统调用创建一个绑定的内核线程，Windows NT 即采用这种模型 ；
n 个用户态线程对应 m 个内核态线程。m 通常设置为核数，Linux 即采用的这种模型
在 Linux 中，操作系统采用虚拟内存管理技术，使得进程都拥有独立的虚拟内存空间，理由也比较直接，物理内存不够用且不安全(用户不能直接访问物理内存)。Linux 内核看来只有进程而没有线程。Linux所谓的线程其实是与其他进程共享资源的轻量级进程。为什么说是轻量级呢？在于它只有一个执行上下文和调度程序所需的信息，与父进程共享进程地址空间 。
虚拟内存技术，把进程虚拟地址空间划分成用户空间和内核空间。
在 32 位的操作系统中，4GB 的进程地址空间分为，用户空间和内核空间，用户空间为 0～3G，内核地址空间占据 3～4G，
用户不能直接操作内核空间虚拟地址，只有通过系统调用的方式访问内核空间。
线程共享虚拟内存和全局变量等资源，线程拥有自己的私有数据比如栈和寄存器。
## 并发/并行
多任务简单地说，就是操作系统可以同时运行多个任务。分为并行和并发两种。
并行是真在不同CPU核上同时执行，并发是轮换在一个核上执行。
【顺序】 你做作业，然后看综艺，
【并发】 你写程序到一半，综艺开始，看完综艺后继续写程序。两件事情都处于启动状态
【并行】 你写程序到一半，综艺开始，你一边做作业一边写程序。两件事情同时做
## 阻塞/非阻塞
等候消息的过程中能不能干其他事
## 同步/异步
指的是消息通知的机制
主动听消息则为同步(一直等,轮流取)、被动听消息则为异步
异步过程调用发出后，可以继续执行其它操作
通知调用者的三种方式，如下
状态：即监听被调用者的状态（轮询），调用者没隔一段时间检查一次，效率会很低。
通知：当被调用者执行完成后，发出通知告知调用者，无需消耗太多性能。
回调：与通知类似，当被调用者执行完成后，会调用调用者提供的回调函数。
## 进程、线程、协程
一个游戏，启动后为一个进程
运行一个软件就是开了一个进程
但一个游戏需要图形渲染，联网操作能同时运行
所以将其各个部分设计为线程
即一个进程有多个线程
从操作系统层面而言
进程是分配资源的基本单位
进程之间是独立的
一个进程无法访问另一个进程的空间
一个进程运行的失败也不会影响其他进程的运行
一个进程内可以包含多个线程
线程是程序执行的基本单位，是进程中的实际运作单位
线程是操作系统分配处理器时间的基本单元
线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉
协程运行在线程之上
协程的调度完全由用户控制，协程拥有自己的寄存器上下文和栈
通常我们所说的电脑配置几核就是最大可以运行的进程，
因为电脑会切换进程，所以看起来电脑会同时运行的进程数会超过核数
当需要创建的子进程数量巨大时，就可以创建进程池
进程是常通过Queue实现数据传递，Queue是一个消息队列程序
线程是进程的一部分，一个进程下的多个线程可以共享该进程的所有资源
多个线程共享内存（数据和全局变量共享）。
如果多个线程同时对同一个全局变量操作，会出现资源竞争问题，从而数据结果会不正确
需要进行同步控制。某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。
如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。
可以添加超时时间等，解决死锁
协程是在一个线程中
协程是异步编程的一种具体实现。异步编程是一种编程范式，旨在提高程序的并发能力。
协程是一种允许在特定位置暂停或恢复的子程序。协程提供了一种轻量级的并发方式，允许多个任务在单线程内交错执行，非常适合 I/O 密集型场景。
和回调等其他异步技术相比，
协程维持了正常的代码流程，在保证代码可读性的同时最大化地利用了 阻塞 IO 的空闲时间。
协程在Python中有三种实现方式：
- 生成器中使用 yield/send
- 第三方库 gevent
- Python 3.5 以后的标准库中的 async/await
异步编程在当前 python 社区，常常等价于协程，甚至等价于 async

2
B 高性能模式/多线程的应用场景.md → B 高性能模式/03 多线程的应用场景.md
Unescape View File

@ -2,7 +2,7 @@
Python的多线程时间切片间隔可以通过 sys.setswitchinterval() 设置。其他切换触发条件 ：
- 当线程等待I/O操作（如网络请求或磁盘读写）时，GIL会被释放，允许其他线程运行。
- 某些函数（如 time.sleep()）会显式释放GIL。
- 某些函数（如 time.sleep()）会显式释放GIL，切换到其他线程执行。
- 线程主动释放GIL。
异步编程特别适合高并发的 I/O 密集型任务（如 Web 服务器、爬虫、实时通信）, 特别是大量并发连接的任务。

15
B 高性能模式/相关知识.md → B 高性能模式/04 其它知识.md
Unescape View File

@ -1,11 +1,4 @@
### 协程
- 异步编程是一种编程范式，旨在提高程序的并发能力。
- 协程是异步编程的一种具体实现。协程是一种特殊的函数，可以在执行过程中暂停，并在稍后恢复执行。协程提供了一种轻量级的并发方式，允许多个任务在单线程内交错执行，非常适合 I/O 密集型场景。Python 中的协程通常通过 yield 或 async/await 语法实现: 生成器协程：使用 yield 关键字暂停和恢复执行 ; 原生协程：使用 async def 定义，通过 await 等待其他操作完成。
- 异步编程在 python 社区讨论中，常常等价于协程，甚至等价于 async
### **JIT（即时编译）**
@ -18,4 +11,10 @@ JIT 的工作原理：**解释执行**：程序开始时，代码以解释方式
- **PyPy**：通用的 Python 实现，适合大多数场景。pypy your_script.py
- **Numba**：专注于数值计算，适合科学计算和数据分析。用 `@jit` 装饰器标记需要加速的函数。
- **Cython**：将 Python 代码编译为 C 代码，适合需要极致性能的场景。支持 JIT 和 AOT 编译 。
- **Taichi**：专注于高性能计算，适合图形学、物理仿真等领域。
- **Taichi**：专注于高性能计算，适合图形学、物理仿真等领域。
### 碎片
- 网络系统常用架构 ：服务端用线程池，客户端用 asynico - 异步
- 分布式方法：celery ，不用自己造车 （ lzuDataFactory ）！！！
- thread模块是比较底层的模块,threading模块对thread做了一些包装

334
B 高性能模式/协程_code.ipynb
Unescape View File

@ -0,0 +1,334 @@
{
"cells": [
{
"cell_type": "raw",
"metadata": {},
"source": [
"async def job(t): # async代表这个方法可以异步\n",
"await代表运行这个方法的时候可以切换到下一个程序"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"ename": "NameError",
"evalue": "name 'sleep' is not defined",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-9-7abcb23d41ae>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;31m# type(ff),type( ff() ) # 是个协程类型\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;31m# asyncio.run(main())\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0;32mawait\u001b[0m \u001b[0mff\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# 这样才能执行\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 11\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;32m<ipython-input-9-7abcb23d41ae>\u001b[0m in \u001b[0;36mff\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;32masync\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mff\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0msleep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mNameError\u001b[0m: name 'sleep' is not defined"
]
}
],
"source": [
"import asyncio\n",
"\n",
"async def ff(): \n",
" sleep(2)\n",
" print(1)\n",
"\n",
"# ff() # 不执行\n",
"# type(ff),type( ff() ) # 是个协程类型\n",
"# asyncio.run(main()) \n",
"await ff() # 这样才能执行\n",
"print(2)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"hi\n",
"hi\n",
"hi\n",
"result\n",
"result\n",
"result\n"
]
}
],
"source": [
"async def foo():\n",
" print('hi')\n",
" return 'result'\n",
"\n",
"# 多个函数执行，但是没有用的轮流切换的特点\n",
"for x in await asyncio.gather( foo(),foo(),foo() ): print(x)"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"A\n",
"B\n",
"C\n",
"name = B,<_MainThread(MainThread, started 139785495770944)> \n",
"name = C,<_MainThread(MainThread, started 139785495770944)> \n",
"name = A,<_MainThread(MainThread, started 139785495770944)> \n"
]
}
],
"source": [
"import threading\n",
"\n",
"async def foo( s:str, count: int ):\n",
" print(f\"{s}\")\n",
" await asyncio.sleep(count) # 假装有一个 io操作，交出控制权\n",
" print(f\"name = {s},{threading.currentThread()} \") \n",
"\n",
"async def main():\n",
"# task1 = asyncio.create_task(foo(\"A\", 2))\n",
"# task2 = asyncio.create_task(foo(\"B\", 3))\n",
"# task3 = asyncio.create_task(foo(\"C\", 2))\n",
"\n",
"# await asyncio.gather( task1,task2,task2 ) #并发运行任务 \n",
"# await task1\n",
"# await task2\n",
"# await task3\n",
"\n",
" await asyncio.gather( foo(\"A\", 4),foo(\"B\", 1),foo(\"C\", 2) ) #并发运行任务 \n",
"\n",
"# asyncio.run(main())\n",
"await main()"
]
},
{
"cell_type": "code",
"execution_count": 85,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.5076558589935303"
]
},
"execution_count": 85,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# 使用一个爬虫来做验证\n",
"import aiohttp\n",
" \n",
"async def fetch(session, url):\n",
" async with session.get(url) as response:\n",
" return await response.text()\n",
" \n",
"async def main(url):\n",
" async with aiohttp.ClientSession() as session:\n",
" html = await fetch(session, url)\n",
" print(html[:5]) \n",
" \n",
"### 或者写成\n",
"async def main(url):\n",
" async with aiohttp.ClientSession() as session:\n",
" async with session.get(url, params=payload) as response:\n",
" return await response.text() \n",
"\n",
"# 要句句修饰？ 不太熟悉，这种写法 \n",
"async def main(url):\n",
" async with aiohttp.ClientSession() as session:\n",
" async with session.get(url, params=payload) as response:\n",
"# return await response.text()\n",
" data = await response.text() # 吐数据的地方\n",
" return data\n",
" \n",
"url = \"http://httpbin.org/get\"\n",
"payload = {'key1': 'value1', 'key2': 'value2'}\n",
"\n",
"async def ff():\n",
" a = time.time() \n",
" task = asyncio.create_task( main(url) )\n",
" data = await asyncio.gather( *[ task for x in range(10)] )\n",
" [ x[:20] for x in data ]\n",
" return time.time() - a \n",
" \n",
"await ff()"
]
},
{
"cell_type": "code",
"execution_count": 82,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"5.514704465866089"
]
},
"execution_count": 82,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# 比较时间消耗\n",
"import requests\n",
"\n",
"a = time.time() \n",
"[ requests.get( url, params=payload ).text[:20] for x in range(10) ]\n",
"time.time() - a"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"aiofile, aioredis ..."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 应用案例"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"小明放了一个鱼丸，现在锅里还有1个鱼丸\n",
"mony吃了一个鱼丸，现在锅里还有0个鱼丸\n",
"小明放了一个鱼丸，现在锅里还有1个鱼丸\n",
"小明放了一个鱼丸，现在锅里还有2个鱼丸\n",
"mony吃了一个鱼丸，现在锅里还有1个鱼丸\n",
"小明放了一个鱼丸，现在锅里还有2个鱼丸\n",
"小明放了一个鱼丸，现在锅里还有3个鱼丸\n",
"mony吃了一个鱼丸，现在锅里还有2个鱼丸\n",
"小明放了一个鱼丸，现在锅里还有3个鱼丸\n",
"小明放了一个鱼丸，现在锅里还有4个鱼丸\n",
"mony吃了一个鱼丸，现在锅里还有3个鱼丸\n",
"小明放了一个鱼丸，现在锅里还有4个鱼丸\n",
"小明放了一个鱼丸，现在锅里还有5个鱼丸\n",
"mony吃了一个鱼丸，现在锅里还有4个鱼丸\n",
"小明放了一个鱼丸，现在锅里还有5个鱼丸\n",
"mony吃了一个鱼丸，现在锅里还有4个鱼丸\n",
"mony吃了一个鱼丸，现在锅里还有3个鱼丸\n",
"mony吃了一个鱼丸，现在锅里还有2个鱼丸\n",
"mony吃了一个鱼丸，现在锅里还有1个鱼丸\n",
"mony吃了一个鱼丸，现在锅里还有0个鱼丸\n"
]
}
],
"source": [
"# 生产者，消费者模式\n",
"\n",
"arr = []\n",
"async def produce():\n",
" for i in range(10): \n",
" await asyncio.sleep(1)\n",
" arr.append(i)\n",
" print(\"小明放了一个鱼丸，现在锅里还有%s个鱼丸\"%len(arr))\n",
"\n",
"async def consumer():\n",
" while True: \n",
" await asyncio.sleep(2)\n",
" if arr: #各一个判断条件\n",
" arr.pop()\n",
" print(\"mony吃了一个鱼丸，现在锅里还有%s个鱼丸\"%len(arr)) \n",
" else:\n",
" break\n",
"\n",
"async def main():\n",
" # t1 = asyncio.create_task(produce()) #创建任务\n",
" # t2 = asyncio.create_task(consumer())\n",
" # await asyncio.gather(t1,t2) #并发运行任务\n",
" await asyncio.gather( produce(),consumer() ) #并发运行任务\n",
" \n",
"await main()"
]
}
],
"metadata": {
"hide_input": false,
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.3"
},
"toc": {
"base_numbering": 1,
"nav_menu": {},
"number_sections": true,
"sideBar": true,
"skip_h1_title": false,
"title_cell": "Table of Contents",
"title_sidebar": "Contents",
"toc_cell": false,
"toc_position": {},
"toc_section_display": true,
"toc_window_display": false
},
"varInspector": {
"cols": {
"lenName": 16,
"lenType": 16,
"lenVar": 40
},
"kernels_config": {
"python": {
"delete_cmd_postfix": "",
"delete_cmd_prefix": "del ",
"library": "var_list.py",
"varRefreshCmd": "print(var_dic_list())"
},
"r": {
"delete_cmd_postfix": ") ",
"delete_cmd_prefix": "rm(",
"library": "var_list.r",
"varRefreshCmd": "cat(var_dic_list()) "
}
},
"types_to_exclude": [
"module",
"function",
"builtin_function_or_method",
"instance",
"_Feature"
],
"window_display": false
}
},
"nbformat": 4,
"nbformat_minor": 4
}
Write Preview
Loading…
Cancel
Save