python

Pyhon

并发处理

pyhton中实现并发的库有:

1.threading

2.concurrent

3.asyncio （异步I/O）

threading

1
2
3
4
5
6
7
8
9
import threading
count=0
def a():
    global count
    count = count + 1
t = threading.Thread(target=a)#创建线程任务
t.start()#启动一个线程任务
t.join()#阻塞线程任务 直到完成任务

互斥锁 Lock

用来管理线程对于共享资源的访问 同一时刻只有一个线程可以访问共享资源

一个acquire()必须有相对应的release()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import threading
lock=threading.Lock()

def a():
    lock.acquire()
    print("a得到了锁")
    lock.release()
    print("a释放了锁")
    
def b():
    lock.acquire()
    print("a得到了锁")
    lock.release()
    print("a释放了锁")
threads=[]
t1=threading.Thread(target=a)
t2=threading.Thread(target=b)

t1.start()
t2.start()

t1.join()
t2.join()

可读锁 RLock

同一个线程可以多次调用 acquire() 而不会死锁，每次 acquire() 必须对应一次 release()，直到最后一次释放后，其他线程才能获取该锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import threading

rlock = threading.RLock()

def func1():
    with rlock:
        print("func1 获得了锁")
        func2()   # 同一线程再次获取锁，不会阻塞

def func2():
    with rlock:   # 同一线程可重入
        print("func2 获得了锁")

t = threading.Thread(target=func1)
t.start()
t.join()

事件 Event

一个线程发出信号，一个或多个线程等待该信号

1
2
3
4
event=threading.Event()
event.wait() #等待事件信号的启动
event.set() #发出信号
event.clear()#清除信号
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import time

event = threading.Event()

def waiter():
    print("等待事件...")
    event.wait()
    print("事件已发生，继续执行")

def setter():
    time.sleep(2)
    print("设置事件")
    event.set()

threading.Thread(target=waiter).start()
threading.Thread(target=setter).start()

条件变量

比 Event 更灵活，可以配合锁使用，实现复杂的线程间通信（如生产者-消费者）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import random
import time

condition = threading.Condition()
queue = []

def producer():
    while True:
        with condition:
            item = random.randint(1, 100)
            queue.append(item)
            print(f"生产 {item}")
            condition.notify()   # 唤醒一个消费者
        time.sleep(random.random())

def consumer():
    while True:
        with condition:
            while not queue:
                condition.wait()   # 释放锁并等待
            item = queue.pop(0)
            print(f"消费 {item}")
        time.sleep(random.random())

# 启动生产者和消费者线程
threading.Thread(target=producer, daemon=True).start()
threading.Thread(target=consumer, daemon=True).start()
time.sleep(5)  # 运行一段时间

信号量

确保只有指定数量的线程在执行中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import time

semaphore = threading.Semaphore(3)  # 最多3个线程同时访问

def worker(thread_id):
    with semaphore:    # 获取信号量
        print(f"线程 {thread_id} 开始工作")
        time.sleep(1)
        print(f"线程 {thread_id} 结束工作")

threads = [threading.Thread(target=worker, args=(i,)) for i in range(6)]
for t in threads: t.start()
for t in threads: t.join()
# 输出中最多同时3个线程在工作

屏障

等待进程到达屏障点 然后一起执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import time

barrier = threading.Barrier(3)  # 需要3个线程都到达

def player(name):
    print(f"{name} 准备")
    time.sleep(1)                # 模拟准备时间
    barrier.wait()                # 等待所有玩家准备
    print(f"{name} 出发！")

names = ["A", "B", "C"]
threads = [threading.Thread(target=player, args=(name,)) for name in names]
for t in threads: t.start()
for t in threads: t.join()
# 输出：三个“准备”后，所有“出发”会同时打印（或几乎同时）

concurrent

主要是使用concurrent 里面的futures模块

直接开一个线程池 在里面提交任务自动就会开启子线程开启任务

1
2
3
4
5
6
7
from cooncurrent import futures

