协程和线程的区别、协程原理与优缺点分析、在Java中使用协程

最新推荐文章于 2025-06-04 21:55:15 发布

程序员bling

最新推荐文章于 2025-06-04 21:55:15 发布

阅读量4.4k

点赞数 5

CC 4.0 BY-SA版权

分类专栏：性能优化文章标签： java 数据结构 jvm

本文链接：https://blog.youkuaiyun.com/wangliangluang/article/details/128652595

性能优化专栏收录该内容

6 篇文章

订阅专栏

文章介绍了协程的概念，将其与线程进行了对比，强调协程的轻量级特性和高效性。文章以Java的Kilim框架为例，展示了如何在Java中实现和使用协程，通过生产者-消费者案例说明了协程的并发执行和通信机制。并提到了Go语言中成熟的Goroutines实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

什么是协程

相对于协程，你可能对进程和线程更为熟悉。进程一般代表一个应用服务，在一个应用服务中可以创建多个线程，而协程是一个轻量级线程,我们知道线程是CPU调度的基本单位,也就是说它是由CPU进行调度的,而协程的调度由用户空间中其专属的调度器控制的,这是一个很大的不同.我们可以在一个主线程里面轻松创建多个协程。

上面提到的协程专属的调度器其实就是程序员自己写的一个东西,不属于操作系统的,只是用来调度协程的,但是协程的执行其实还是由线程执行的,协程可以认为是运行在线程上的代码块.
这里举个例子假如人就是一个线程,那么协程就是具体的做某一件事情,一个人可以并发的做好几件事情,比如说可以同时煮饭,热水,听歌等等,这些事情可能我们就只需要偶尔操作一下,不需要完全占用我们的时间,就类似于我们的IO密集型任务,比较适合协程来做. 而其他的任务,比如说跑步,需要一直占用我们的时间,类似于CPU密集型任务,就不适合协程来做.

在对协程进行调度时,可以通过暂停或者阻塞的方式将协程的执行挂起，而其它协程可以继续执行。这里的挂起只是在程序中（用户态）的挂起，同时将代码执行权转让给其它协程使用，待获取执行权的协程执行完成之后，将从挂起点唤醒挂起的协程协程的挂起和唤醒是通过一个调度器来完成的。

协程的优点与缺点

优点:

协程是轻量级线程,全部都在用户态,因此系统消耗资源非常低,非常高效.不像线程一样是内核线程,由cpu调度,造成上下文切换,浪费资源.
线程实现数据共享的方式是共享内存,而协程是通信,这就避免了线程安全的问题,避免了锁竞争.

缺点:

系统是察觉不到协程的存在的，所以只有一个处理器内核会被分配给该进程，也就不能发挥多核 CPU 的优势,所以协程适用于I/O 阻塞型场景.不适用于cpu密集型.

协程实现原理.

这里还是对比着线程来说.

线程是被内核所调度,线程被调度切换到另一个线程上下文的时候,需要保存一个用户线程的状态到内存(切出),恢复另一个线程状态到寄存器(切入),然后更新调度器的数据结构,这几步操作涉及到用户态到内核态的切换,开销比较多.

那协程是怎样被调度?被执行的呢?

它其实是完全在用户空间实现了自己的一套调度器,上下文存储,以及任务载体等等这些,相当于我直接在用户空间就能完成程序的调度与切换,完全没有内核切换的开销.
协程的执行其实还是依靠线程来执行的.所以,同一时间, 在多核处理器的环境下, 多个线程是可以并行的，但是运行的协程的函数却只能有一个，其他的协程的函数都被suspend, 即协程是并发的.

协程与线程在不同编程语言的实现

Go语言最近非常火,国内很多互联网公司开始使用或转型 Go 语言，其中一个很重要的原因就是 Go 语言优越的性能表现，而这个优势与 Go 实现的轻量级线程 Goroutines（协程 Coroutine）不无关系.
Golang 在语言层面实现了对协程的支持，Goroutine 是协程在 Go 语言中的实现，在 Go 语言中每一个并发的执行单元叫作一个 Goroutine ，Go 程序可以轻松创建成百上千个协程并发执行。

JDK 1.8 Thread.java 中 Thread#start 方法的实现，实际上是通过 Native 调用 start0 方法实现的；在 Linux 下， JVM Thread 的实现是基于 pthread_create 实现的，而 pthread_create 实际上是调用了 clone() 完成系统调用创建线程的。也就是创建的是内核线程.目前 Java 原生语言暂时还不支持协程.

在Java中使用协程

Kilim介绍

虽然目前 Java 原生语言暂时还不支持协程。不过也不用泄气，我们可以通过协程框架在 Java 中使用协程。

目前 Kilim 协程框架在 Java 中应用得比较多，通过这个框架，开发人员就可以低成本地在 Java 中使用协程了。

Kilim 框架包含了四个核心组件，分别为：任务载体（Task）、任务上下文（Fiber）、任务调度器（Scheduler）以及通信载体（Mailbox）。
在这里插入图片描述
任务载体Task:
Task对象主要用来执行业务逻辑,我们可以把这个比作多线程的Thread,与Thread类似,Task中也有一个run方法,不过在Task中方法名为execute,我们可以将协程里面要做的业务逻辑操作写在execute方法中.

