多线程--vthread

vthread中包含两个类：

vthread.vthread.pool

vthread.vthread.thread

其中class pool的原型如下：

class pool(builtins.object)
        pool(pool_num=None, gqueue=0, join=False, log=True, monitor=True)

class thread的原型如下：

class thread(builtins.object)
        thread(num=1, join=False, log=True)

init：

__init__(self, pool_num=None, gqueue=0, join=False, log=True, monitor=True)
    #     :pool_num  伺服线程数量
    #     :gqueue    全局队列表的index，默认0，建议用数字标识
    #     :join      多线程是否join
    #     :log       print函数的输出时是否加入线程名作前缀

其他：

Class methods defined here:
    change_thread_num(num, gqueue=0) from builtins.type
        #通过组名字，用来修改线程数量的函数，默认修改gqueue=0的组
        # 是静态函数，你可以直接用 vthread.self.change_thread_num(3)修改
        # 就是简单的多退少补，用来动态修改伺服线程数量的。
        # 因为原理是向线程队列注入停止标记，线程执行和线程接收停止信号是互斥安全的
        # 也是在设计初对任务执行完整性的一种考虑
    
    close_all() from builtins.type
        # 关闭所有伺服线程

    close_by_gqueue(gqueue=0) from builtins.type
        # 通过组名关闭该组所有的伺服线程
        # 默认关闭gqueue=0组的所有伺服线程

    main_monitor() from builtins.type
        # 对主线程进行监视的函数
        # 一旦主线程执行完毕就会向所有线程池函数队列尾注入停止标记
        # 使所有的线程在执行完任务后都停止下来
        # 对于命令行使用的 python 脚本尤为重要
        # 因为如果所有线程不停止的话，控制权就不会交还给命令窗口;
        # 在任意被含有该函数的装饰类装饰的情况下，这个是默认被打开的
        # 可以在装饰时通过设置 monitor 参数是否打开，默认以第一个装饰器设置为准

    
        show() from builtins.type
            # 简单的打印一下当前的线程池的组数
            # 以及打印每一组线程池的线程数量


__dict__
     dictionary for instance variables (if defined)
__weakref__
    list of weak references to the object (if defined)
__call__(self, func)
    # 类装饰器入口

atom(func)
    # 对任意函数进行原子包装（加锁）

patch_print()
    # print 补丁函数
    # monkey patch 式的修改
    # 对python内建 print 函数进行加锁
    # 使其在调试阶段能更方便使用

toggle(toggle=False, name='thread')
    # 开关显示方式,目前提供修改的参数有三个：
    # 1. "thread"  # 是否在print时在最左显示线程名字
    # 2. "error"   # 是否显示error信息

unpatch_all(can_be_repatch=False)
    # 去补丁函数
    # :can_be_repatch=False
    #   因为设计是在每次装饰时就会默认patch一次
    #   卸载后不可被重新patch的参数添加就是为了
    #   可以使得在头部执行这个函数后后面的装饰都不会再patch

example1:多线程

import vthread
import time
# vthread.thread
#========#
# 多线程 #
#========#
# eg.1
#普通的多线程装饰器
@vthread.thread(3) # 只要这一行就能让函数变成开3个线程执行同个函数
def foolfunc(num): #将foolfunc变成动态开启3个线程执行的函数
    time.sleep(1)
    print(f"foolstring, test1 foolnumb: {num} @",time.time())
#默认参数：join=False;log=True
foolfunc(123) # 加入装饰器后，这个函数就变成了开3个线程执行的函数了

执行的结果如下所示：

[   Thread-3  ] foolstring, test1 foolnumb: 123 @ 1585216798.0833788
[   Thread-2  ] foolstring, test1 foolnumb: 123 @ 1585216798.0833788
[   Thread-1  ] foolstring, test1 foolnumb: 123 @ 1585216798.0833788

example2：多线程

import vthread
import time
# eg.2
#为了和pool的使用方法共通（一次函数执行只是一次函数单独执行的效果）
# 为了使函数执行更独立可以用 vthread.thread(1) 来装饰
# 但是为了使用更为简便 这里的 vthread.thread 等同于 vthread.thread(1)

#通过装饰函数，将foolfunc变成开启新线程执行的函数
@vthread.thread
def foolfunc(num):
    time.sleep(1)
    print(f"foolstring, test1 foolnumb: {num} @",time.time())

for i in range(5):
    foolfunc(123) # 执行与数量分离，可以使得参数传递更为动态
                  # 每次执行都会开启新线程，默认不join。
# 注意：
# 这种本身就用于简单测试的方法不要将带参数和不带参数的thread装饰器混用！
# 可能会造成装饰出现问题。

执行的结果如下：

[   Thread-1  ] foolstring, test1 foolnumb: 123 @ 1585216957.6751187
[   Thread-5  ] foolstring, test1 foolnumb: 123 @ 1585216957.6761105
[   Thread-4  ] foolstring, test1 foolnumb: 123 @ 1585216957.6761105
[   Thread-3  ] foolstring, test1 foolnumb: 123 @ 1585216957.6761105
[   Thread-2  ] foolstring, test1 foolnumb: 123 @ 1585216957.6761105

example3：线程池

import vthread
import time
# vthread.pool
#========#
# 线程池 #
#========#
# 线程池的多线程装饰,对代码入侵较小

@vthread.pool(3) # 只用加这一行就能实现3条线程池的包装
def foolfunc(num):
    time.sleep(1)
    print(f"foolstring, test2 foolnumb: {num} @",time.time())
# 默认参数:pool_num=None,join=False,log=True,gqueue=0
# pool_num不选时就自动选 cpu 核心数
# 就是说，装饰方法还可以更简化为 @vthread.pool()
# join参数不建议在主线程内打开。

