多线程库vthread

安装

pip install vthread

线程池

如果不加装饰器就是普通的单线程，只用加一行就能在不破坏代码原来的结构直接实现线程池操作，能支持参数传递，支持分组。

• 不加装饰器

import time
start = time.time()
def foolfunc(num):
	print(f"test foolnum:{num}")
for i in range(10):
	# 使用sleep(1)即每次循环等待1秒用于检测线程池操作
	time.sleep(1)
	foolfunc(i)
end = time.time()
print(f"执行循环总用时{end - start}s")

代码运行结果：

• 加装饰器

import time
import vthread
start = time.time()
@vthread.pool(6)
def foolfunc(num):
	# 使用sleep(1)即每次等待1秒 用于检测线程池操作
	time.sleep(1)
	print(f"test foolnum:{num}")
for i in range(10):
	foolfunc(i)
end = time.time()
print(f"执行循环总用时{end - start}s")

代码运行结果：

分组线程池

• 可以实现代码中其中几个函数有m个线程，另外几个函数有n个线程。

import time
import vthread
# 额外开启线程池组的话，最好不要用gqueue=0
# gqueue=0是默认参数
pool_1 = vthread.pool(5, gqueue=1)  # 定义5个线程，组名为1
pool_2 = vthread.pool(2, gqueue=2)  # 定义2个线程，组名为2
@pool_1
def foolfunc1(num):
	time.sleep(1)
	print(f"test foolnum1:{num}")
@pool_2
def foolfunc2(num):
	time.sleep(1)
	print(f"test foolnum2:{num}")
@pool_2
def foolfunc3(num):
	time.sleep(1)
	print(f"test foolnum3:{num}")
for i in range(5):
	foolfunc1(i)
for i in range(5):
	foolfunc2(i)
for i in range(5):
	foolfunc3(i)

代码运行结果：

原子封装

• 如果需要考虑对函数内某些操作进行锁的操作，需要把某些操作进行原子化，可以把原子化的操作写成函数，用vthread.atom装饰。

import time
import vthread
@vthread.thread(5)
def foolfunc():
	@vthread.atom  # 对函数加锁封装
	def do_some_fool_thing1():
		pass
	@vthread.atom  # 对函数加锁封装
	def do_some_fool_thing2():
		pass
	# 执行时就会实现原子操作
	do_some_fool_thing1()
	do_some_fool_thing2()

线程池分组

• 假如在使用过程中装饰了多个函数会怎么计算线程池的线程数量呢？ 这里给出了说明，在 vthread.pool 函数库中，是以 gqueue 这个参数来确定线程池分组的。 而相同的分组，则会默认使用最后一个 “人为定义” 的伺服线程数量。如果不给线程数量，这样就意味着线程池数量为默认的cpu核心数。

#==============================================#
#                                              #
#  注意！关于多个函数装饰器，线程池数量的定义    #
#                                              #
#==============================================#
# 例.1
@vthread.pool(10)
def foolfunc1():
    pass
@vthread.pool(18)
def foolfunc1():
    pass
# 这样就意味着gqueue=0的线程池数量为18
# 例.2
@vthread.pool(10)
def foolfunc1():
    pass
@vthread.pool()
def foolfunc1():
    pass
# 这样就意味着gqueue=0的线程池数量为10
# 例.3
@vthread.pool()
def foolfunc1():
    pass
@vthread.pool()
def foolfunc1():
    pass
# 这样就意味着gqueue=0的线程池数量为默认的cpu核心数
# 例.4
pool1 = vthread.pool(gqueue=1)
pool2 = vthread.pool(6,gqueue=2)
pool2 = vthread.pool(8,gqueue=2)
# 这样就意味着gqueue=1的线程池数量为默认的cpu核心数，gqueue=2的线程池数量为8

普通多线程

import time
import vthread
# 只要这一行就能让函数变成开5个线程执行同个函数
@vthread.thread(5)
def foolfunc(num):
    time.sleep(1)
    print(f"test1 foolnumb: {num}")
foolfunc(123) # 加入装饰器后，这个函数就变成了开5个线程执行的函数了

执行代码结果：

注意：
vthread.thread 不带参数的方式只能装饰一个函数，装饰多个函数会出现问题，仅用于测试单个函数。
vthread.thread(1) 带参数的可以装饰多个函数，但是已经有了分组线程池的强大功能。