进程，线程，纤程的概念，以及线程和纤程对于高并发小案例的时间效率对比（小实验）

本文主要介绍Java中的纤程，以及一个测试的小案例，体现纤程的牛逼之处

1.进程和线程的区别？
进程是操作系统分配资源的基本单位，
线程是执行调度的基本单位。所谓的分配资源最重要的是为进程分配内存空间，线程是共享内存空间，没有自己独立的内存空间。
2.纤程：线程中的线程，纤程的调度和切换是不需要经过OS的，是在用户态中完成的，而线程的创建和调度都是需要OS操作系统，所以在执行效率上纤程要高效的多。

引申出一个小问题：为什么说跟内核打交道效率要低？
因为系统调用（我们这里说的是软中断），也就是 int 0x80，首先需要在bx,cx,dx,si,di不同的寄存器中放置参数，然后在ax寄存器中放置系统调用号（对应操作系统函数编号），在调用int 0x80中断，操作系统执行完之后，将返回值放入ax中，再由应用程序去ax中取值，这就应用程序调用操作系统内核的大致过程。所以与用户态上的调用相比，效率低下。

纤程的实现例子：
1.10000个线程，处理calc(随便写的计算的方法)

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException{
        Long startTime = System.currentTimeMillis();
        Runnable runnable = new Runnable() {
            @Override
            public void run(){
                calc();
            }
        };
        int size =10000;
        Thread[] threads = new Thread[size];
        for(int i=0;i<size;i++){
            threads[i] = new Thread(runnable);
        }
        for (int i=0;i<size;i++){
            threads[i].start();
        }
        for(int i=0;i<size;i++){
            threads[i].join();
        }
        Long endtime = System.currentTimeMillis();
        System.out.println("10000个线程计算calc方法耗时："+(endtime-startTime));
    }

    /**
     * 只是一个计算方法没有实际意义
     */
    private static void calc(){
        int result =0;
        for (int i =0;i<10000;i++){
            for(int j=0;j<200;j++){
                result +=i;
            }
        }
    }

2.使用纤程，创建10000个纤程
首先需要引入quasar.jar
最新版本是0.8的，但是我用的时候会出现问题。

<dependency>
	<groupId>co.paralleluniverse</groupId>
	<artifactId>quasar-core</artifactId>
	<version>0.7.9</version>
</dependency>

public class FiberTest {
    public static void main(String[] args) throws Exception{
        long start = System.currentTimeMillis();
        SuspendableRunnable suspendableRunnable = new SuspendableRunnable() {
            @Override
            public void run() throws SuspendExecution, InterruptedException {
                calc();
            }
        };
        int size = 10000;
        Fiber<Void>[] fibers = new Fiber[size];
        for(int i=0;i<size;i++){
            fibers[i] = new Fiber<>(suspendableRunnable);
        }
        for(int i=0;i<size;i++){
            fibers[i].start();
        }
        for(int i=0;i<size;i++){
            fibers[i].join();
        }
        long end = System.currentTimeMillis();
        System.out.println("10000个请求使用纤程耗费时间："+(end-start));
    }
    /**
     * 只是一个计算方法没有实际意义
     */
    private static void calc(){
        int result =0;
        for (int i =0;i<10000;i++){
            for(int j=0;j<200;j++){
                result +=i;
            }
        }
    }
}

3.进一步压榨cpu的资源，创建100个线程，每个线程中创建1000个纤程，可以把第二步中的size设置为100000，在跟第3步进行比较。

public class FiberTest2 {
    public static void main(String[] args) throws InterruptedException{
        long start = System.currentTimeMillis();
        Thread[] t = new Thread[100];
        for(int i=0;i<10;i++){
            t[i] = new Thread(getThread());
        }
        for (int i=0;i<10;i++){
            t[i].start();
        }
        for (int i=0;i<10;i++){
            t[i].join();
        }
        long endtime = System.currentTimeMillis();
        System.out.println("使用线程池+纤程的方式耗时："+(endtime-start));
    }
    public static Runnable getThread() {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                //创建1000个纤程
                Fiber<Void>[] fibers = new Fiber[1000];
                SuspendableRunnable suspendableRunnable = new SuspendableRunnable() {
                    @Override
                    public void run() throws SuspendExecution, InterruptedException {
                        calc();
                    }
                };
                for (int i = 0; i < fibers.length; i++) {
                    fibers[i] = new Fiber<>(suspendableRunnable);
                }
                for (int i = 0; i < fibers.length; i++) {
                    fibers[i].start();
                }
                for (int i = 0; i < fibers.length; i++) {
                    try {
                        fibers[i].join();
                    } catch (Exception e) {

                    }

                }
            }
        };
        return runnable;
    }
    /**
     * 只是一个计算方法没有实际意义
     */
    private static void calc(){
        int result =0;
        for (int i =0;i<10000;i++){
            for(int j=0;j<200;j++){
                result +=i;
            }
        }
    }

经过测试，第三种方式效率更好，你如果电脑可以的话，可以创建10万个线程，看跟这种线程和纤程混合使用的时间进行比较。但是很遗憾，这种通过类库的支持，在做高并发的时候会存在问题，内置支持线程（Fiber）的语言：Kotlin,Scala,go，纤程适合计算的业务，如果是阻塞时间较长的IO，并不适合。