for i in range(5):
    foolfunc(i) # 加入装饰器后，这个函数变成往伺服线程队列里塞原函数的函数了

# 这里的函数执行都是放在伺服线程中执行。
# 如果不指定 gqueue 参数，默认是共用0号队列
# 不指定 gqueue 参数给多个函数装饰的情况下，用的都是一组伺服线程
#可以尝试用gqueue的参数来实现不同函数不同作用域，开启多组伺服线程

# 不加装饰就是普通的单线程
# 只用加一行就能不破坏原来的结构直接实现线程池操作，能进行参数传递

执行的结果如下所示：

[  Thread-1_0 ] foolstring, test2 foolnumb: 1 @ 1585217724.2185104
[  Thread-2_0 ] foolstring, test2 foolnumb: 2 @ 1585217724.2187068
[  Thread-3_0 ] foolstring, test2 foolnumb: 0 @ 1585217724.2187068
[  Thread-1_0 ] foolstring, test2 foolnumb: 3 @ 1585217725.219437
[  Thread-2_0 ] foolstring, test2 foolnumb: 4 @ 1585217725.2204554

可以看出，多线程并发控制的实现可以通过vthread.pool线程池实现

example4：多组线程池

import vthread
import time
# vthread.pool
#==============#
# 多组的线程池 #
#==============#
pool_1 = vthread.pool(2,gqueue=1) # 开2个伺服线程，组名为1
pool_2 = vthread.pool(2,gqueue=2) # 开2个伺服线程，组名为2

@pool_1
def foolfunc1(num):
    time.sleep(1)
    print(f"foolstring1, test3 foolnumb1:{num} @",time.time())

@pool_2 # foolfunc2 和 foolfunc3 用gqueue=2的线程池
def foolfunc2(num):
    time.sleep(1)
    print(f"foolstring2, test3 foolnumb2:{num} @",time.time())
@pool_2 # foolfunc2 和 foolfunc3 用gqueue=2的线程池
def foolfunc3(num):
    time.sleep(1)
    print(f"foolstring3, test3 foolnumb3:{num} @",time.time())

for i in range(3): foolfunc1(i)
for i in range(2): foolfunc2(i)
for i in range(1): foolfunc3(i)
# 额外开启线程池组的话最好不要用gqueue=0
# 因为gqueue=0就是默认参数

执行的结果如下所示：

[  Thread-4_2 ] foolstring2, test3 foolnumb2:1 @ 1585218328.066928
[  Thread-1_1 ] foolstring1, test3 foolnumb1:0 @ 1585218328.066928
[  Thread-3_2 ] foolstring2, test3 foolnumb2:0 @ 1585218328.066928
[  Thread-2_1 ] foolstring1, test3 foolnumb1:1 @ 1585218328.066928
[  Thread-4_2 ] foolstring3, test3 foolnumb3:0 @ 1585218329.0687575
[  Thread-1_1 ] foolstring1, test3 foolnumb1:2 @ 1585218329.0688848

example5：加装封装，将某些操作进行原子化

import time
import vthread
# 有时候你需要把某些操作进行原子化
# 可以把你要原子化的操作写成函数，用vthread.atom装饰就行
#==========#
# 加锁封装 #
#==========#
@vthread.thread(2)
def foolfunc_():

    @vthread.atom # 将函数加锁封装
    def do_some_fool_thing1():
#        pass # do_something
        print("do some fool thing1 @",time.time())
    @vthread.atom # 将函数加锁封装
    def do_some_fool_thing2():
#        pass # do_something
        print("do some fool thing2 @", time.time())

    # 执行时就会实现原子操作
    do_some_fool_thing1()
    do_some_fool_thing2()

foolfunc_()

执行的结果如下所示：

[   Thread-1  ] do some fool thing1 @ 1585223133.8172073
[   Thread-1  ] do some fool thing2 @ 1585223133.8172073
[   Thread-2  ] do some fool thing1 @ 1585223133.8172073
[   Thread-2  ] do some fool thing2 @ 1585223133.8172073

原子操作是指独立而不可分割的操作，可以理解为一组不可分割操作集。

其他说明：

# 另外：
# 为了便于调试函数在任意第一次装饰过后会对 print 打猴子补丁
# 自带的 print 函数变成带锁的函数了，还加了些打印线程名字的操作
# 可以通过 vthread.toggle 函数对这些或其他一些功能进行关闭
# 也可以用 vthread.unpatch_all() 直接将 print 还原成系统默认函数
# 更多详细内容可以 help(vthread)

# 额外细节：
# 如果想将自己的某些函数进行原子操作的封装可以考虑用 @vthread.atom 装饰那个函数
# 如果你想用原函数的话，你可以用 vthread.orig_func["foolfunc1"] 获得原函数地址
# vthread.orig_func 就是一个包装【原函数名字】对应【原函数地址】的字典。
# 虽然 vthread.atom 可以实现原子操作
# 这里仍然将 lock 暴露出去，用 vthread.lock 就可以拿到这个唯一的线程锁实体

# 为了不用使用者收尾：
# 当使用者装饰任意数量的线程池的时候，都会默认只开一个不计入数量的线程MainMonitor
# 就是监视主线程执行情况，一旦主线程执行完就向线程队列注入相应数量的停止标记
# 因为该线程池的原理就是让主线程变成派发函数的进程，执行到尾部自然就代表
# 分配的任务已经分配完了，这时就可以注入停止标记让线程执行完就赶紧结束掉
# 因为是队列操作不会影响线程效率，只是为了防止在命令行下控制权不交还的情况。
# 当然在之前设计的时候是可以用人为在所有代码最后执行一次 vthread.pool_close_all() 即可解决。
# 但是为了更易用，为了不让使用者在代码最后添加这一句话，就设计了这个监控线程