with cf.ThreadPoolExecutor(max_workers=50) as executor:
    future=executor.submit(func,)
    futures.append(future)
    for future in futures:
        result=future.result()#阻塞线程任务直到完成 但是不会阻塞线程池中的任务
1
2
3
4
5
from concurrent.futures import wait, FIRST_COMPLETED

futures = [executor.submit(task, i) for i in range(5)]
done, not_done = wait(futures, return_when=FIRST_COMPLETED)
print(f"已完成：{len(done)}，未完成：{len(not_done)}")
1
2
3
4
5
from concurrent.futures import as_completed

futures = [executor.submit(task, i) for i in range(5)]
for future in as_completed(futures):
    print(f"结果：{future.result()}")

asyncio

异步I/O操作

单线程+循环事件

一定要用协程函数

1
2
3
4
5
6
7
8
9
10
import asyncio
import httpx

async def func1():
    task=await asyncio.sleep(0.1)
    
    task1=asyncio.sleep(0.1)
    task2=asyncio.sleep(0.2)
    cores=await asyncio.gather(task1,task2)
asyncio.run(func1())

await会挂起任务 并执行其他相同的任务 与直接阻塞不同

httpx

1
2
3
4
import httpx
async def get():
    with httpx.AsyncClient() as client:
        responce = await client.get()

aiohttp

1
2
3
4
import aiohttp
with aihttp.Session() as session:
    with session.get(url) as responce:

通常需要显示关闭一些东西 比如连接 执行器

使用with as 语句可以自动关闭

连接池复用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import request
class Client():
    def __init__(self,url,header,cookies,proxy):
        self.url=url
        self.header=header
        self.cookies=cookies
        self.proxy=proxy
    def __enter__(self):
        self.session=request.session(proxy,header,cookies)
        return self
    def __exit__(self):
        if self.session:
            self.session.close()
        return self

with Client() as client:
    client.get(url)

文件操作

python中文件操作权限常用类型:

image-20260320195600527

image-20260320200009481

读写文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
file = "D:\\123\\1.txt"
fileWrite = "D:\\123\\2.txt"
line = None
with open(file,"r+",encoding = "utf-8") as f:
    while line != "":
        line = f.readline()
        print(line)
        
        
file = "D:\\123\\1.txt"
fileWrite = "D:\\123\\2.txt"
line = None
with open(file,"r+",encoding = "utf-8") as f:
    while line != "":
        lineWrite = "aaa"
        #print(lineWrite,file=fileWrite)
        f.writeline(lineWrite)

下载网络图片

1
2
3
with open(file,"wb") as f:
    for chunk in res.iter_content(size=1024):
        f.write(chunk)

修改文件目录中的文件的后缀名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import pathlib
file = "D:/anime/test"
F = pathlib.Path(file)

if F.exists() and F.is_dir():
    for f in F.iterdir():
        if ".sc.ass.txt" in f.name:
            newName = f.name.replace(".sc.ass.txt",".ass")
            newFile = f.with_name(newName)

            f.rename(newFile)

            print(f"重命名成功：{newFile}")


匹配并修改文本中的特定字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import pathlib
import os
filename = "C:/Users/sakuya/Desktop/1/test/从零开始学习java安全.md"
prefix = r"E:\blog_back\source\_posts\从零开始学习java安全\ ".strip()
file = pathlib.Path(filename)
fileTmp = pathlib.Path(filename + ".tmp")
with file.open(mode="r",encoding="UTF-8") as f:
    with fileTmp.open(mode="w",encoding="UTF-8") as fTmp:
        while (1):
            line = f.readline().replace(prefix,"")
            if line == "":
                break
            fTmp.write(line)
            
os.replace(fileTmp,file)
print("OK")


正则匹配

re库常用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
re.sub(pattern,repl,string) 替换指定字符

re.match(pattern,string)    匹配指定字符 匹配开头的字符

re.research(pattern,string) 匹配指定字符 匹配全部字符

re.findall(pattern,string)  找指定字符


re.escape(r"C:\123\123.txt") 自动转义

# ^ 开始符号
# $ 结束符号
# . 匹配换行符以外的字符
#\d 数字'''

JAVA

流读写

1

说些什么吧！

gitalk