Updated for: threadrecycler@0.3.0-a.4

Important: Manually recycling vs. automatically recycling

The accompanying function MUST HAVE a thread parameter whether you’re recycling or not.

Automatically recycling

ThreadPool.spawn(ThreadPool, function(thread, ...)
    print("Thread executed")
end)

local function foo(thread, ...)
    print("foo")
end)
ThreadPool.spawn(ThreadPool, foo, ...)

Manually recycling

ThreadPool.spawn(ThreadPool, function(thread, ...)
    print("Thread executed")
    ThreadPool.recycle(ThreadPool, thread) -- once you are finished
end)

local function foo(thread, ...)
    print("Thread executed")
    ThreadPool.recycle(ThreadPool, thread)
end)
ThreadPool.spawn(ThreadPool, foo, ...)

API Reference

ThreadRecycler.construct()

ThreadRecycler.construct(Config: {})

Creates a ThreadPool.

local ThreadPool = ThreadRecycler.construct({
    ["InitialThreadCount"] = 60, -- initial thread count 
	["CachedLifetime"] = 60,  -- cached lifetime 
	["EnableStatRecording"] = true, -- enables recording of stats 
	["Logger"] = warn, -- log method; doesn't do anything right now. Coming in the future... 
	["Debug"] = false -- debug configuration. Doesn't do anything right now. Coming in the future... 
})

ThreadPool.autocompatible()

ThreadPool.autocompatible(ThreadPool, callback: function, ...: any) -> boolean, number | string)

Checks whether the function can support auto recycling.

local function foo(thread, ...)
    print("Thread executed")
end)
ThreadPool.autocompatible(ThreadPool, foo, ...) -- > ThreadRecycler: This function supports auto-recycling!

ThreadPool.wrap()

ThreadPool.wrap(ThreadPool, callback: function, ...: any)

Creates and runs a thread using coroutine.create() and coroutine.resume().

ThreadPool.wrap(ThreadPool, function(thread) -- function(index: number) if use signal == true
    print("Thread executed")
end)

ThreadPool.spawn()

ThreadPool.spawn(ThreadPool, callback: function, ...: any)

Creates and runs a thread immediately using task.spawn().

ThreadPool.spawn(ThreadPool, function(thread)
    print("Thread executed")
end)

ThreadPool.defer()

ThreadPool.defer(ThreadPool, callback: function, ...: any)

Executes a function on the next RunService.Heartbeat.

ThreadPool.defer(ThreadPool, function(thread)
    print("Deferred execution")
end)

ThreadPool.gooddefer()

ThreadPool.gooddefer(ThreadPool, callback: function, ...: any)

Executes a function on the next RunService.Heartbeat. Works the same way as ThreadRecycler.defer, but doesn’t have a function overhead.

ThreadPool.gooddefer(ThreadPool, function(thread)
    print("Executed on Heartbeat")
end)

ThreadPool.unsafedefer()

ThreadPool.unsafedefer(ThreadPool, callback: function, ...: any) Uses task.defer() to execute the function at the end of the current execution cycle.

ThreadPool.unsafedefer(ThreadPool, function()
    print("Unsafe defer execution")
end)

ThreadPool.unsafedelay()

ThreadPool.unsafedelay(ThreadPool, time: number, callback: function, ...: any)

Uses task.delay() to execute the function after some time has been elapsed.

ThreadPool.unsafedelay(ThreadPool, 1, function(thread)
    print("Unsafe delay execution")
end)

ThreadPool.delay()

ThreadPool.delay(ThreadPool, time: number, callback: function, ...: any)

Uses ThreadRecycler.wait() to execute the function after some time has been elapsed.

ThreadPool.delay(ThreadPool, 1, function(thread)
    print("Defer execution")
end)

ThreadPool.wait()

ThreadPool.wait(seconds: number | nil)

Pauses execution for a set duration using os.clock().

ThreadPool.wait(2) -- Waits for 2 seconds

ThreadPool.recycle()

ThreadPool.recycle(ThreadPool, thread)

Recycles a thread back into the pool.

ThreadRecycler.recycle(thread) -- Recycle thread 

ThreadPool.getstat()

ThreadPool.getstat(ThreadPool, stat: string) -> boolean, number | string)

Retrieves statistics about thread usage. Works on Count, Recycled, and Created.

local success, count = ThreadPool.getstat(ThreadPool, "Count") -- functions like a pcall
if success then
    print("Active threads:", count)
end