精华内容
下载资源
问答
  • 凌云时刻 · 技术导读:Java异步非阻塞编程的几种方式作者|尘定来源|阿里技术从一个同步的Http调用说起一个很简单的业务逻辑,其他后端服务提供了一个接口,我们需要通过接口调用,获取到响...

    凌云时刻 · 技术

    导读:Java异步非阻塞编程的几种方式

    作者尘定

    来源|阿里技术

    从一个同步的Http调用说

    一个很简单的业务逻辑,其他后端服务提供了一个接口,我们需要通过接口调用,获取到响应的数据。

    逆地理接口:通过经纬度获取这个经纬度所在的省市区县以及响应的code:

    curl-i"http://xxx?latitude=31.08966221524924&channel=amap7a&near=false&longitude=105.13990312814713"
    
    {"adcode":"510722"}
    

    服务端执行,最简单的同步调用方式:

    服务端响应之前,IO会阻塞在:java.net.SocketInputStream#socketRead0 的native方法上:

    通过jstack日志,可以发现,此时这个Thread会一直在runable的状态:

    "main"#1 prio=5 os_prio=31 tid=0x00007fed0c810000 nid=0x1003 runnable [0x000070000ce14000]   java.lang.Thread.State: RUNNABLE
            at java.net.SocketInputStream.socketRead0(Native Method)
            at java.net.SocketInputStream.socketRead(SocketInputStream.java:116)
            at java.net.SocketInputStream.read(SocketInputStream.java:171)
            at java.net.SocketInputStream.read(SocketInputStream.java:141)
            at org.apache.http.impl.conn.LoggingInputStream.read(LoggingInputStream.java:84)
            at org.apache.http.impl.io.SessionInputBufferImpl.streamRead(SessionInputBufferImpl.java:137)
            at org.apache.http.impl.io.SessionInputBufferImpl.fillBuffer(SessionInputBufferImpl.java:153)
            at org.apache.http.impl.io.SessionInputBufferImpl.readLine(SessionInputBufferImpl.java:282)
            at org.apache.http.impl.conn.DefaultHttpResponseParser.parseHead(DefaultHttpResponseParser.java:138)
            at org.apache.http.impl.conn.DefaultHttpResponseParser.parseHead(DefaultHttpResponseParser.java:56)
            at org.apache.http.impl.io.AbstractMessageParser.parse(AbstractMessageParser.java:259)
            at org.apache.http.impl.DefaultBHttpClientConnection.receiveResponseHeader(DefaultBHttpClientConnection.java:163)
            at org.apache.http.impl.conn.CPoolProxy.receiveResponseHeader(CPoolProxy.java:165)
            at org.apache.http.protocol.HttpRequestExecutor.doReceiveResponse(HttpRequestExecutor.java:273)
            at org.apache.http.protocol.HttpRequestExecutor.execute(HttpRequestExecutor.java:125)
            at org.apache.http.impl.execchain.MainClientExec.execute(MainClientExec.java:272)
            at org.apache.http.impl.execchain.ProtocolExec.execute(ProtocolExec.java:185)
            at org.apache.http.impl.execchain.RetryExec.execute(RetryExec.java:89)
            at org.apache.http.impl.execchain.RedirectExec.execute(RedirectExec.java:110)
            at org.apache.http.impl.client.InternalHttpClient.doExecute(InternalHttpClient.java:185)
            at org.apache.http.impl.client.CloseableHttpClient.execute(CloseableHttpClient.java:83)
            at org.apache.http.impl.client.CloseableHttpClient.execute(CloseableHttpClient.java:108)
            at com.amap.aos.async.AsyncIO.blockingIO(AsyncIO.java:207)
                    .......
    

    线程模型示例:

     

    同步最大的问题是在IO等待的过程中,线程资源没有得到充分的利用,对于大量IO场景的业务吞吐量会有一定限制。

    JDK NIO & Future

    在JDK 1.5 中,JUC提供了Future抽象:

     

    当然并不是所有的Future都是这样实现的,如 io.netty.util.concurrent.AbstractFuture 就是通过线程轮询去。

    这样做的好处是,主线程可以不用等待IO响应,可以去做点其他的,比如说再发送一个IO请求,可以等到一起返回:

    "main"#1 prio=5 os_prio=31 tid=0x00007fd7a500b000 nid=0xe03 waiting on condition [0x000070000a95d000]   java.lang.Thread.State: WAITING (parking)
            at sun.misc.Unsafe.park(Native Method)
    - parking to wait for  <0x000000076ee2d768> (a java.util.concurrent.CountDownLatch$Sync)
            at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:836)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedInterruptibly(AbstractQueuedSynchronizer.java:997)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1304)
            at java.util.concurrent.CountDownLatch.await(CountDownLatch.java:231)
            at org.asynchttpclient.netty.NettyResponseFuture.get(NettyResponseFuture.java:162)
            at com.amap.aos.async.AsyncIO.futureBlockingGet(AsyncIO.java:201)
            .....
    "AsyncHttpClient-2-1"#11 prio=5 os_prio=31 tid=0x00007fd7a7247800 nid=0x340b runnable [0x000070000ba94000]   java.lang.Thread.State: RUNNABLE
            at sun.nio.ch.KQueueArrayWrapper.kevent0(Native Method)
            at sun.nio.ch.KQueueArrayWrapper.poll(KQueueArrayWrapper.java:198)
            at sun.nio.ch.KQueueSelectorImpl.doSelect(KQueueSelectorImpl.java:117)
            at sun.nio.ch.SelectorImpl.lockAndDoSelect(SelectorImpl.java:86)
    - locked <0x000000076eb00ef0> (a io.netty.channel.nio.SelectedSelectionKeySet)
    - locked <0x000000076eb00f10> (a java.util.Collections$UnmodifiableSet)
    - locked <0x000000076eb00ea0> (a sun.nio.ch.KQueueSelectorImpl)
            at sun.nio.ch.SelectorImpl.select(SelectorImpl.java:97)
            at io.netty.channel.nio.NioEventLoop.select(NioEventLoop.java:693)
            at io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:353)
            at io.netty.util.concurrent.SingleThreadEventExecutor$2.run(SingleThreadEventExecutor.java:140)
            at io.netty.util.concurrent.DefaultThreadFactory$DefaultRunnableDecorator.run(DefaultThreadFactory.java:144)
            at java.lang.Thread.run(Thread.java:748)
    

    主线程在等待结果返回过程中依然需要等待,没有根本解决此问题。

    使用Callback回调方式

    第二节中,依然需要主线程等待,获取结果,那么可不可以在主线程完成发送请求后,再也不用关心这个逻辑,去执行其他的逻辑?那就可以使用Callback机制。

    如此一来,主线程再也不需要关心发起IO后的业务逻辑,发送完请求后,就可以彻底去干其他事情,或者回到线程池中再供调度。如果是HttpServer,那么需要结合Servlet 3.1的异步Servlet。

    异步Servelt参考资料

    https://www.cnblogs.com/davenkin/p/async-servlet.html

    使用Callback方式,从线程模型中看,发现线程资源已经得到了比较充分的利用,整个过程中已经没有线程阻塞。

    Callback hell

    回调地狱,当Callback的线程还需要执行下一个IO调用的时候,这个时候进入回调地狱模式。

    典型的应用场景如,通过经纬度获取行政区域adcode(逆地理接口),然后再根据获得的adcode,获取当地的天气信息(天气接口)。

    在同步的编程模型中,几乎不会涉及到此类问题。

    Callback方式的核心缺陷

    JDK 1.8 CompletableFuture

    那么有没有办法解决Callback Hell的问题?当然有,JDK 1.8中提供了CompletableFuture,先看看它是怎么解决这个问题的。

    将逆地理的Callback逻辑,封装成一个独立的CompletableFuture,当异步线程回调时,调用 future.complete(T) ,将结果封装。

    将天气执行的Call逻辑,也封装成为一个独立的CompletableFuture ,完成之后,逻辑同上。

    compose衔接,whenComplete输出:

    每一个IO操作,均可以封装为独立的CompletableFuture,从而避免回调地狱。

    CompletableFuture,只有两个属性:

    • result:Future的执行结果 (Either the result or boxed AltResult)。

    • stack:操作栈,用于定义这个Future接下来操作的行为 (Top of Treiber stack of dependent actions)。

    weatherFuture这个方法是如何被调用的呢?

    通过堆栈可以发现,是在 reverseCodeFuture.complete(result) 的时候,并且也将获得的adcode作为参数执行接下来的逻辑。

    这样一来,就完美解决回调地狱问题,在主的逻辑中,看起来像是在同步的进行编码。

    Vert.x Future

    Info-Service中,大量使用的 Vert.x Future 也是类似的解决的方案,不过设计上使用Handler的概念。

    核心执行的逻辑差不多:

    这当然不是Vertx的全部,当然这是题外话了。

    Reactive Streams

    异步编程对吞吐量以及资源有好处,但是有没有统一的抽象去解决此类问题内,答案是 Reactive Streams。

    核心抽象:Publisher Subscriber Processor Subscription ,整个包里面,只有这四个接口,没有实现类。

    在JDK 9里面,已经被作为一种规范封装到 java.util.concurrent.Flow :

    参考资料

    https://www.baeldung.com/java-9-reactive-streams

    http://ypk1226.com/2019/07/01/reactive/reactive-streams/

    https://www.reactivemanifesto.org/

    https://projectreactor.io/learn

    一个简单的例子:

    Reactor & Spring 5 & Spring WebFlux

    Flux & Mono

    参考资料

    https://projectreactor.io/docs/core/3.1.0.M3/reference/index.html

    https://speakerdeck.com/simonbasle/projectreactor-dot-io-reactor3-intro

    END

    开工大礼包

    邀请伙伴助力中奖几率翻倍

    开奖时间:2021 年 3 月 09 日

    赶紧转发至朋友圈,呼唤好友一起

    抽  奖 吧 !


    长按扫描二维码关注凌云时刻

    每日收获前沿技术与科技洞见

    展开全文
  • 七 Reactive Streams 异步编程对吞吐量以及资源有好处,但是有没有统一的抽象去解决此类问题内,答案是 Reactive Streams。 核心抽象:Publisher Subscriber Processor Subscription ,整个包里面,只有这四个接口...

    一 从一个同步的Http调用说起

    一个很简单的业务逻辑,其他后端服务提供了一个接口,我们需要通过接口调用,获取到响应的数据。

    逆地理接口:通过经纬度获取这个经纬度所在的省市区县以及响应的code:

    curl-i"http://xxx?latitude=31.08966221524924&channel=amap7a&near=false&longitude=105.13990312814713"
    {"adcode":"510722"}

    服务端执行,最简单的同步调用方式:

    服务端响应之前,IO会阻塞在:
    java.net.SocketInputStream#socketRead0 的native方法上:

    通过jstack日志,可以发现,此时这个Thread会一直在runable的状态:

    "main"#1 prio=5 os_prio=31 tid=0x00007fed0c810000 nid=0x1003 runnable [0x000070000ce14000]   java.lang.Thread.State: RUNNABLE
            at java.net.SocketInputStream.socketRead0(Native Method)
            at java.net.SocketInputStream.socketRead(SocketInputStream.java:116)
            at java.net.SocketInputStream.read(SocketInputStream.java:171)
            at java.net.SocketInputStream.read(SocketInputStream.java:141)
            at org.apache.http.impl.conn.LoggingInputStream.read(LoggingInputStream.java:84)
            at org.apache.http.impl.io.SessionInputBufferImpl.streamRead(SessionInputBufferImpl.java:137)
            at org.apache.http.impl.io.SessionInputBufferImpl.fillBuffer(SessionInputBufferImpl.java:153)
            at org.apache.http.impl.io.SessionInputBufferImpl.readLine(SessionInputBufferImpl.java:282)
            at org.apache.http.impl.conn.DefaultHttpResponseParser.parseHead(DefaultHttpResponseParser.java:138)
            at org.apache.http.impl.conn.DefaultHttpResponseParser.parseHead(DefaultHttpResponseParser.java:56)
            at org.apache.http.impl.io.AbstractMessageParser.parse(AbstractMessageParser.java:259)
            at org.apache.http.impl.DefaultBHttpClientConnection.receiveResponseHeader(DefaultBHttpClientConnection.java:163)
            at org.apache.http.impl.conn.CPoolProxy.receiveResponseHeader(CPoolProxy.java:165)
            at org.apache.http.protocol.HttpRequestExecutor.doReceiveResponse(HttpRequestExecutor.java:273)
            at org.apache.http.protocol.HttpRequestExecutor.execute(HttpRequestExecutor.java:125)
            at org.apache.http.impl.execchain.MainClientExec.execute(MainClientExec.java:272)
            at org.apache.http.impl.execchain.ProtocolExec.execute(ProtocolExec.java:185)
            at org.apache.http.impl.execchain.RetryExec.execute(RetryExec.java:89)
            at org.apache.http.impl.execchain.RedirectExec.execute(RedirectExec.java:110)
            at org.apache.http.impl.client.InternalHttpClient.doExecute(InternalHttpClient.java:185)
            at org.apache.http.impl.client.CloseableHttpClient.execute(CloseableHttpClient.java:83)
            at org.apache.http.impl.client.CloseableHttpClient.execute(CloseableHttpClient.java:108)
            at com.amap.aos.async.AsyncIO.blockingIO(AsyncIO.java:207)
                    .......

    线程模型示例:

    同步最大的问题是在IO等待的过程中,线程资源没有得到充分的利用,对于大量IO场景的业务吞吐量会有一定限制。

    二 JDK NIO & Future

    在JDK 1.5 中,JUC提供了Future抽象:

    当然并不是所有的Future都是这样实现的,如
    io.netty.util.concurrent.AbstractFuture 就是通过线程轮询去。

    这样做的好处是,主线程可以不用等待IO响应,可以去做点其他的,比如说再发送一个IO请求,可以等到一起返回:

    "main"#1 prio=5 os_prio=31 tid=0x00007fd7a500b000 nid=0xe03 waiting on condition [0x000070000a95d000]   java.lang.Thread.State: WAITING (parking)
            at sun.misc.Unsafe.park(Native Method)
    - parking to wait for  <0x000000076ee2d768> (a java.util.concurrent.CountDownLatch$Sync)
            at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:836)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedInterruptibly(AbstractQueuedSynchronizer.java:997)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1304)
            at java.util.concurrent.CountDownLatch.await(CountDownLatch.java:231)
            at org.asynchttpclient.netty.NettyResponseFuture.get(NettyResponseFuture.java:162)
            at com.amap.aos.async.AsyncIO.futureBlockingGet(AsyncIO.java:201)
            .....
    "AsyncHttpClient-2-1"#11 prio=5 os_prio=31 tid=0x00007fd7a7247800 nid=0x340b runnable [0x000070000ba94000]   java.lang.Thread.State: RUNNABLE
            at sun.nio.ch.KQueueArrayWrapper.kevent0(Native Method)
            at sun.nio.ch.KQueueArrayWrapper.poll(KQueueArrayWrapper.java:198)
            at sun.nio.ch.KQueueSelectorImpl.doSelect(KQueueSelectorImpl.java:117)
            at sun.nio.ch.SelectorImpl.lockAndDoSelect(SelectorImpl.java:86)
    - locked <0x000000076eb00ef0> (a io.netty.channel.nio.SelectedSelectionKeySet)
    - locked <0x000000076eb00f10> (a java.util.Collections$UnmodifiableSet)
    - locked <0x000000076eb00ea0> (a sun.nio.ch.KQueueSelectorImpl)
            at sun.nio.ch.SelectorImpl.select(SelectorImpl.java:97)
            at io.netty.channel.nio.NioEventLoop.select(NioEventLoop.java:693)
            at io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:353)
            at io.netty.util.concurrent.SingleThreadEventExecutor$2.run(SingleThreadEventExecutor.java:140)
            at io.netty.util.concurrent.DefaultThreadFactory$DefaultRunnableDecorator.run(DefaultThreadFactory.java:144)
            at java.lang.Thread.run(Thread.java:748)

    主线程在等待结果返回过程中依然需要等待,没有根本解决此问题。

    三 使用Callback回调方式

    第二节中,依然需要主线程等待,获取结果,那么可不可以在主线程完成发送请求后,再也不用关心这个逻辑,去执行其他的逻辑?那就可以使用Callback机制。

    如此一来,主线程再也不需要关心发起IO后的业务逻辑,发送完请求后,就可以彻底去干其他事情,或者回到线程池中再供调度。如果是HttpServer,那么需要结合Servlet 3.1的异步Servlet。

    异步Servelt参考资料

    https://www.cnblogs.com/davenkin/p/async-servlet.html

    使用Callback方式,从线程模型中看,发现线程资源已经得到了比较充分的利用,整个过程中已经没有线程阻塞。

    四 Callback hell

    回调地狱,当Callback的线程还需要执行下一个IO调用的时候,这个时候进入回调地狱模式。

    典型的应用场景如,通过经纬度获取行政区域adcode(逆地理接口),然后再根据获得的adcode,获取当地的天气信息(天气接口)。

    在同步的编程模型中,几乎不会涉及到此类问题。

    Callback方式的核心缺陷

    五 JDK 1.8 CompletableFuture

    那么有没有办法解决Callback Hell的问题?当然有,JDK 1.8中提供了CompletableFuture,先看看它是怎么解决这个问题的。

    将逆地理的Callback逻辑,封装成一个独立的CompletableFuture,当异步线程回调时,调用 future.complete(T) ,将结果封装。

    将天气执行的Call逻辑,也封装成为一个独立的CompletableFuture ,完成之后,逻辑同上。

    compose衔接,whenComplete输出:

    每一个IO操作,均可以封装为独立的CompletableFuture,从而避免回调地狱。

    CompletableFuture,只有两个属性:

    • result:Future的执行结果 (Either the result or boxed AltResult)。
    • stack:操作栈,用于定义这个Future接下来操作的行为 (Top of Treiber stack of dependent actions)。

    weatherFuture这个方法是如何被调用的呢?

    通过堆栈可以发现,是在
    reverseCodeFuture.complete(result) 的时候,并且也将获得的adcode作为参数执行接下来的逻辑。

    这样一来,就完美解决回调地狱问题,在主的逻辑中,看起来像是在同步的进行编码。

    六 Vert.x Future

    Info-Service中,大量使用的 Vert.x Future 也是类似的解决的方案,不过设计上使用Handler的概念。

    核心执行的逻辑差不多:

    这当然不是Vertx的全部,当然这是题外话了。

    七 Reactive Streams

    异步编程对吞吐量以及资源有好处,但是有没有统一的抽象去解决此类问题内,答案是 Reactive Streams。

    核心抽象:Publisher Subscriber Processor Subscription ,整个包里面,只有这四个接口,没有实现类。

    在JDK 9里面,已经被作为一种规范封装到 java.util.concurrent.Flow :

    参考资料

    https://www.baeldung.com/java-9-reactive-streams

    http://ypk1226.com/2019/07/01/reactive/reactive-streams/

    https://www.reactivemanifesto.org/

    https://projectreactor.io/learn

    一个简单的例子:

    八 Reactor & Spring 5 & Spring WebFlux

    Flux & Mono

     

    原文链接

    本文为阿里云原创内容,未经允许不得转载。

    展开全文
  • 服务端响应之前,IO会阻塞在: java.net.SocketInputStream#socketRead0 的native方法上: 2 JDK NIO & Future java 1.5之后 优点:主线程可以不用等待IO响应,可以去做点其他的,比如说再发送一个IO请求,...

    1 服务端执行,最简单的同步调用方式:

    • 缺陷:
    • 服务端响应之前,IO会阻塞在:
    • java.net.SocketInputStream#socketRead0 的native方法上:

     

    2 JDK NIO & Future java 1.5之后

    • 优点:主线程可以不用等待IO响应,可以去做点其他的,比如说再发送一个IO请求,可以等到一起返回;
    • 缺点: 主线程在等待结果返回过程中依然需要等待,没有根本解决此问题;

    3 使用Callback回调方式

    • 优点:主线程完成发送请求后,再也不用关心这个逻辑,去执行其他的逻辑;整个过程中已经没有线程阻塞;如 使用nio的EventLoopGroup中的线程执行完所有逻辑;
    • 缺点:回调地狱;Callback hell  代码可读性低、编写费劲、容易出错

    4  JDK 1.8 CompletableFuture

    • 优点:解决Callback Hell的问题,JDK 1.8中提供了CompletableFuture;每一个IO操作,均可以封装为独立的CompletableFuture,从而避免回调地狱。
    • 实现:将逆Callback逻辑,封装成一个独立的CompletableFuture,当异步线程回调时,调用 future.complete(T) ,将结果封装;thenCompose衔接,whenComplete输出;
    • 小结:这样一来,就完美解决回调地狱问题,在主的逻辑中,看起来像是在同步的进行编码。

    5 源码举例 测试+结果

    
    import java.util.concurrent.CompletableFuture;
    
    public class CompletableFutureTest {
    
        private static CompletableFuture<String> invokeAFuture(String rawASource){
            CompletableFuture<String> future = new CompletableFuture<>();
            System.out.println("pre-do-invokeA");
            try {
                Thread.sleep(1000);
                future.complete("invokeA "+rawASource+" result = skip");
            }catch (Exception e){
    
            }
            return future;
        }
    
        private static CompletableFuture<String> invokeBFuture(String rawAResult){
            CompletableFuture<String> future = new CompletableFuture<>();
            System.out.println("pre-do-invokeB");
            try {
                Thread.sleep(1000);
                future.complete("after A done result = "+rawAResult+", then invokeB result = success");
            }catch (Exception e){
    
            }
            return future;
        }
    
        public static void main(String[] args) {
            invokeAFuture("加油").thenCompose(aResult-> invokeBFuture(aResult)).whenComplete((resultB, throwable) ->{
                if(throwable != null){
                    throwable.printStackTrace();
                    return;
                }
                System.out.println(resultB);
            });
        }
        
         public static void main(String[] args) {
            invokeAFuture("加油").thenCompose(CompletableFutureTest::invokeBFuture).whenComplete((resultB, throwable) ->{
                if(throwable != null){
                    throwable.printStackTrace();
                    return;
                }
                System.out.println(resultB);
            });
        }
    }
    
    pre-do-invokeA
    pre-do-invokeB
    after A done result = invokeA 加油 result = skip, then invokeB result = success

    6 小结:

    •    1 尝试使用异步编程方式;
    •    2 剖析内部实现原理;
    •    3 java9 juc 包有了更抽象的flow处理方式;

     

     

    展开全文
  • # 真正意义上的 异步IO 是说内核直接将数据拷贝至用户态的内存单元,再通知程序直接去读取数据。 # select / poll / epoll 都是同步IO的多路复用模式 1.同步和异步 # 同步和异步关注的是消息通信机制 # 所谓...
  • 同步异步,阻塞非阻塞 前言 在工作和同事交流时,面试时,看文档介绍时,经常遇到这些概念,把之前看到的和自己理解的整理一下: “阻塞”与"非阻塞"与"同步"与“异步"不能简单的从字面理解,提供一个从分布式系统...
  • 同步异步、阻塞非阻塞 个人认为同步和异步是更抽象的概念,是相对的任务而言的。而阻塞和非阻塞就就字面的意思是对当前的进程或线程而言的。 概念之间的区别同步与异步 同步与异步在不同的场景下有不同的概念,在...
  • AIO(异步非阻塞

    2018-02-22 13:55:26
    异步非阻塞AIO编程,在NIO基础之上引入了异步通道的概念,并提供了异步文件和异步套接字的实现,从而在真正意义上实现了异步非阻塞,之前我们学习的NIO只是非阻塞而并非异步。而AIO它不需要通过多路复用器对注册的...
  • Unix网络编程之同步/异步/阻塞/非阻塞
  • 异步就是异步,别扯 异步阻塞 异步非阻塞的 <Unix网络编程>,POSIX标准。都没有提到过 哪两个名词,异步就是异步。只有同步时候才有 阻塞和非阻塞 的说法。 都tm异步了,还阻不阻塞个jb 还有 百度的这个,...
  • IO的两个重要步骤:发起IO...而阻塞和非阻塞的区别在于发起IO请求的时候是否会阻塞,如果会就是阻塞,不会就是非阻塞。 NIO:同步非阻塞IO 参考如下 同步需要主动去询问结果 http://weixiaolu.iteye.com/b...
  • 这是一边通俗易懂,深刻全面说了 同步,异步,阻塞,非阻塞 概念的文章,值得阅读!! 1.基本概念 引子 以ajax为例: 异步就是不等待结果的代码, 异步并不是同时做两件事情 #结果打印顺序是 1,3,2 " 之所以会是这样是...
  • 异步非阻塞

    2016-09-07 09:37:00
    首先讨论下使用事件驱动,异步编程的优点: 充分利用了系统资源,执行代码无须阻塞等待某种操作完成,有限的资源可以用于其他的任务。其非常适合于后端的网络服务编程。 在服务器开发中,并发的请求处理是个大...
  • 在IO和网络编程中,我们经常看到几个概念:同步、异步、阻塞、非阻塞。 同步和异步  同步和异步是针对应用程序和内核的交互而言的,同步指的是用户进程触发IO 操作并等待或者轮询的去查看IO 操作是否就绪,而异步...
  • 同步/异步/阻塞/非阻塞 同步和异步: 同步和异步对应于调用者与被调用者,它们是线程之间的关系,两个线程之间要么是同步的,要么是异步的。 同步操作时,调用者需要等待被调用者返回结果,才会进行下一步操作。 ...
  • 对于Node开发者来说,非阻塞异步编程是他们引以为傲的地方。而在JDK8中,也引入了非阻塞异步编程的概念。所谓非阻塞异步编程,就是一种不需要等待返回结果的多线程的回调方法的封装。使用非阻塞异步编程,可以很大...
  • 参考Tornado 源码分析 - 异步篇Tornado 框架中异步非阻塞编程代码说明Tornado之源码分析(一)异步客户端篇tornado分析(1).基础小结【优化tornado阻塞任务的三个选择】
  • 网络编程时的同步、异步、阻塞、非阻塞? 同步:函数调用在没得到结果之前,没有调用结果,不返回任何结果。 异步:函数调用在没得到结果之前,没有调用结果,返回状态信息。 阻塞:函数调用在没得到结果之前,当前线程挂起。...
  • 作者:银月游侠 ...来源:知乎 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。   这几个概念,上面不少答案已经写得很清楚了。...我认为同步、异步、阻塞、非阻塞,是分3个层...
  • VC WSA 异步非阻塞网络编程WSARecvFrom调用失败;下面是主要代码,发送是成功的,但是接受的时候总是不成功,接受到的数据为空, BOOL CChatToDlg::InitSocket(void) { m_socket = ::WSASocket(AF_INET,SOCK_...
  • tornado的异步非阻塞 tornado支持同步和异步两种模式,一般的写法是同步方式,想要支持异步就需要一点特殊的写法。 web框架的异步模式是为了让程序的效率更高,如果http请求让线程干的事情都是计算密集型任务,那么...
  • 文章目录来源同步与异步概念消息通知场景比喻阻塞与非阻塞概念描述场景比喻同步/异步与阻塞/非阻塞组合小明的故事 来源 https://www.jianshu.com/p/aed6067eeac9 同步与异步 这两个概念与消息的通知机制有关。也就是...
  • AIO------在NIO的基础上引入了异步通道的概念,并提供了异步文件和异步套接字通道的实现,从而在真正意义上实现了异步非阻塞,这是在jdk1.7及以后才有的。AIO不需要通过类似NIO的多路复用器对注册的通道进行轮训操作...
  • 许多概念,诸如:同步(Sync)/异步(Async),阻塞(Block)/非阻塞(Unblock)等,初学者往往迷惑不清,只知其所以而不知起所以然。  异步方式指的是发送方不等接收方响应,便接着发下个数据包的通信方式;而同步指发送...
  • 同步异步 阻塞非阻塞

    2020-01-29 10:50:12
    有些文章将这四个作了两两组合,于是就有了:异步阻塞和异步非阻塞,可以明确的说,这完全是牵强之理解,无论<Unix网络编程>一书中所列的I/O模式,还是POSIX标准,都没有提这两个概念。异步就是异步!只有同步...
  • 同步异步阻塞非阻塞杂记

    万次阅读 2017-11-10 12:19:18
    gevent实现的协程是同步非阻塞还是异步非阻塞? gevent是一个使用完全同步编程模型的可扩展的异步I/O框架。 IO是不是阻塞的和协程是没有关系的,python本来就能支持非阻塞IO, 比如在linux只要用API,更改了...
  • 刚开始接触socket的编程的时候,遇到了很多的问题,费了很大劲搞懂。其实往往都是一些比较基本的知识,但是都是很重要的,只要对其熟练的掌握后,相信对基于网络的编程会有很大的提高,呵呵。  就拿基于C/S结构...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,603
精华内容 1,441
关键字:

异步非阻塞编程