多线程 #

export JULIA_NUM_THREADS=4
julia

julia --threads=4

using Base.Threads

nthreads()
threadid()

using Base.Threads

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

using Base.Threads

function parallel_sum(arr)
    total = Threads.Atomic{Int}(0)
    @threads for x in arr
        Threads.atomic_add!(total, x)
    end
    return total[]
end

parallel_sum(1:1000)

using Base.Threads

function thread_local_example()
    locals = [0 for _ in 1:nthreads()]
    
    @threads for i in 1:100
        locals[threadid()] += 1
    end
    
    return locals
end

thread_local_example()

using Base.Threads

counter = Threads.Atomic{Int}(0)

@threads for _ in 1:1000
    Threads.atomic_add!(counter, 1)
end

counter[]

using Base.Threads

lock = ReentrantLock()
counter = 0

@threads for _ in 1:1000
    Base.lock(lock)
    try
        counter += 1
    finally
        Base.unlock(lock)
    end
end

counter

using Base.Threads

function thread_safe_push()
    lock = ReentrantLock()
    results = Int[]
    
    @threads for i in 1:100
        Base.lock(lock)
        try
            push!(results, i)
        finally
            Base.unlock(lock)
        end
    end
    
    return results
end

using Base.Threads

function parallel_map(f, arr)
    results = similar(arr, Any)
    @threads for i in eachindex(arr)
        results[i] = f(arr[i])
    end
    return results
end

parallel_map(x -> x^2, [1, 2, 3, 4, 5])

using Base.Threads

function parallel_reduce(f, arr, init)
    n = nthreads()
    partial = [init for _ in 1:n]
    
    @threads for i in eachindex(arr)
        partial[threadid()] = f(partial[threadid()], arr[i])
    end
    
    return reduce(f, partial)
end

parallel_reduce(+, 1:1000, 0)

using Base.Threads

function parallel_fib(n)
    if n < 30
        return n <= 1 ? n : parallel_fib(n-1) + parallel_fib(n-2)
    end
    
    t = @task parallel_fib(n - 1)
    schedule(t)
    y = parallel_fib(n - 2)
    return fetch(t) + y
end

using Base.Threads

function parallel_matrix_multiply(A, B)
    rows_A, cols_A = size(A)
    rows_B, cols_B = size(B)
    
    C = zeros(rows_A, cols_B)
    
    @threads for i in 1:rows_A
        for j in 1:cols_B
            for k in 1:cols_A
                C[i, j] += A[i, k] * B[k, j]
            end
        end
    end
    
    return C
end

using Base.Threads

function parallel_process_files(files)
    results = Vector{String}(undef, length(files))
    
    @threads for i in eachindex(files)
        results[i] = read(files[i], String)
    end
    
    return results
end

using Base.Threads

function parallel_monte_carlo_pi(n)
    hits = Threads.Atomic{Int}(0)
    
    @threads for _ in 1:n
        x, y = rand(), rand()
        if x^2 + y^2 <= 1
            Threads.atomic_add!(hits, 1)
        end
    end
    
    return 4 * hits[] / n
end

parallel_monte_carlo_pi(10^7)