任务

yield(t::Task, arg = nothing)

yield()

yieldto(t::Task, arg = nothing)

sleep(seconds)

schedule(t::Task, [val]; error=false)

julia> a5() = sum(i for i in 1:1000);

julia> b = Task(a5);

julia> istaskstarted(b)
false

julia> schedule(b);

julia> yield();

julia> istaskstarted(b)
true

julia> istaskdone(b)
true

errormonitor(t::Task)

julia> wait(errormonitor(Threads.@spawn error("task failed")); throw = false)
Unhandled Task ERROR: task failed
Stacktrace:
[...]

@sync

julia> Threads.nthreads()
4

julia> @sync begin
           Threads.@spawn println("Thread-id $(Threads.threadid()), task 1")
           Threads.@spawn println("Thread-id $(Threads.threadid()), task 2")
       end;
Thread-id 3, task 1
Thread-id 1, task 2

wait([x])

waitany(tasks; throw=true) -> (done_tasks, remaining_tasks)

waitall(tasks; failfast=true, throw=true) -> (done_tasks, remaining_tasks)

fetch(t::Task)

fetch(x::Any)

timedwait(testcb, timeout::Real; pollint::Real=0.1)

julia> cb() = (sleep(5); return);

julia> t = @async cb();

julia> timedwait(()->istaskdone(t), 1)
:timed_out

julia> timedwait(()->istaskdone(t), 6.5)
:ok

Condition()

Threads.Condition([lock])

lock(c)
try
    while !thing_we_are_waiting_for
        wait(c)
    end
finally
    unlock(c)
end

Event([autoreset=false])

notify(condition, val=nothing; all=true, error=false)

reset(::Event)

Semaphore(sem_size)

acquire(f, s::Semaphore)

s = Base.Semaphore(2)
@sync for _ in 1:100
    Threads.@spawn begin
        Base.acquire(s) do
            foo()
        end
    end
end

acquire(s::Semaphore)

release(s::Semaphore)

AbstractLock

lock(f::Function, l::Lockable)

lock(f::Function, lock)

lock(lock)

unlock(lock)

trylock(lock) -> Success (Boolean)

islocked(lock) -> Status (Boolean)

nspins = 0
while true
    while islocked(lock)
        GC.safepoint()
        nspins += 1
        nspins > LIMIT && error("timeout")
    end
    trylock(lock) && break
    backoff()
end

ReentrantLock()

lock(l)
try
    <atomic work>
finally
    unlock(l)
end

@lock l expr

lock(l)
try
    expr
finally
    unlock(l)
end

Lockable(value, lock = ReentrantLock())

julia> locked_list = Base.Lockable(Int[]);

julia> @lock(locked_list, push!(locked_list[], 1)) # must hold the lock to access the value
1-element Vector{Int64}:
 1

julia> lock(summary, locked_list)
"1-element Vector{Int64}"

AbstractChannel{T}

Channel{T=Any}(size::Int=0)

Channel{T=Any}(func::Function, size=0; taskref=nothing, spawn=false, threadpool=nothing)

julia> chnl = Channel() do ch
           foreach(i -> put!(ch, i), 1:4)
       end;

julia> typeof(chnl)
Channel{Any}

julia> for i in chnl
           @show i
       end;
i = 1
i = 2
i = 3
i = 4

julia> taskref = Ref{Task}();

julia> chnl = Channel(taskref=taskref) do ch
           println(take!(ch))
       end;

julia> istaskdone(taskref[])
false

julia> put!(chnl, "Hello");
Hello

julia> istaskdone(taskref[])
true

julia> chnl = Channel{Char}(1, spawn=true) do ch
           for c in "hello world"
               put!(ch, c)
           end
       end;

julia> String(collect(chnl))
"hello world"

put!(c::Channel, v)

take!(c::Channel)

julia> c = Channel(1);

julia> put!(c, 1);

julia> take!(c)
1

julia> c = Channel(0);

julia> task = Task(() -> put!(c, 1));

julia> schedule(task);

julia> take!(c)
1

isfull(c::Channel)

julia> c = Channel(1); # capacity = 1

julia> isfull(c)
false

julia> put!(c, 1);

julia> isfull(c)
true

julia> c = Channel(); # capacity = 0

julia> isfull(c) # unbuffered channel is always full
true

isready(c::Channel)

julia> c = Channel(1);

julia> isready(c)
false

julia> put!(c, 1);

julia> isready(c)
true

julia> c = Channel();

julia> isready(c)  # no tasks waiting to put!
false

julia> task = Task(() -> put!(c, 1));

julia> schedule(task);  # schedule a put! task

julia> isready(c)
true

isopen(c::Channel)

julia> c = Channel(ch -> put!(ch, 1), 1);

julia> isopen(c) # The channel is closed to new `put!`s
false

julia> isready(c) # The channel is closed but still contains elements
true

julia> take!(c)
1

茱莉亚>已准备好(c)
错误

julia> c = Channel{Int}();

julia> isopen(c)
true

julia> close(c)

julia> isopen(c)
false

fetch(c::Channel)

julia> c = Channel(3) do ch
           foreach(i -> put!(ch, i), 1:3)
       end;

julia> fetch(c)
1

julia> collect(c)  # item is not removed
3-element Vector{Any}:
 1
 2
 3

close(c::Channel[, excp::Exception])

bind(chnl::Channel, task::Task)

julia> c = Channel(0);

julia> task = @async foreach(i->put!(c, i), 1:4);

julia>绑定（c，任务）;

朱莉娅>对于我在c
           @展示我
       结束;
i=1
i=2
i=3
i=4

朱莉娅>isopen（c）
错误

julia> c = Channel(0);

julia> task = @async (put!(c, 1); error("foo"));

julia> bind(c, task);

julia> take!(c)
1

julia> put!(c, 1);
ERROR: TaskFailedException
Stacktrace:
[...]
    nested task error: foo
[...]