什么是协程？协程和线程的区别

文章目录

前置知识
- 应用程序和内核
- 阻塞和非阻塞
- 同步和异步
- 并发和并行
- IO 发展历史
- - 同步编程
  - 异步多线程/进程
  - 异步消息 + 回调函数（响应式编程）
协程
- 协程基本概念
- `go` 示例代码
- 协程和线程的区别
个人简介

前置知识

在了解协程前，我们先理解一些相关的基本知识。

应用程序和内核

内核具有最高权限，可以访问受保护的内存空间，可以访问底层的硬件设备。而这些是应用程序所不具备的，但应用程序可以通过调用内核提供的接口来间接访问或操作。
以一次网络 IO 操作为例，请求的数据会先被拷贝到系统内核的缓冲区（内核空间），然后再从内核缓冲区拷贝到应用程序的地址空间（用户空间）。这个过程包括两个阶段：

1、等待数据准备: 数据从网络接口读取并放入内核缓冲区。
2、拷贝数据: 数据从内核缓冲区复制到应用程序的用户空间。

阻塞和非阻塞

从上面我们可以清楚的知道， 一次 IO 操作 操作流程分为两步：等待数据准备、拷贝数据，若等待数据准备过程是阻塞的，则我们称为阻塞操作；若不必等待数据准备完成，而是返回是否就绪标志，则称为非阻塞。

同步和异步

用户线程发起 IO 操作，阻塞等待 IO 操作完成，则操作是同步的；若用户发起 IO 操作，不必等待操作完成，等待内核完成 IO 操作后通知用户线程，则为异步，如常见的 aio_read 函数。

并发和并行

并发（concurrency）：逻辑上具备同时处理多个任务的能力。
并行（parallesim）：物理上在同一时刻执行多个并发任务，依赖多核处理器等物理设备。

IO 发展历史

在没有协程的时代，处理 IO 操作我们一般使用下面三种方式：

同步编程

应用程序阻塞等待IO结果（比如等待打开一个大的文件，或者等待远端服务器的响应）。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class SynchronousIO {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

优点：编程简单，方便理解
缺点：阻塞读取，效率低下，与 IO 无关的操作也需要等待 IO 完成

异步多线程/进程

将IO操作频繁的逻辑、或者单纯的IO操作独立到一/多个线程中，业务线程与IO线程间靠通信/全局变量来共享数据。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class AsynchronousMultiThreadIO {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(4);

        executor.submit(() -> {
            try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    System.out.println(line);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        });

        executor.shutdown();
    }
}

优点：多线程处理，提高系统响应速度；充分利用 CPU 资源、避免阻塞其它业务
缺点：上下文切换成本较高，编程复杂度较高，需要管理大量线程

异步消息 + 回调函数（响应式编程）

在响应式编程中，IO 操作是非阻塞的，并且通过回调函数来处理结果。
示例代码（使用 CompletableFuture）

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.concurrent.CompletableFuture;

public class AsynchronousCallbackIO {
    public static void main(String[] args) {
        CompletableFuture.runAsync(() -> {
            try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    System.out.println(line);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).thenRun(() -> System.out.println("File reading completed."));
    }
}

示例代码（使用 Reactor）：

import reactor.core.publisher.Mono;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class ReactiveIO {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");
        Mono.fromCallable(() -> Files.readString(path))
            .subscribe(content -> System.out.println(content),
                       error -> error.printStackTrace(),
                       () -> System.out.println("File reading completed."));
    }
}

优点：
1、相比多线程 IO，响应式编程的资源开销更低，能够更好地利用系统资源
2、响应式编程模型适合处理高并发、高吞吐量的应用，便于扩展和维护

缺点：
1、学习曲线陡峭：响应式编程需要理解异步编程和回调机制，对于初学者来说可能比较困难
2、调试复杂：由于异步操作的非顺序执行，调试和错误处理变得更加复杂

协程

协程基本概念

维基百科定义：Coroutines are computer program components that generalize subroutines for non-preemptive multitasking, by allowing multiple entry points for suspending and resuming execution at certain locations. Coroutines are well-suited for implementing more familiar program components such as cooperative tasks, exceptions, event loops, iterators, infinite lists and pipes.
中文翻译：协程是一种计算机程序组件，它通过允许多个入口点在特定位置暂停和恢复执行，将非抢占式多任务的子程序进行了一般化。协程非常适合实现更熟悉的程序组件，如协作任务、异常、事件循环、迭代器、无限列表和管道。
简而言之：协程（Goroutines）是一种轻量级的并发编程模型，由编程语言或运行时环境管理，用于执行并发任务。与传统的操作系统线程相比，协程更轻量级，切换开销更小，因此在高并发场景中非常高效。协程在许多现代编程语言中都有实现，包括 Go、Python、JavaScript（在某种程度上通过异步函数和生成器）等。
协程从一定程度来讲，可以说是“用同步的语义解决异步问题”，即业务逻辑看起来是同步的，但实际上并不阻塞当前线程（一般是靠事件循环处理来分发消息）。

`go` 示例代码

下面是一个使用 Go 协程协作的示例，这个示例展示了如何使用 sync.WaitGroup 和 channel 来实现协程之间的协作：

package main

import (
	"fmt"
	"sync"
	"time"
)

// 定义一个 WaitGroup 以等待所有协程完成
var wg sync.WaitGroup

// 定义两个 channel 用于协程间的通信
var ch1 = make(chan int)
var ch2 = make(chan int)

func worker1() {
	defer wg.Done() // 在函数结束时减少 WaitGroup 计数
	for i := 0; i < 5; i++ {
		fmt.Println("Worker 1: Sending", i)
		ch1 <- i // 将数据发送到 ch1
		time.Sleep(500 * time.Millisecond)
	}
	close(ch1) // 关闭 channel，通知 worker2 没有更多数据
}

func worker2() {
	defer wg.Done() // 在函数结束时减少 WaitGroup 计数
	for {
		val, ok := <-ch1 // 从 ch1 接收数据
		if !ok {
			break // 如果 ch1 已关闭，退出循环
		}
		fmt.Println("Worker 2: Received", val)
		fmt.Println("Worker 2: Sending", val*val)
		ch2 <- val * val // 将数据发送到 ch2
		time.Sleep(500 * time.Millisecond)
	}
	close(ch2) // 关闭 channel，通知 main 没有更多数据
}

func main() {
	// 启动 worker1 和 worker2 协程
	wg.Add(2)
	go worker1()
	go worker2()

	// 在主协程中从 ch2 接收数据
	go func() {
		for val := range ch2 {
			fmt.Println("Main: Received", val)
		}
	}()

	wg.Wait() // 等待所有 worker 协程完成
}