Contoh pengenalan: Java melaksanakan kumpulan coroutine berdasarkan quasar

Artikel ini membawakan anda pengetahuan yang berkaitan tentang java, yang terutamanya menyelesaikan isu berkaitan pelaksanaan kumpulan coroutine berdasarkan quasar Satu urutan boleh mempunyai berbilang coroutine dan satu proses juga boleh bebas Dengan berbilang coroutine , proses benang semuanya adalah mekanisme segerak, manakala coroutine tidak segerak Mari kita lihat bersama-sama.

Pembelajaran yang disyorkan: "tutorial video java"

Senario perniagaan: Golang dan swoole kedua-duanya menerima coroutine dan menjalankan tugas yang sama Di bawah nombor serentak, coroutine boleh menjadi beberapa kali lebih banyak daripada benang. Jadi baru-baru ini apabila saya menyoal Java, saya mengetahui bahawa Java sendiri tidak mempunyai coroutine, tetapi seekor lembu tertentu melaksanakan coroutine sendiri, yang merupakan protagonis artikel ini, quasar (proses serat)! Tetapi saya tidak pernah melihat sesiapa mendedahkan operasi hebat kumpulan coroutine tulisan tangan (Siapa yang akan menggunakannya secara langsung? Ini bermakna mereka belum dipukul teruk oleh masyarakat~)

Sebuah benang boleh mempunyai berbilang coroutine, dan proses juga boleh Anda boleh mempunyai berbilang coroutine secara individu.

Proses benang ialah semua mekanisme segerak, manakala coroutine adalah tak segerak.

Coroutine boleh mengekalkan keadaan panggilan terakhir Setiap kali proses masuk semula, ia bersamaan dengan memasuki keadaan panggilan terakhir.

Thread adalah preemptif, manakala coroutine bukan preemptive, jadi pengguna perlu melepaskan hak penggunaan mereka untuk beralih kepada coroutine lain Oleh itu, hanya satu coroutine yang berhak untuk dijalankan pada masa yang sama, yang bersamaan dengan satu kebolehan.

Coroutine tidak menggantikan utas, tetapi disarikan daripada utas adalah sumber CPU yang tersusun gunakan benang. Coroutine secara langsung menggunakan pelaksana (Pemintas).

Benang adalah sumber coroutine. Coroutine menggunakan sumber benang secara tidak langsung melalui Interceptor.

Tanpa berlengah lagi, mari terus ke kod:

Pakej import:

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

WorkTools工具类：

package com.example.ai;

import co.paralleluniverse.fibers.Fiber;
import co.paralleluniverse.fibers.SuspendExecution;
import co.paralleluniverse.strands.SuspendableRunnable;

import java.util.concurrent.ArrayBlockingQueue;


public class WorkTools {
    //协程池中默认协程的个数为5
    private static int WORK_NUM = 5;
    //队列默认任务为100
    private static int TASK_COUNT = 100;

    //工做协程数组
    private Fiber[] workThreads;
    //等待队列
    private final ArrayBlockingQueue<SuspendableRunnable> taskQueue;

    //用户在构造这个协程池时，但愿启动的协程数
    private final int workerNum;


    //构造方法：建立具备默认协程个数的协程池
    public WorkTools() {
        this(WORK_NUM,TASK_COUNT);
    }

    //建立协程池,workNum为协程池中工做协程的个数
    public WorkTools(int workerNum, int taskCount) {
        if (workerNum <= 0) {
            workerNum = WORK_NUM;
        }
        if (taskCount <= 0) {
            taskCount = TASK_COUNT;
        }
        this.workerNum = workerNum;
        taskQueue = new ArrayBlockingQueue(taskCount);
        workThreads = new Fiber[workerNum];
        for (int i = 0; i < workerNum; i++) {
            int finalI = i;
            workThreads[i] = new Fiber<>(new SuspendableRunnable() {
                @Override
                public void run() throws SuspendExecution, InterruptedException {
                    SuspendableRunnable runnable = null;
                    while (true){
                        try{
                            //取任务，没有则阻塞。
                            runnable = taskQueue.take();
                        }catch (Exception e){
                            System.out.println(e.getMessage());
                        }
                        //存在任务则运行。
                        if(runnable != null){
                            runnable.run();
                        }

                        runnable = null;
                    }
                }
            });  //new一个工做协程

            workThreads[i].start();  //启动工做协程

        }

        Runtime.getRuntime().availableProcessors();
    }
    //执行任务，其实就是把任务加入任务队列，何时执行由协程池管理器决定
    public void execute(SuspendableRunnable task) {
        try {
            taskQueue.put(task);   //put:阻塞接口的插入
        } catch (Exception e) {
            // TODO: handle exception
            System.out.println("阻塞");
        }
    }
    //销毁协程池,该方法保证全部任务都完成的状况下才销毁全部协程，不然等待任务完成再销毁
    public void destory() {
        //工做协程中止工做，且置为null
        System.out.println("ready close thread...");
        for (int i = 0; i < workerNum; i++) {

            workThreads[i] = null; //help gc
        }
        taskQueue.clear();  //清空等待队列
    }
    //覆盖toString方法，返回协程信息：工做协程个数和已完成任务个数
    @Override
    public String toString() {
        return "WorkThread number:" + workerNum + " ==分割线== wait task number:" + taskQueue.size();
    }
}

Kod ujian:

package com.example.ai;

import co.paralleluniverse.strands.SuspendableRunnable;
import lombok.SneakyThrows;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import java.util.concurrent.CountDownLatch;



@SpringBootApplication


public class AiApplication {

    @SneakyThrows
    public static void main(String[] args) {
        //等待协程任务完毕后再结束主线程
        CountDownLatch cdl = new CountDownLatch(50);
        //开启5个协程，50个任务列队。
        WorkTools myThreadPool = new WorkTools(5, 50);
        for (int i = 0; i< 50; i++){
            int finalI = i;
            myThreadPool.execute(new SuspendableRunnable() {
                @Override
                public void run() {
                    System.out.println(finalI);
                    try {
                        //延迟1秒
                        Thread.sleep(1000);
                        cdl.countDown();
                    } catch (InterruptedException e) {
                        System.out.println("阻塞中");
                    }
                }
            });

        }
        //阻塞
        cdl.await();
    }

}

Kod khusus diulas, supaya anda boleh memahaminya sendiri. Saya juga melaksanakannya menggunakan penulisan kolam benang.

Pada masa ini kami cuba menyelesaikan masalah: Semasa proses penyekatan coroutine, kelas Fiber akan melaporkan amaran menyekat, yang mengelirukan dan menjengkelkan untuk ditonton. Tidak ada cara untuk menanganinya pada masa ini. Mari lihat jika ada di antara anda yang mempunyai sebarang idea dalam ulasan di bawah. Terima kasih banyak~

Kajian yang disyorkan: "tutorial video java"

Atas ialah kandungan terperinci Contoh pengenalan: Java melaksanakan kumpulan coroutine berdasarkan quasar. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!