与 Thread 实现的线程一样，Task 实现的协程也有状态，包括：Ready、Running、Pausing、Paused 以及 Done 总共五种。Task 对象被创建后，处于 Ready 状态，在调用 execute() 方法后，协程处于 Running 状态，在运行期间，协程可以被暂停，暂停中的状态为 Pausing，暂停后的状态为 Paused，暂停后的协程可以被再次唤醒。协程正常结束后的状态为 Done。

任务上下文Fiber:
Fiber 对象与 Java 的线程栈类似，主要用来维护 Task 的执行堆栈，对于实现协程切换很关键.

任务调度器Scheduler:
Scheduler是实现协程的核心调度器,Scheduler负责分派Task给指定的工作者线程执行,工作者线程默认初始化个数为机器的CPU个数.

邮箱Mailbox:
Mailbox对象类似一个邮箱,协程之间可以依靠邮箱来进行通信和数据共享,这里和线程是很大的区别,因为线程是共享内存来实现

Kilim整合Java,使用举例

这里我们实现一个简单的生产者和消费者的案例.

引入maven

        <dependency>
            <groupId>org.db4j</groupId>
            <artifactId>kilim</artifactId>
            <version>2.0.1-jdk7</version>
        </dependency>

代码实现

消费者:

public class Consumer extends Task<Object> {

	Mailbox<Integer> mb = null;

	public Consumer(Mailbox<Integer> mb) {
		this.mb = mb;
	}

	/**
	 * 执行
	 */
	public void execute() throws Pausable {
		Integer c = null;
		for (int i = 0; i < 10; i++)  {
			c = mb.get();//获取消息，阻塞协程
			
			if (c == null) {
				System.out.println("计数");
			}else {
				System.out.println(Thread.currentThread().getName() + "消费者消费，目前总共有" + mb.size() + "消费了：" + c);
				c = null;
			}
		}
	}
	
}

生产者:

public class Producer extends Task<Object> {

	Integer count = null;
	Mailbox<Integer> mb = null;

	public Producer(Integer count, Mailbox<Integer> mb) {
		this.count = count;
		this.mb = mb;
	}

	public void execute() throws Pausable {
		count = count*10;
		for (int i = 0; i < 10; i++) {
			mb.put(count);//当空间不足时，阻塞协程线程
			System.out.println(Thread.currentThread().getName() + "生产者生产，目前总共有" + mb.size() + "生产了：" + count);
			count++;
		}
	}
	
}

主类:

public class Coroutine  {

	static Map<Integer, Mailbox<Integer>> mailMap = new HashMap<Integer, Mailbox<Integer>>();

	public static void main(String[] args) {

		if (kilim.tools.Kilim.trampoline(false,args)) return;
		Properties propes = new Properties();
		propes.setProperty("kilim.Scheduler.numThreads", "4");
		System.setProperties(propes);
		long startTime = System.currentTimeMillis();

		//创建一千个协程生产者发送消息
		for (int i = 0; i < 1000; i++) {
			Mailbox<Integer> mb = new Mailbox<Integer>(1, 10);
			new Producer(i, mb).start();
			mailMap.put(i, mb);
		}


		//创建一千个协程消费者消费消息
		for (int i = 0; i < 1000; i++) {
			new Consumer(mailMap.get(i)).start();
		}
		
		Task.idledown();
		

		 long endTime = System.currentTimeMillis();
	        
	     System.out.println( Thread.currentThread().getName()  + "总计花费时长：" + (endTime- startTime));
	}
	
}

运行结果:
在这里插入图片描述

可以看到运行时间还是很短的,这里我们用Java线程实现类似的功能,看看性能差异.
代码如下:

public class ThreadTest {
	private static Integer count = 0;
	private static final Integer FULL = 10;
	private static String LOCK = "lock";
	private static CountDownLatch countDownLatch = new CountDownLatch(2000);

	public static void main(String[] args) {

		ThreadTest test1 = new ThreadTest();

		long start = System.currentTimeMillis();

		List<Thread> list = new ArrayList<Thread>();
		//创建1000个生产者,每个生产者每次生产10个产品
		for (int i = 0; i < 1000; i++) {
			Thread thread = new Thread(test1.new Producer());
			thread.start();
			list.add(thread);
		}
		//创建1000个消费者,每个消费者每次生产消费个产品
		for (int i = 0; i < 1000; i++) {
			Thread thread = new Thread(test1.new Consumer());
			thread.start();
			list.add(thread);
		}

		try {
			//等待所有的线程运行完毕
			countDownLatch.await();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		long end = System.currentTimeMillis();
		System.out.println("子线程执行时长：" + (end - start));
	}

	class Producer implements Runnable {
		public void run() {
			for (int i = 0; i < 10; i++) {
				//因为是共享内存,所以这里需要加锁,确保线程安全
				synchronized (LOCK) {
					while (count == FULL) {
						try {
							LOCK.wait();
						} catch (Exception e) {
							e.printStackTrace();
						}
					}
					count++;
					System.out.println(Thread.currentThread().getName() + "生产者生产，目前总共有" + count);
					LOCK.notifyAll();
				}
			}
			countDownLatch.countDown();
		}
	}

	class Consumer implements Runnable {
		public void run() {
			for (int i = 0; i < 10; i++) {
				synchronized (LOCK) {
					while (count == 0) {
						try {
							LOCK.wait();
						} catch (Exception e) {
						}
					}
					count--;
					System.out.println(Thread.currentThread().getName() + "消费者消费，目前总共有" + count);
					LOCK.notifyAll();
				}
			}
			countDownLatch.countDown();
		}
	}
}