分布式计算 #

using Distributed

addprocs(4)
nprocs()
workers()
rmprocs(workers())

julia -p 4

using Distributed

addprocs(2)

r = remotecall(() -> myid(), 2)
fetch(r)

remotecall_fetch(() -> myid(), 2)

using Distributed

addprocs(2)

r = remotecall((x) -> x^2, 2, 5)
fetch(r)

remotecall_wait((x) -> x^2, 2, 5)

remotecall_fetch((x) -> x^2, 2, 5)

using Distributed

addprocs(2)

r = @spawn sum(rand(1000))
fetch(r)

r = @spawnat 2 sum(rand(1000))
fetch(r)

using Distributed

addprocs(2)

r = remotecall(() -> rand(5), 2)
typeof(r)
fetch(r)

using Distributed

addprocs(2)

ch = RemoteChannel(() -> Channel{Int}(10))

put!(ch, 1)
take!(ch)

using Distributed

addprocs(2)

@everywhere data = [1, 2, 3, 4, 5]

r = @spawn sum(data)
fetch(r)

using Distributed

addprocs(2)

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

using Distributed

addprocs(2)

@distributed (+) for i in 1:100
    i^2
end

using Distributed

addprocs(2)

@distributed for i in 1:10
    println("Worker $(myid()) processing $i")
end

using Distributed

addprocs(4)

function parallel_sum(arr)
    @distributed (+) for x in arr
        x
    end
end

parallel_sum(1:10^6)

using Distributed

addprocs(4)

@everywhere function monte_carlo_pi(n)
    hits = 0
    for _ in 1:n
        x, y = rand(), rand()
        if x^2 + y^2 <= 1
            hits += 1
        end
    end
    return hits
end

function parallel_monte_carlo_pi(total_n)
    n_per_worker = total_n ÷ nworkers()
    results = pmap(_ -> monte_carlo_pi(n_per_worker), 1:nworkers())
    total_hits = sum(results)
    return 4 * total_hits / total_n
end

parallel_monte_carlo_pi(10^7)

using Distributed

addprocs(2)

function distributed_queue(jobs)
    results = RemoteChannel(() -> Channel{Any}(length(jobs)))
    
    @async begin
        for job in jobs
            put!(results, @spawn process_job(job))
        end
    end
    
    return [fetch(take!(results)) for _ in 1:length(jobs)]
end

@everywhere function process_job(x)
    sleep(0.1)
    x^2
end

distributed_queue([1, 2, 3, 4, 5])