map [Task] int64其中Task是一个接口(map[Task]int64 where Task is an interface)

 您可以生成函数的number副本，每个副本都有独立的 lru_cache包装器： 
 
setup = '''\
    from {name} import recursive_function as f
    f = iter([
        functools.lru_cache(maxsize=None)(recursive_function.__wrapped__)
        for _ in range({number})])
    n = {n}
    next_ = next
'''.format(name=__name__, number=number, n=n)
test = '''\
    recursive_function = next_(f)
    recursive_funcion.__globals__['recursive_funcion'] = recursive_funcion
    recursive_function(n)
'''
return timeit.timeit(test, setup, number=number)
 
 该设置预先创建number独立装饰的功能对象，每个功能对象都有一个不同的LRU缓存，并为此创建一个迭代器。 然后，测试使用next()函数获取下一个可用的函数对象，并将其用于测试。 
 
 但是，每次都必须替换当前的全局名称recursive_function ，否则递归调用将找不到新的装饰版本。 这有点不利，不要运行计时器并且期望​​缓存在之后是空的（它将包含最后一次测试运行的结果）。 
 
 这是因为： 
 
 
 
 原始的非缓存函数仍可用作recursive_function.__wrapped__ 
 
 
 decorator语法只是用于调用decorator对象以生成新函数对象的语法糖。 
 
 
 这为每个单独的测试提供了一个干净的缓存，只需要很少的开销（只有一个next()调用，它已被绑定到本地以避免全局名称查找惩罚）。 

You could produce number copies of the function, each with their independent lru_cache wrapper:
 
setup = '''\
    from {name} import recursive_function as f
    f = iter([
        functools.lru_cache(maxsize=None)(recursive_function.__wrapped__)
        for _ in range({number})])
    n = {n}
    next_ = next
'''.format(name=__name__, number=number, n=n)
test = '''\
    recursive_function = next_(f)
    recursive_funcion.__globals__['recursive_funcion'] = recursive_funcion
    recursive_function(n)
'''
return timeit.timeit(test, setup, number=number)
 
The setup creates number individually decorated function objects up front, each with a distinct LRU cache, and creates an iterator for this. The test then uses the next() function to obtain the next available function object, and uses that for the test.
 
You do have to replace the current global name recursive_function each time however, as otherwise the recursive call won't find the new decorated version. This is a bit of a downside, don't run the time trial and expect the cache to be empty afterwards (it'll contain the results of the very last test run instead).
 
This works because:
 
 
 
the original un-cached function is still available as recursive_function.__wrapped__
 
 
decorator syntax is just syntactic sugar for a call to the decorator object to produce a new function object.
 
 
This gives each individual test a clean cache, with minimal overhead (only a next() call, which has been bound to a local to avoid the global name lookup penalty).