1. 什么是纤程？

纤程：用户态的线程，线程中的线程，切换和调度不需要经过OS

2. 纤程和线程的区别

主要的区别是

3. 纤程的优势

  1. 占有资源很少,启动一个县城操作系统前前后后要为它分配大概1M的资源, 纤程Fiber是4K
  2. 切换比较简单
  3. 启动很多个10W+

目前(2020年3月22日)支持内置纤程的语言：Kotlin Scala Go Python(lib)… Java?（open jdk : loom）

4. 纤程的应用场景

很短的计算任务，不需要和内核打交道，并发量高！

5. 纤程的使用（利用Quaser库）

  1. <!-- https://mvnrepository.com/artifact/co.paralleluniverse/quasar-core -->
  2. <dependency>
  3.   <groupId>co.paralleluniverse</groupId>
  4.   <artifactId>quasar-core</artifactId>
  5.   <version>0.4.0</version>
  6. </dependency>
  1. import co.paralleluniverse.fibers.Fiber;
  2. import co.paralleluniverse.fibers.SuspendExecution;
  3. import co.paralleluniverse.strands.SuspendableRunnable;
  5. import java.util.concurrent.ExecutionException;
  7. /**
  8.  * 线程和纤程的对比
  9.  * 启动10000个纤程和10000个线程，分别进行相同的计算量calculate()， 对比线程和纤程的性能
  10.  */
  11. public class FiberAndThread {
  13.     //启动的纤程/线程数量
  14.     public static final int SIZE = 10000;
  16.     //计算
  17.     static void calculate() {
  18.         int result = 0;
  19.         for (int m = 0; m < 10000; m++) {
  20.             for (int i = 0; i < 200; i++) {
  21.                 result += i;
  22.             }
  23.         }
  24.     }
  26.     //测试纤程
  27.     public static void testFiber() throws ExecutionException, InterruptedException {
  28.         //开始计时
  29.         long start = System.currentTimeMillis();
  30.         //初始化纤程数组
  31.         Fiber<Void>[] fibers = new Fiber[SIZE];
  32.         for (int i = 0; i < fibers.length; i++) {
  33.             fibers[i] = new Fiber<Void>(new SuspendableRunnable() {
  34.                 public void run() throws SuspendExecution, InterruptedException {
  35.                     calculate();
  36.                 }
  37.             });
  38.         }
  39.         //启动
  40.         for (int i = 0; i < fibers.length; i++) {
  41.             fibers[i].start();
  42.         }
  43.         //加入当前线程
  44.         for (int i = 0; i < fibers.length; i++) {
  45.             fibers[i].join();
  46.         }
  47.         //结束计时
  48.         long end = System.currentTimeMillis();
  49.         //计算并打印耗时
  50.         System.out.println("纤程耗时"+(end - start));
  51.     }
  53.     //测试线程
  54.     public static void testThread() throws InterruptedException {
  55.         //开始计时
  56.         long start = System.currentTimeMillis();
  57.         Runnable r = new Runnable() {
  58.             @Override
  59.             public void run() {
  60.                 calculate();
  61.             }
  62.         };
  63.         //初始化线程数组
  64.         Thread[] threads = new Thread[SIZE];
  65.         //填充
  66.         for (int i = 0; i < threads.length; i++) {
  67.             threads[i] = new Thread(r);
  68.         }
  69.         //启动
  70.         for (int i = 0; i < threads.length; i++) {
  71.             threads[i].start();
  72.         }
  73.         //加入当前线程
  74.         for (int i = 0; i < threads.length; i++) {
  75.             threads[i].join();
  76.         }
  77.         //结束计时
  78.         long end = System.currentTimeMillis();
  79.         //计算并打印耗时
  80.         System.out.println("线程耗时"+(end - start));
  81.     }
  83.     public static void main(String[] args) throws InterruptedException, ExecutionException {
  84.         //测试线程
  85.         for (int i = 0 ; i < 10; i++){
  86.             testThread();
  87.         }
  88.         //测试纤程
  89.         for (int i = 0 ; i < 10; i++){
  90.             testFiber();
  91.         }
  93.     }
  94. }

测试结果：

线程耗时577 线程耗时606

线程耗时605

线程耗时537

线程耗时497

线程耗时507

线程耗时494

线程耗时513

线程耗时501

线程耗时505

纤程耗时143

纤程耗时8

纤程耗时8

纤程耗时6

纤程耗时5

纤程耗时7

纤程耗时5

纤程耗时8

纤程耗时5

纤程耗时4