import threading
from functools import wraps
class ThreadingMask:
    '''
    一个装饰器，用于运行具有列表作为第一个参数的动态方法
    将列表分割成多个列表（根据maxThreads），并在多线程中运行它们
    在定义下有一个示例
    '''
    def __init__(self, maxThreads: int = 64):
        self.maxThreads = maxThreads
        self.groups: list[list] = []
        self.threads = []
    def separate_groups(self, items):
        # 初始化组
        i = 0
        while i < self.maxThreads:
            self.groups.append([])
            i += 1
        i = 0
        # 分离组
        for item in items:
            if i == self.maxThreads:
                i = 0
            self.groups[i].append(item)
            i += 1
    def __call__(self, func):
        @wraps(func)
        def group_run(*args, **kwargs):
            if type(args[1]) is list:
                self.separate_groups(args[1])
            for group in self.groups:
                argsSep = list(args)
                argsSep[1] = group
                argsSep = tuple(argsSep)
                th = threading.Thread(target=func, args=argsSep, kwargs=kwargs)
                self.threads.append(th)
            for th in self.threads:
                th.start()
            for th in self.threads:
                th.join()
        return group_run

import time
class Test:
    '''一个示例'''
    def __init__(self):
        self.result = []
        self.lock = threading.Lock()
    @ThreadingMask()
    def runs(self, items, typeLimit, isNot="a"):
        for item in items:
            def get_matched():
                time.sleep(1)
                if type(item) is typeLimit and str(item) != str(isNot):
                    self.lock.acquire()
                    self.result.append(item)
                    self.lock.release()
            get_matched()
if __name__ == "__main__":
    start = time.time()
    a = Test()
    bunchOfItems = ["d", None, True, "", 1, 2, 3, "a", "b", "c", "this", "e", "d", 13, "p", 0.1, 11]
    a.runs(bunchOfItems, str, isNot="b")
    a.result.sort()
    print(a.result)
    b = Test()
    b.runs(bunchOfItems, str, isNot="b")

import threading
import time
from functools import wraps
class ThreadingMask:
    '''
    a deco to run dynamic method which has a list as the first arg
    will separate the list into several lists (according to maxThreads) and run them with the method in multi-threads
    there is an example under definition
    '''
    def __init__(self, maxThreads: int = 64):
        self.maxThreads = maxThreads
    def separate_groups(self, items):
        # init groups
        groups = [[] for _ in range(self.maxThreads)]
        # separate groups
        for i, item in enumerate(items):
            groups[i % self.maxThreads].append(item)
        return groups
    def __call__(self, func):
        @wraps(func)
        def group_run(*args, **kwargs):
            if type(args[1]) is list:
                groups = self.separate_groups(args[1])
            else:
                groups = [[]]
            threads = []
            for group in groups:
                args_sep = list(args)
                args_sep[1] = group
                args_sep = tuple(args_sep)
                th = threading.Thread(target=func, args=args_sep, kwargs=kwargs)
                threads.append(th)
            for th in threads:
                th.start()
            for th in threads:
                th.join()
        return group_run
class Test:
    '''just a sample'''
    def __init__(self):
        self.result = []
        self.lock = threading.Lock()
    @ThreadingMask()
    def runs(self, items, typeLimit, isNot="a"):
        for item in items:
            def get_matched():
                time.sleep(1)
                if type(item) is typeLimit and str(item) != str(isNot):
                    with self.lock:
                        self.result.append(item)
            get_matched()
if __name__ == "__main__":
    start = time.time()
    a = Test()
    b = Test()
    bunchOfItems = ["d", None, True, "", 1, 2, 3, "a", "b", "c", "this", "e", "d", 13, "p", 0.1, 11]
    a.runs(bunchOfItems, str, isNot="b")
    b.runs(bunchOfItems, str, isNot="b")
    a.result.sort()
    b.result.sort()
    print(a.result)
    print(b.result)

def __call__(self, func):
    @wraps(func)
    def group_run(*args, **kwargs):
        self.threads = []
        if type(args[1]) is list:
            self.separate_groups(args[1])
        for group in self.groups:
            argsSep = list(args)
            argsSep[1] = group
            argsSep = tuple(argsSep)
            th = threading.Thread(target=func, daemon=True, args=argsSep, kwargs=kwargs)
            self.threads.append(th)
        for th in self.threads:
            th.start()
        for th in self.threads:
            th.join()
    return group_run