精华内容
下载资源
问答
  • Quasar轻量级java线程库:Quasar 是一个 Java 库,...Quasar最主要的贡献就是提供了轻量级线程的实现,叫做fiber(纤程)。Fiber的功能和使用类似Thread, API接口也类似,所以使用起来没有违和感,但是它们不是被..

    转载自品略图书馆 http://www.pinlue.com/article/2017/03/0621/16608898542.html

     

    Quasar轻量级java线程库:Quasar 是一个 Java 库,提供了高性能、轻量级的线程,类似 Go 语言的 Channel,Erlang 语言的 Actor 和其他异步编程工具。

    Quasar最主要的贡献就是提供了轻量级线程的实现,叫做fiber(纤程)。Fiber的功能和使用类似Thread, API接口也类似,所以使用起来没有违和感,但是它们不是被操作系统管理的,它们是由一个或者多个ForkJoinPool调度。一个idle fiber只占用400K内存,切换的时候占用更少的CPU,你的应用中可以有上百万的fiber,显然Thread做不到这一点。这一点和Go的goroutine类似

    Fiber并不意味着它可以在所有的场景中都可以替换Thread。当fiber的代码经常会被等待其它fiber阻塞的时候,就应该使用fiber。

    对于那些需要CPU长时间计算的代码,很少遇到阻塞的时候,就应该首选thread

    Fiber特别适合替换哪些异步回调的代码。使用 FiberAsync 异步回调很简单,而且性能很好,扩展性也更高。

    Fibers还可以被视为一个从线程池的进化,当我们通过应用并行流的时候避开了线程过载的危险。他们更容易衡量线程和允许令人可观的并行”轻量“线程数量。它们不是为了取代线程,而是应该用在那些相对来说经常堵塞的代码中,就如同担任真正异步线程的角色

    new Fiber() {

    @Override

    protected V run() throws SuspendExecution, InterruptedException {

    // your code

    }

    }.start();

    Comsat介绍

    Comsat还是Parallel Universe提供的集成Quasar的一套开源库,可以提供web或者企业级的技术,如HTTP服务和数据库访问。

    Comsat并不是一套web框架。它并不提供新的API,只是为现有的技术如Servlet、JAX-RS、JDBC等提供Quasar fiber的集成。

    它包含非常多的库,比如Spring、ApacheHttpClient、OkHttp、Undertow、Netty、Kafka等。

    展开全文
  • Quasar轻量级java线程库:Quasar 是一个 Java 库,提供了高...Quasar最主要的贡献就是提供了轻量级线程的实现,叫做fiber(纤程)。Fiber的功能和使用类似Thread, API接口也类似,所以使用起来没有违和感,但是它们...

    在转自品略图书馆 http://www.pinlue.com/article/2017/03/0621/16608898542.html

     

    Quasar轻量级java线程库:Quasar 是一个 Java 库,提供了高性能、轻量级的线程,类似 Go 语言的 Channel,Erlang 语言的 Actor 和其他异步编程工具。

     

    Quasar最主要的贡献就是提供了轻量级线程的实现,叫做fiber(纤程)。Fiber的功能和使用类似Thread, API接口也类似,所以使用起来没有违和感,但是它们不是被操作系统管理的,它们是由一个或者多个ForkJoinPool调度。一个idle fiber只占用400K内存,切换的时候占用更少的CPU,你的应用中可以有上百万的fiber,显然Thread做不到这一点。这一点和Go的goroutine类似

    Fiber并不意味着它可以在所有的场景中都可以替换Thread。当fiber的代码经常会被等待其它fiber阻塞的时候,就应该使用fiber。

    对于那些需要CPU长时间计算的代码,很少遇到阻塞的时候,就应该首选thread

    Fiber特别适合替换哪些异步回调的代码。使用 FiberAsync 异步回调很简单,而且性能很好,扩展性也更高。

    Fibers还可以被视为一个从线程池的进化,当我们通过应用并行流的时候避开了线程过载的危险。他们更容易衡量线程和允许令人可观的并行”轻量“线程数量。它们不是为了取代线程,而是应该用在那些相对来说经常堵塞的代码中,就如同担任真正异步线程的角色

    new Fiber() {

    @Override

    protected V run() throws SuspendExecution, InterruptedException {

    // your code

    }

    }.start();

    Comsat介绍

    Comsat还是Parallel Universe提供的集成Quasar的一套开源库,可以提供web或者企业级的技术,如HTTP服务和数据库访问。

    Comsat并不是一套web框架。它并不提供新的API,只是为现有的技术如Servlet、JAX-RS、JDBC等提供Quasar fiber的集成。

    它包含非常多的库,比如Spring、ApacheHttpClient、OkHttp、Undertow、Netty、Kafka等。

    展开全文
  • 主要介绍了Go语言轻量级线程Goroutine用法,实例分析了goroutine使用技巧,需要的朋友可以参考下
  • goroutine 轻量级线程

    2018-02-12 10:09:52
    goroutine是由Go运行时环境管理的轻量级线程。  在一个包中有一个函数  goroutine使用 go say("xxx")来开启一个新的goroutine执行。  运行下面的程序,观察运行结果。 package main import ( ...

       goroutine是由Go运行时环境管理的轻量级线程。

       在一个包中有一个函数

       goroutine使用 go say("xxx")来开启一个新的goroutine执行。

       运行下面的程序,观察运行结果。

    package main
    
    import (
        "time"
        "fmt"
    )
    
    func say(s string)  {
        for i := 0; i < 5; i++{
            time.Sleep(100*time.Millisecond)
            fmt.Println(s)
        }
    }
    
    func main() {
        go say("Hello")
        say("world")
    }

       你会发现输出的Hello和world,没有固定的先后顺序。因为它们是两个goroutine在执行。

      如果系统运行的太快,可能你看不到所有的 go say("Hello")的运行结果。这时候,你可以修改time.Sleep(100*time.Millisecond) 为 time.Sleep(500*time.Millisecond)或更长的时间,就能够看到所有的运行结果了。

     

    参考:

    https://www.yuque.com/docs/share/77788270-1b55-46d1-bd7e-7e6bf99178ea

    展开全文
  • 轻量级线程——Kotlin之协程

    千次阅读 2018-07-18 14:41:07
    轻量级线程——Kotlin之协程 协程是一种“轻量级线程“,从Kotlin 1.1开始引入。由于一些耗时操作(如网络IO、文件 IO、CPU或GPU密集型任务)会使线程阻塞直到操作完成,协程提供了一种避免线程阻塞、开销更小且...

    轻量级线程——Kotlin之协程

    协程是一种“轻量级线程“,从Kotlin 1.1开始引入。由于一些耗时操作(如网络IO、文件 IO、CPU或GPU密集型任务)会使线程阻塞直到操作完成,协程提供了一种避免线程阻塞、开销更小且更加可控的异步操作。

    协程的基本原理

    协程完全通过编译技术实现(不需要来自 VM 或 OS 端的支持),挂起通过代码来生效。基本上,每个挂起函数都转换为状态机,其中的状态对应于挂起调用。刚好在挂起前,下一状态与相关局部变量等一起存储在编译器生成的类的字段中。在恢复该协程时,恢复局部变量并且状态机从刚好挂起之后的状态进行。

    为什么需要协程

    阻塞还是挂起

    协程可以被挂起而不阻塞线程,线程的阻塞代价是昂贵的。尤其是创建线程数量是有限的,当线程被阻塞,那些重要的任务就有可能被延迟。协程的挂起几乎是没有代价的,它不需要切换上下文。协程的本质是最大限度的利用线程所获得的cpu时间,提高线程的效率。

    协程的简单使用——launch函数

    使用launch函数

        public fun launch(
        context: CoroutineContext = DefaultDispatcher,
        start: CoroutineStart = CoroutineStart.DEFAULT,
        block: suspend CoroutineScope.() -> Unit): Job {}

    第一个参数为协程的上下文

    第二个参数为协程的启动选项

    第三个参数为一个suspend修饰的函数

        fun test(){
            launch(Unconfined) {
                delay(1000)
                print("I am a Coroutine")
            }
            print("I am mainThread")
        }

    这里写图片描述

    launch()函数开启了一个协程,由于协程被挂起,所以协程之外的代码先被执行,又因为协程所处的上下文已经销毁,所以不能完整执行结束。

    注意:suspend函数只能用于启动协程的函数(闭包)中

    launch函数返回一个Job借口对象,可以对协程进行管理。

    Job接口的常用方法有

    • isActive
    • isCompleted
    • isCanceled
    • start
    • cancel
    • join

    Job的几种状态

    这里写图片描述

    协程的生命周期

    这里写图片描述

    延迟一个协程

    fun test(){
        val task =  launch(Unconfined,CoroutineStart.LAZY) {
            println("I am a Coroutine")
        }
        println("I am mainThread")
        task.start()
    }

    这里写图片描述

    finally中的协程代码

        fun test(){
        val task = launch(Unconfined) {
            try{
                delay(1000)
                println("try at coroutine")
            }finally {
                println("finally at coroutine")
            }
        }
        task.cancel()
        Thread.sleep(2000)
        println("I am mainThread")
        }

    这里写图片描述

    协程取消时,finally语句依然会被执行。但是当协程所在线程已经停止,finally也会停止,不会继续执行。可以使用NonCancellable让finallly完整执行。

        fun test(){
        val task = launch(Unconfined) {
            try{
                println("try at coroutine")
            }finally {
                run(NonCancellable) {
                    delay(2000)
                    println("finally at coroutine")
                }
            }
        }
        println("I am mainThread")
        task.cancel()
        }

    协程的超时时间

    
    fun test(){
        launch(Unconfined) {
            withTimeout(1000){
                try{
                    println("try at coroutine")
                }finally {
                    delay(2000)
                    println("finally at coroutine")
                }
            }
        }
        println("I am mainThread")
        Thread.sleep(2000)
    }

    这里写图片描述

    取消一个计算协程

        fun test(){
        val task = launch(Unconfined) {
            var i=0
            while(true){
                i++
                println(i)
                delay(200)
            }
        }
        Thread.sleep(1000)
        if(task.isActive) task.cancel()
        Thread.sleep(1000)
        println("I am mainThread")
        }

    这里写图片描述

    协程的简单使用——async函数

    使用async函数开启异步协程

    将launch函数换成async即可启动异步协程

        fun test(){
        async {
            repeat(10){
                delay(200)
                println("task1")
            }
        }
    
        async {
            repeat(10){
                delay(200)
                println("task2")
            }
        }
    
        Thread.sleep(2000)
        println("I am mainThread")
        }

    这里写图片描述

    协程的简单使用——runBlocking函数

    runBlocking用于main函数或test函数,用于实现类似主协程的效果

        fun main(args: Array<String>) = runBlocking {
        launch {
            println("before delay")
            delay(1000)
            println("after delay")
        }
        delay(2000)
        //Thread.sleep(2000)
        println("I am mainThread")
        }

    这里写图片描述

    Android中使用协程

    协程的优点主要是①数量多②非阻塞③管理方便④异步并发时同步简单。

    所以可以使用launch(async)+async+async来启动两个异步任务并直接在launch更新UI,无需使用handler机制;多线程之间同步也不需要写过多的代码。

    异步协程launch+async+async

        fun testAsync(){
            //开启两个异步任务;这里只能用async,因为只有async有await()获取结果,并且异步
            val task1 = async {
                repeat(100){
                    Log.d("Task1","当前线程:${Thread.currentThread().name}")
                }
                "AsyncTask1"
            }
            val task2 = async {
                repeat(100){
                    Log.d("Task2","当前线程:${Thread.currentThread().name}")
                }
                "AsyncTask2"
            }
            //更新UI或async
            launch(Unconfined) {
                Log.d("UI1","当前线程:${Thread.currentThread().name}")
                //当前UI线程的协程阻塞,但是不会使UI阻塞
                text1.text = task1.await()
                text2.text = task2.await()
                Log.d("UI2","当前线程:${Thread.currentThread().name}")
            }
        }

    同步协程launch+async+async

        fun testSync(){
            launch(Unconfined) {
                Log.d("UI1","当前线程:${Thread.currentThread().name}")
                val res1 = async {
                    repeat(100){
                        Log.d("Task1","当前线程:${Thread.currentThread().name}")
                    }
                    "AsyncTask1"
                }.await()  //挂起
                val res2 = async {
                    repeat(100){
                        Log.d("Task2","当前线程:${Thread.currentThread().name}")
                    }
                    "AsyncTask2"
                }.await()
                Log.d("UI2","当前线程:${Thread.currentThread().name}")
                text1.text = res1
                text2.text = res2
            }
        }

    以上,我们可以使用launch或者async+几个async来代替以前的多线程。而当我们只需要让几个任务串行而不需要返回值,可以只用launch;当我们需要几个异步或者需要获得返回值,就用async,没有特殊需求就可自由选用。

    总结

    • 线程创建的数量是有限的,创建和销毁线程的开销很大,协程几乎不需要有额外的开销
    • 协程挂起不会引起线程阻塞,阻塞可能会导致重要任务的延迟
    • 协程更加容易管理,如果要管理线程,则需要自己实现future借口或使用线程池。
    • 异步协程的await()可以直接获取获取返回值而不需要去写额外的同步代码。
    展开全文
  • 通常说java的是重量级线程,python,erlang等是轻量级线程,请问为什么这样说?他们的区别是什么?如何区分重量级线程和轻量级线程轻量级线程和重量级线程的定义是...
  • 1. 轻量级线程  在计算机操作系统中,轻量级进程(LWP)是一种实现多任务的方法。与普通进程相比,LWP与其他进程共享所有或大部分它的逻辑地址空间和系统资源;与线程相比,LWP有它自己的进程标识符,优先级,状态...
  • 本章我通过大量实例学习了协程的用法;同时了解了作为轻量级线程的协程是怎样简化的我们的多线程并发编程的。我们看到协程通过挂起机制实现非阻塞的特性大大提升了我们并发性能。
  • 自 .NET 诞生以来就有锁,然而从 .NET Framework 4.0 开始,又诞生了 6 个轻量级线程安全方案:SpinLock, SpinWait, CountdownEvent, SemaphoreSlim, ManualResetEventSlim, Barrier。 SpinLock, SpinWait ...
  • 第11章 轻量级线程:协程(Coroutines) 11.1 协程概念 11.2 协程的基本操作11.2.1 创建11.2.2 启动11.2.3 暂停11.2.4 继续 11.3 竞争条件 11.4 同步 11.5 实现异步
  • “协程”即用户态下的非抢占式的轻量级线程,是一种在程序开发中处理多任务的组件。 由于在C/C++中并没有引入协程这一概念,而大部分开源的库又过于重量,所以我基于ucontext组件实现了一个简单的协程库 项目特点 ...
  • 简单比较了一下ucontext和...效率差这么多是可以预见的,C的轻量级线程实现都是栈切换的,要完成寄存器保存和加载,只是不需要经过系统调度。相比之下其它语言的轻量级线程切换通常不是C栈切换,开销要小得多。 ...
  • 异步IO与轻量级线程

    2016-08-25 20:18:14
    计算机执行计算任务时,通常还需要与各种IO设备交互,这些设备和CPU、内存比起来慢几个数量。大部分web应用的瓶颈都在于IO操作,如读写磁盘,网络操作,读取数据库。使用怎样的策略等待这段时间,就成了改善性能的...
  • 相信很多人都听过或者看到过这样一种说法“协程是一种轻量级线程”。以下文档中都有类似的描述: Kotlin中文网-协程-基础-第一个协程程序 本质上,协程是轻量级线程。 Kotlin英文官网对应位置 ...
  • 协程作为一个轻量级线程,可以完美解决这些问题。你试下开100万个线程?不死机我吃电脑。但是你开100万个协程,那是分分钟的事。 这里只说android和kotlin中的使用。 添加依赖 // kotlin 版本 ext.k...
  • 轻量级线程和erlang

    2011-05-02 00:23:00
    计算机执行计算任务时,通常还需要与各种IO设备交互,这些设备和CPU、内存比起来慢几个数量,一些任务还需要串行地使用这些设备,这时候使用多线程就可以有效利用这些设备资源。 <br />除了创建大量线程以外...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,784
精华内容 5,113
关键字:

轻量级线程