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

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

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 完成

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 资源、避免阻塞其它业务
缺点：上下文切换成本较高，编程复杂度较高，需要管理大量线程

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."));
    }
}

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、调试复杂：由于异步操作的非顺序执行，调试和错误处理变得更加复杂

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 协程完成
}