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

阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6

文章目录

什么是协程

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

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

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

协程的优点与缺点

优点:

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

缺点:

  1. 系统是察觉不到协程的存在的所以只有一个处理器内核会被分配给该进程 也就不能发挥多核 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,使用举例

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

  1. 引入maven
        <dependency>
            <groupId>org.db4j</groupId>
            <artifactId>kilim</artifactId>
            <version>2.0.1-jdk7</version>
        </dependency>
  1. 代码实现
    在这里插入图片描述
    消费者:
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();
		}
	}
}

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

可以看到协程花费400,线程花费1300,差距还是蛮大的.

小总结

协程和线程密切相关协程可以认为是运行在线程上的代码块协程提供的挂起操作会使协程暂停执行而不会导致线程阻塞。

协程又是一种轻量级资源即使创建了上千个协程对于系统来说也不是很大的负担但如果在程序中创建上千个线程那系统可真就压力山大了。

可以说协程的设计方式极大地提高了线程的使用率。通过今天的学习当其他人侃侃而谈 Go 语言在网络编程中的优势时相信你不会一头雾水。学习 Java 的我们也不要觉得协程离我们很遥远了。

协程是一种设计思想不仅仅局限于某一门语言况且 Java 已经可以借助协程框架实现协程了。但话说回来协程还是在 Go 语言中的应用较为成熟在 Java 中的协程目前还不是很稳定重点是缺乏大型项目的验证可以说 Java 的协程设计还有很长的路要走。

今天的分享就到这里了,有问题可以在评论区留言,均会及时回复呀.
我是bling,未来不会太差,只要我们不要太懒就行, 咱们下期见.
在这里插入图片描述

阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6
标签: Java
返回列表

上一篇：FPGA：IIC验证镁光EEPROM仿真模型（纯Verilog）

下一篇：浅谈Dubbo服务引入源码（@ReferenceBean依赖注入）

“协程和线程的区别、协程原理与优缺点分析、在Java中使用协程” 的相关文章

JAVA学习笔记- - - day 11年前 (2023-02-02)
3、JavaScript函数1年前 (2023-02-02)
分享111个Java源码，总有一款适合您1年前 (2023-02-02)
代码随想录算法训练营第十七天二叉树 java : . 110.平衡二叉树 257.二叉树的所有路径 404.左叶子之和1年前 (2023-02-02)
cocoscreator java 和ts调用1年前 (2023-02-02)
Java数组动态扩容和动态缩减1年前 (2023-02-02)
【javascript】有计算功能的简易计算器1年前 (2023-02-02)
【Java寒假打卡】Java基础-线程池1年前 (2023-02-02)
5、JavaScript面向对象1年前 (2023-02-02)
Java加解密（八）数字证书1年前 (2023-02-02)

阿里云国际版