"threads can only be started once" when calling a method again with a multi-threading deco

I created a deco to run a bunch of things with same method in multi-threads

import threading
from functools import wraps

class ThreadingMask:
    '''
    a deco to run dymastic method which has a list as 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 defination
    '''
    def __init__(self, maxThreads: int = 64):
        self.maxThreads = maxThreads
        self.groups: list[list] = []
        self.threads = []

    def separate_groups(self, items):
        # init groups
        i = 0
        while i < self.maxThreads:
            self.groups.append([])
            i += 1
        i = 0
        # separate groups
        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:
    '''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):
                    self.lock.acquire()
                    self.result.append(item)
                    self.lock.release()
            get_matched()


if __name__ == "__main__":
    start = time.time()
    a = Test()
    bunchOfItems: list = ["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")

But RuntimeError: threads can only be started once occurs when the second time call the method with this deco
Is there a way that can start different threads when second time calling the method than the ones started by the first calling?

You have to create a new instance of your threads on decorator object (ThreadingMask) to run in separate threads, instead you try to launch the same thread twice which you can't (you were using the same self.threads object that you were stocking, instead you should create new thread on function)

Modified code sample :

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: list = ["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)

I think I got the answer, I didn't reset self.threads = [] at each calling.

And according to [https://stackoverflow.com/questions/27575954/python-decorator-with-arguments-only-called-once], it should be under the wrapped func group_run

    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