当然可以！其实很多人会把异步和多线程绑定在一起，但这完全是个误区——异步的核心是非阻塞的任务调度，多线程只是实现异步的其中一种手段而已，单线程环境下照样能写出地道的异步程序。下面我给你拆解几种常见的实现方式：

1. 单线程事件循环（最主流的方案） #

这是现在最常见的单线程异步实现，比如Node.js、浏览器的JavaScript引擎都是基于这个模型。它的核心逻辑是：

• 单线程维护一个任务队列，把所有需要处理的任务（包括I/O操作、回调函数）都放进队列里。
• 线程不断循环取出队列里的任务执行，遇到耗时的I/O操作（比如网络请求、文件读写）时，不原地阻塞等待，而是把这个操作交给操作系统去处理，自己继续执行队列里的下一个任务。
• 当操作系统完成I/O操作后，会把结果和对应的回调函数放回任务队列，线程下次循环到的时候再处理这个结果。

举个Node.js的简单例子，你就能明白：

const fs = require('fs');

// 非阻塞读取文件，注册回调函数
fs.readFile('example.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log('文件内容:', data);
});

// 这行代码会先打印，因为readFile不会阻塞主线程
console.log('正在处理其他任务...');

运行这段代码，你会先看到“正在处理其他任务...”，等文件读取完成后才会打印文件内容——全程都是单线程在跑，没有开启任何额外线程。

2. 协程（Coroutines）/纤程（Fibers） #

协程是用户态的“轻量级线程”，完全由程序自己调度，不需要操作系统介入，所以可以在单线程里实现多任务的异步切换。和线程不同，协程的切换开销极小，因为不需要操作系统保存线程上下文。

比如Python的async/await、Lua的coroutine，都是典型的单线程协程异步实现。举个Python的例子：

import asyncio

async def fetch_data():
    # 模拟耗时的网络请求（非阻塞）
    await asyncio.sleep(2)
    return "异步请求返回的数据"

async def main():
    print("程序启动")
    # 创建异步任务，但不阻塞主线程
    task = asyncio.create_task(fetch_data())
    print("主线程继续处理其他事情")
    # 等待任务完成并获取结果
    result = await task
    print(result)

asyncio.run(main())

这段代码里，fetch_data是一个协程，当执行到await asyncio.sleep(2)时，会主动让出CPU，让主线程去处理其他任务，等2秒后再回到这个协程继续执行——全程都是单线程，没有多线程的参与。

3. 信号驱动I/O（Unix/Linux系统专属） #

在Unix/Linux系统中，你可以给文件描述符注册信号，当I/O操作就绪时（比如有数据可读），操作系统会给进程发送SIGIO信号，程序在信号处理函数里处理I/O结果，主线程可以继续执行其他任务，完全不需要阻塞或者多线程。

比如用C语言实现的简单例子：

#include <stdio.h>
#include <signal.h>
#include <fcntl.h>
#include <unistd.h>

void sigio_handler(int signo) {
    char buf[1024];
    ssize_t n = read(STDIN_FILENO, buf, sizeof(buf)-1);
    if (n > 0) {
        buf[n] = '\0';
        printf("收到输入: %s", buf);
    }
}

int main() {
    // 注册SIGIO信号处理函数
    signal(SIGIO, sigio_handler);
    // 设置标准输入的所有者为当前进程
    fcntl(STDIN_FILENO, F_SETOWN, getpid());
    // 开启标准输入的异步模式
    int flags = fcntl(STDIN_FILENO, F_GETFL);
    fcntl(STDIN_FILENO, F_SETFL, flags | O_ASYNC);

    // 主线程可以一直执行其他逻辑
    while(1) {
        printf("主线程正在运行...\n");
        sleep(1);
    }
    return 0;
}

运行这段代码，主线程会每秒打印一次“主线程正在运行...”，当你在终端输入内容时，SIGIO信号会触发处理函数，读取并打印输入内容——全程单线程，没有多线程。

4. 轮询式非阻塞I/O #

这种方式是用select()、poll()或者epoll()这些系统调用，单线程不断轮询多个文件描述符，看哪个I/O操作就绪了就处理哪个，处理完继续轮询。早期的很多网络服务器都是用这种方式实现单线程处理多个连接的。

比如用select()实现的简单例子：

#include <stdio.h>
#include <sys/select.h>
#include <unistd.h>

int main() {
    fd_set read_fds;
    struct timeval tv;
    int ret;

    while(1) {
        FD_ZERO(&read_fds);
        FD_SET(STDIN_FILENO, &read_fds);

        // 设置轮询超时时间为1秒
        tv.tv_sec = 1;
        tv.tv_usec = 0;

        // 轮询标准输入是否就绪
        ret = select(STDIN_FILENO + 1, &read_fds, NULL, NULL, &tv);
        if (ret == -1) {
            perror("select error");
            return 1;
        } else if (ret == 0) {
            printf("超时，继续处理其他任务...\n");
        } else {
            if (FD_ISSET(STDIN_FILENO, &read_fds)) {
                char buf[1024];
                ssize_t n = read(STDIN_FILENO, buf, sizeof(buf)-1);
                if (n > 0) {
                    buf[n] = '\0';
                    printf("收到输入: %s", buf);
                }
            }
        }
    }
    return 0;
}

这段代码里，主线程不断用select()轮询标准输入，超时的话就打印“超时，继续处理其他任务...”，如果有输入就读取并打印——全程单线程，没有多线程。

总结一下 #

异步的本质是避免阻塞等待耗时操作，多线程只是让阻塞的任务在其他线程等待，而单线程异步则是让主线程不阻塞，把等待的工作交给操作系统或者自己的调度逻辑。现在很多高性能的服务端程序都是基于单线程事件循环或者协程实现的，反而比多线程更高效，因为少了线程上下文切换的开销。

内容的提问来源于stack exchange，提问作者Mandroid