说明：本文是cuda.jl官方的doc，中文为google机翻。
本文涉及到的知识：

同步：CPU和GPU是不同的设备，CPU在调用GPU的时候，它把一个计算任务发给GPU，然后在线等待GPU的这个计算结果，然后再执行后面的步骤，这就是同步。举例就是：项目经理让你改bug，然后在线等，让你把改好的程序版本发给他，他才能做后面的事情。假如你的程序有10个bug，而且只有你能改，这时，项目经理监督你，让你改一个bug然后汇报一次，直到全部的bug改完，这就是同步。

异步：假如你有多个计算任务，它们没有先后的逻辑关系，也就是说这些任务是可以同时开展的，那么这些步骤就是可以同时执行的任务。比如现在你要对十个不相干的array用GPU进行计算，而且这些计算之间没有先后逻辑关系，这时，CPU一次性把这十个任务丢给GPU去执行。

====以下是 doc文档的机翻原文====

任务和线程

CUDA.jl 可以与 Julia 任务和线程一起使用，提供一种方便的方式来处理多个设备，或者执行可以在 GPU 上并发执行的独立计算。

基于任务的编程

每个 Julia 任务都有自己的本地 CUDA 执行环境，有自己的流、库句柄和活动设备选择。这使得每个设备可以轻松使用一项任务，或者将任务用于可以重叠的独立操作。同时，在任务之间共享数据时务必小心。

例如，让我们进行一些虚拟的昂贵计算并从两个任务中执行它：

# an expensive computation
function compute(a, b)
    c = a * b             # library call
    broadcast!(sin, c, c) # Julia kernel
    c
end

function run(a, b)
    results = Vector{Any}(undef, 2)

    # computation
    @sync begin
        @async begin
            results[1] = Array(compute(a,b))
            nothing # JuliaLang/julia#40626
        end
        @async begin
            results[2] = Array(compute(a,b))
            nothing # JuliaLang/julia#40626
        end
    end

    # comparison
    results[1] == results[2]
end

我们使用熟悉的 Julia 构造来创建两个任务并在之后重新同步（@async和@sync），而虚拟compute函数演示了库（矩阵乘法使用 CUBLAS）和原生 Julia 内核的使用。该函数传递了三个填充随机数的 GPU 数组：

function main(N=1024)
    a = CUDA.rand(N,N)
    b = CUDA.rand(N,N)

    # make sure this data can be used by other tasks!
    synchronize()

    run(a, b)
end

该main函数说明了我们在任务之间共享数据时需要注意的事项：GPU 操作通常异步执行，在执行流上排队，因此如果我们切换任务并因此切换执行流，我们需要synchronize()确保数据实际上可用。

使用 Nsight Systems，我们可以可视化此示例的执行情况：

“使用多个任务分析重叠执行

您可以看到两次调用如何compute导致重叠执行。然而，内存副本是串行执行的。这是预期的：常规 CPU 阵列不能用于异步操作，因为它们的内存不是页面锁定的。对于大多数应用程序，这并不重要，因为计算时间通常比复制内存的时间要长得多。

如果您的应用程序需要在 CPU 和 GPU 之间执行多次复制，则“固定”CPU 内存可能会有所帮助，以便可以进行异步内存复制。但是，此操作很昂贵，并且只有在您可以预先分配和重用 CPU 缓冲区时才应该使用。应用于前面的例子：

function run(a, b)
    results = Vector{Any}(undef, 2)

    # pre-allocate and pin destination CPU memory
    results[1] = Mem.pin(Array{eltype(a)}(undef, size(a)))
    results[2] = Mem.pin(Array{eltype(a)}(undef, size(a)))

    # computation
    @sync begin
        @async begin
            copyto!(results[1], compute(a,b))
            nothing # JuliaLang/julia#40626
        end
        @async begin
            copyto!(results[2], compute(a,b))
            nothing # JuliaLang/julia#40626
        end
    end

    # comparison
    results[1] == results[2]
end

“使用多个任务和固定内存分析重叠执行

配置文件显示内存副本本身不能重叠，但第一个副本是在 GPU 仍处于活动状态时执行第二轮计算。此外，副本的执行速度要快得多——如果内存未固定，则无论如何首先必须将其暂存到固定的 CPU 缓冲区。

多线程

使用 Threads 标准库中的功能可以轻松地将任务的使用扩展到多个线程：

function run(a, b)
    results = Vector{Any}(undef, 2)

    # computation
    @sync begin
        Threads.@spawn begin
            results[1] = Array(compute(a,b))
            nothing # JuliaLang/julia#40626
        end
        Threads.@spawn begin
            results[2] = Array(compute(a,b))
            nothing # JuliaLang/julia#40626
        end
    end

    # comparison
    results[1] == results[2]
end

通过使用Threads.@spawn宏，任务将被安排在不同的 CPU 线程上运行。当您在 CUDA 中调用许多“阻塞”的操作时，这会很有用，例如，将内存复制到未固定内存或从未固定内存复制。不过，一般来说，同步 GPU 执行的操作（包括对synchronize自身的调用）的实现方式是将它们交还给 Julia 调度程序，以便在不需要使用不同 CPU 线程的情况下启用并发执行。

警告
在 CUDA.jl 中使用多线程是最近添加的，可能仍然存在错误或性能问题。