Should I be using task.spawn() or coroutines?

[KashTheKing (Kash)]

My question is, should I be using coroutines to create separate threads or task.spawn? Which one is safer to use in case of memory leaks and better for performance?

[OnceCrowned]

It depends on the use case.

coroutines have much more functionality than task.spawn and have more use cases. for most people, task.spawn does the job best for general purposes

[MagmaBurnsV]

Coroutine

The coroutine library provides more functionality such as thread state at the cost of convenience. Threads ran via coroutine.wrap or coroutine.resume do not get tagged in the debug traceback, meaning errors that occur in the thread’s function get obscured. You also have to handle the execution of threads manually, and cannot utilize Roblox’s TaskScheduler without using the task library

Task

The task library provides convenience at the expense of less functionality to work with (ex: task.cancel does not return the thread’s state like coroutine.close). It allows you to execute threads in conjunction to the rest of the engine’s task scheduler, allowing you to reason more with the flow of things.

The task library has 3 “spawner” functions: task.spawn, task.delay and task.defer. Here’s a basic summary of how they differ:

Function	Description
task.spawn	Spawns the thread immediately. It can also resume “dead” threads unlike coroutine.resume.
task.delay	Spawns the thread after the given duration in seconds, or immediately if nil is given.
task.defer	Spawns the thread during the next resumption cycle as opposed to immediately. What this means is certain engine mechanics like parent-locking will finish before it is executed.

---

Generally, you will use the task library more often, but threads can be handled with both libraries interchangeably.

[KashTheKing (Kash)]

Thank you, this explained the functionality differences perfectly.
However, are there any differences in the 2 with performance?

[Ar_Link (Ardev)]

I don’t think there is necessarily any performance differences between the two although task.spawn runs through the scheduler and coroutines run alongside a thread.

[bt6k (beetee)]

I would also like to point out that parallel lua (a very good structure to learn) is primarily ran with the task library. It also is easier, in my opinion, to halt tasks with libraries such as Maid and Janitor.

[Fizzitix (69Goat)]

With task.defer there is.

Basically, using task.spawn and coroutine.create or coroutine.wrap will create/resume the thread immediately (within the same frame). This can cause small performance issues for obvious reasons.
However, task.defer will create/resume the thread on the next “resumption cycle”, which is still almost immediate, but won’t cause those small performance issues.