Julia Concurrency Guide — Coroutines, Threads, and Parallel Computing

In this tutorial, you will learn about Julia Concurrency Guide. We cover key concepts, practical examples, and best practices to help you master this topic.

Julia concurrency offers Tasks (green threads with yield/schedule), Threads (Threads.@threads for shared memory), Channels for communication, and Distributed with @everywhere and @distributed for multi-node parallel computing across processes.

Tasks (Coroutines)

# Create a task
function producer(c::Channel)
    for i in 1:5
        put!(c, i^2)
    end
end

# Process with task
task = Task(() -> begin
    for i in 1:5
        println("Task: $i")
        yield()  # cooperative multitasking
    end
end)

schedule(task)
wait(task)

Channels

# Channel for communication
c = Channel{Int}(10)

# Producer
@async begin
    for i in 1:5
        put!(c, i)
        sleep(0.5)
    end
    close(c)
end

# Consumer
for value in c
    println("Got: $value")
end

Threads

using Base.Threads

# Parallel for loop
@threads for i in 1:10
    println("Thread $(threadid()) processing $i")
end

# Atomic operations
counter = Atomic{Int}(0)
@threads for i in 1:1000
    atomic_add!(counter, 1)
end
println(counter[])  # 1000

# Thread-local variables
data = zeros(10)
@threads for i in 1:10
    # Each thread works on independent work
    data[i] = threadid()
end

Distributed Computing

using Distributed
addprocs(4)  # add 4 worker processes

@everywhere using DataFrames

# Parallel map
results = @distributed (vcat) for i in 1:100
    (i, i^2)
end

# Fetch results
results = pmap(i -> i^2, 1:100)

Common Mistakes

1. Race conditions

Shared mutable state without synchronization causes race conditions. Use atomic operations or Channels.

2. Thread Safety of libraries

Not all Julia libraries are thread-safe. Check documentation before using @threads with third-party packages.

3. Overhead of parallelization

Small tasks have overhead that exceeds parallel speedup. @threads is useful for workloads > 10ms per iteration.

Practice Questions

1. How do you create a basic task? Task(() -> ...) or @async begin ... end. Schedule with schedule(task).

2. How do you parallelize a for loop? Use Threads.@threads for i in 1:N ... end. Set JULIA_NUM_THREADS env var.

3. How do you communicate between tasks? Use Channel{T}(). put! to send, take! or iterate to receive.

FAQ

{{< faq question="What is the difference between @async and @threads?" >}} @async creates a cooperative task on the same thread. @threads distributes work across multiple OS threads. {{< /faq >}}

{{< faq question="How do I set the number of threads?" >}} Set JULIA_NUM_THREADS=4 before starting Julia, or use julia -t 4. {{< /faq >}}

{{< faq question="What is a Channel?" >}} A thread-safe queue for sending data between tasks. Can be bounded or unbounded. Supports iteration. {{< /faq >}}

What's Next

Now learn about Metaprogramming in Julia.