Deno 并发编程-JavaScript中文网-JavaScript教程资源分享门户

Deno 是一个现代化的 JavaScript 和 TypeScript 运行时，它提供了许多现代功能和工具来简化开发者的日常工作。并发编程是现代应用开发中的一个重要部分，尤其是在处理 I/O 操作、网络请求和大量数据处理时。Deno 提供了多种方法来实现高效的并发编程。

协程（Coroutines）

协程是 Deno 中实现并发的一种方式。协程是一种轻量级的线程，可以由开发者手动调度。Deno 使用异步函数（async 函数）作为协程的基础。异步函数允许代码以非阻塞的方式运行，这使得它可以与其他代码并行执行。

异步函数基础

异步函数通过 await 关键字来暂停其执行，直到等待的 Promise 被解决。这种机制使得异步函数可以在等待 I/O 操作完成的同时让出执行权，从而提高程序的整体效率。

async function fetchData(url) {
    const response = await fetch(url);
    const data = await response.json();
    console.log(data);
}

fetchData("https://jsonplaceholder.typicode.com/todos/1");

在这个例子中，fetchData 函数会等待 fetch 请求完成，然后继续执行。如果在多个地方调用 fetchData，它们将会并行执行，而不是阻塞顺序执行。

并发执行多个任务

利用异步函数，我们可以轻松地并发执行多个任务。例如，如果我们需要同时从多个 URL 获取数据，我们可以创建多个异步函数实例，并同时启动它们。

// www.javascriptcn.com code example
async function fetchData(url) {
    const response = await fetch(url);
    const data = await response.json();
    return data;
}

async function main() {
    const urls = [
        "https://jsonplaceholder.typicode.com/todos/1",
        "https://jsonplaceholder.typicode.com/todos/2",
        "https://jsonplaceholder.typicode.com/todos/3"
    ];

    const results = await Promise.all(urls.map(fetchData));
    console.log(results);
}

main();

在这个例子中，Promise.all 方法用于并发执行多个 fetchData 调用，并且所有这些调用将同时开始，当所有的 Promise 都被解决后返回结果。

Promise 与并发

除了使用异步函数之外，我们还可以利用 JavaScript 的原生 Promise 来实现并发编程。Promise 可以帮助我们更好地管理异步操作的结果和错误处理。

使用 Promise.all

Promise.all 是一种常见的并发编程模式，它接受一个 Promise 数组作为参数，并返回一个新的 Promise，这个新的 Promise 在所有输入的 Promise 都解决后才会解决。如果任何一个 Promise 被拒绝，那么新的 Promise 也会立即被拒绝。

// www.javascriptcn.com code example
const promise1 = Promise.resolve(3);
const promise2 = 42;
const promise3 = new Promise((resolve, reject) => {
    setTimeout(resolve, 100, 'foo');
});

Promise.all([promise1, promise2, promise3]).then(values => {
    console.log(values); // 输出: [3, 42, "foo"]
});

使用 Promise.race

与 Promise.all 相对的是 Promise.race，它接收一个 Promise 数组，并返回一个新的 Promise，这个新的 Promise 在输入的 Promise 中第一个解决或被拒绝时就会解决或被拒绝。

const promise1 = new Promise((resolve, reject) => setTimeout(resolve, 500, 'one'));
const promise2 = new Promise((resolve, reject) => setTimeout(resolve, 100, 'two'));

Promise.race([promise1, promise2]).then(value => {
    console.log(value); // 输出: "two"
});

Channels 和消息传递

除了上述的方法之外，Deno 还提供了一个叫做 channels 的特性，它允许在不同的协程之间安全地传递消息。这在处理复杂的并发场景时特别有用。

创建 Channel

要创建一个 Channel，我们可以使用 Deno.channel 函数。这个函数返回一个具有 send 和 receive 方法的对象，可以用来发送和接收数据。

// www.javascriptcn.com code example
const channel = Deno.channel();

// 发送数据到通道
channel.send("Hello, Deno!");

// 接收通道中的数据
channel.receive().then(message => {
    console.log(message); // 输出: "Hello, Deno!"
});

使用 Channel 实现生产者-消费者模型

在并发编程中，生产者-消费者模型是一个非常常见的模式。在这个模式中，一个或多个生产者生成数据，并将其发送到共享资源（例如 Channel），而一个或多个消费者从这个共享资源获取数据并进行处理。

// www.javascriptcn.com code example
const channel = Deno.channel();

async function producer() {
    for (let i = 0; i < 5; i++) {
        await channel.send(`Message ${i}`);
        console.log(`Sent message ${i}`);
    }
}

async function consumer() {
    for (let i = 0; i < 5; i++) {
        const message = await channel.receive();
        console.log(`Received message: ${message}`);
    }
}

producer().then(() => console.log("Producer done"));
consumer().then(() => console.log("Consumer done"));

// 输出:
// Sent message 0
// Sent message 1
// Sent message 2
// Sent message 3
// Sent message 4
// Received message: Message 0
// Received message: Message 1
// Received message: Message 2
// Received message: Message 3
// Received message: Message 4

在这个例子中，producer 函数负责发送消息到 Channel，而 consumer 函数则负责从 Channel 接收消息。这两个函数都在异步环境中运行，从而实现了并发处理。

通过以上介绍，你可以看到 Deno 提供了丰富的并发编程工具，使得开发者能够更高效地处理复杂的应用场景。无论是通过异步函数、Promise 还是 Channels，都可以找到适合特定需求的并发解决方案。