asynchronous vs non-blocking

Question

What is the difference between asynchronous and non-blocking calls  Also between blocking and synchronous calls  with examples please

User · Answer

Asynchronous refers to something done in parallel  say is another thread  Non-blocking often refers to polling  i e  checking whether given condition holds  socket is readable  device has more data  etc

User · Answer

As you can probably see from the multitude of different  and often mutually exclusive  answers  it depends on who you ask  In some arenas  the terms are synonymous  Or they might each refer to two similar concepts    One interpretation is that the call will do something in the background essentially unsupervised in order to allow the program to not be held up by a lengthy process that it does not need to control  Playing audio might be an example - a program could call a function to play  say  an mp3  and from that point on could continue on to other things while leaving it to the OS to manage the process of rendering the audio on the sound hardware  The alternative interpretation is that the call will do something that the program will need to monitor  but will allow most of the process to occur in the background only notifying the program at critical points in the process  For example  asynchronous file IO might be an example - the program supplies a buffer to the operating system to write to file  and the OS only notifies the program when the operation is complete or an error occurs    In either case  the intention is to allow the program to not be blocked waiting for a slow process to complete - how the program is expected to respond is the only real difference  Which term refers to which also changes from programmer to programmer  language to language  or platform to platform  Or the terms may refer to completely different concepts  such as the use of synchronous asynchronous in relation to thread programming    Sorry  but I don t believe there is a single right answer that is globally true

User · Answer

Non-blocking   This function won t wait while on the stack   Asynchronous   Work may continue on behalf of the function call after that call has left the stack

User · Answer

Blocking  control returns to invoking precess after processing of primitive sync or async  completes  Non blocking  control returns to process immediately after invocation

User · Answer

synchronous   asynchronous is to describe the relation between two modules  blocking   non-blocking is to describe the situation of one module  An example  Module X   quot I quot   Module Y   quot bookstore quot   X asks Y  do you have a book named  quot c   primer quot    blocking  before Y answers X  X keeps waiting there for the answer  Now X  one module  is blocking  X and Y are two threads or two processes or one thread or one process  we DON T know   non-blocking  before Y answers X  X just leaves there and do other things  X may come back every two minutes to check if Y has finished its job  Or X won t come back until Y calls him  We don t know  We only know that X can do other things before Y finishes its job  Here X  one module  is non-blocking  X and Y are two threads or two processes or one process  we DON T know   BUT we are sure that X and Y couldn t be one thread   synchronous  before Y answers X  X keeps waiting there for the answer  It means that X can t continue until Y finishes its job  Now we say  X and Y  two modules  are synchronous   X and Y are two threads or two processes or one thread or one process  we DON T know   asynchronous  before Y answers X  X leaves there and X can do other jobs  X won t come back until Y calls him  Now we say  X and Y  two modules  are asynchronous   X and Y are two threads or two processes or one process  we DON T know  BUT we are sure that X and Y couldn t be one thread    Please pay attention on the two bold-sentences above  Why does the bold-sentence in the 2  contain two cases whereas the bold-sentence in the 4  contains only one case  This is a key of the difference between non-blocking and asynchronous  Here is a typical example about non-blocking  amp  synchronous     thread X while  true        msg   recv Y  NON BLOCKING FLAG       if  msg is not empty                break            else               sleep 2000      2 sec             thread Y    prepare the book for X send X  book    You can see that this design is non-blocking  you can say that most of time this loop does something nonsense but in CPU s eyes  X is running  which means that X is non-blocking  whereas X and Y are synchronous because X can t continue to do any other things X can t jump out of the loop  until it gets the book from Y  Normally in this case  make X blocking is much better because non-blocking spends much resource for a stupid loop  But this example is good to help you understand the fact  non-blocking doesn t mean asynchronous  The four words do make us confused easily  what we should remember is that the four words serve for the design of architecture  Learning about how to design a good architecture is the only way to distinguish them  For example  we may design such a kind of architecture     Module X   Module X1   Module X2    Module X1 while  true        msg   recv many other modules  NON BLOCKING FLAG       if  msg is not null                if  msg     quot done quot                         break                       create a thread to process msg           else               sleep 2000      2 sec            Module X2 broadcast  quot I got the book from Y quot         Module Y    prepare the book for X send X  book    In the example here  we can say that  X1 is non-blocking X1 and X2 are synchronous X and Y are asynchronous  If you need  you can also describe those threads created in X1 with the four words  The more important things are  when do we use synchronous instead of asynchronous  when do we use blocking instead of non-blocking  Is making X1 blocking better than non-blocking  Is making X and Y synchronous better than asynchronous  Why is Nginx non-blocking  Why is Apache blocking  These questions are what you must figure out  To make a good choice  you must analyze your need and test the performance of different architectures  There is no such an architecture that is suitable for various of needs

User · Answer

The blocking models require the initiating application to block when the I O has started  This means that it isn t possible to overlap processing and I O at the same time  The synchronous non-blocking model allows overlap of processing and I O  but it requires that the application check the status of the I O on a recurring basis  This leaves asynchronous non-blocking I O  which permits overlap of processing and I O  including notification of I O completion

User · Answer

They differ in spelling only   There is no difference in what they refer to   To be technical you could say they differ in emphasis  Non blocking refers to control flow it doesn t block   Asynchronous refers to when the event data is handled not synchronously

User · Answer

A nonblocking call returns immediately with whatever data are available  the full number of bytes requested  fewer  or none at all    An asynchronous call requests a transfer that will be performed in its whole entirety  but will complete at some future time

User · Answer

Blocking call  Control returns only when the call completes   Non blocking call  Control returns immediately  Later OS somehow notifies the process that the call is complete     Synchronous program  A program which uses Blocking calls  In order not to freeze during the call it must have 2 or more threads  that s why it s called Synchronous - threads are running synchronously    Asynchronous program  A program which uses Non blocking calls  It can have only 1 thread and still remain interactive

User · Answer

In many circumstances they are different names for the same thing  but in some contexts they are quite different   So it depends  Terminology is not applied in a totally consistent way across the whole software industry   For example in the classic sockets API  a non-blocking socket is one that simply returns immediately with a special  would block  error message  whereas a blocking socket would have blocked  You have to use a separate function such as select or poll to find out when is a good time to retry   But asynchronous sockets  as supported by Windows sockets   or the asynchronous IO pattern used in  NET  are more convenient  You call a method to start an operation  and the framework calls you back when it s done  Even here  there are basic differences  Asynchronous Win32 sockets  marshal  their results onto a specific GUI thread by passing Window messages  whereas  NET asynchronous IO is free-threaded  you don t know what thread your callback will be called on    So they don t always mean the same thing  To distil the socket example  we could say    Blocking and synchronous mean the same thing  you call the API  it hangs up the thread until it has some kind of answer and returns it to you  Non-blocking means that if an answer can t be returned rapidly  the API returns immediately with an error and does nothing else  So there must be some related way to query whether the API is ready to be called  that is  to simulate a wait in an efficient way  to avoid manual polling in a tight loop   Asynchronous means that the API always returns immediately  having started a  background  effort to fulfil your request  so there must be some related way to obtain the result

User · Answer

Putting this question in the context of NIO and NIO 2 in java 7  async IO is one step more advanced than non-blocking  With java NIO non-blocking calls  one would set all channels  SocketChannel  ServerSocketChannel  FileChannel  etc  as such by calling AbstractSelectableChannel configureBlocking false   After those IO calls return  however  you will likely still need to control the checks such as if and when to read write again  etc  For instance    while   isDataEnough          socketchannel read inputBuffer          do something else and then read again     With the asynchronous api in java 7  these controls can be made in more versatile ways  One of the 2 ways is to use CompletionHandler  Notice that both read calls are non-blocking   asyncsocket read inputBuffer  60  TimeUnit SECONDS    60 secs for timeout          new CompletionHandler lt Integer  Object gt              public void completed Integer result  Object attachment                  public void failed Throwable e  Object attachment

User · Answer

Synchronous is defined as happening at the same time  Asynchronous is defined as not happening at the same time  This is what causes the first confusion  Synchronous is actually what is known as parallel  While asynchronous is sequential  do this  then do that  Now the whole problem is about modeling an asynchronous behaviour  because you ve got some operation that needs the response of another before it can begin  Thus it s a coordination problem  how will you know that you can now start that operation  The simplest solution is known as blocking  Blocking is when you simply choose to wait for the other thing to be done and return you a response before moving on to the operation that needed it  So if you need to put butter on toast  and thus you first need to toast the bred  The way you d coordinate them is that you d first toast the bred  then stare endlessly at the toaster until it pops the toast  and then you d proceed to put butter on them  It s the simplest solution  and works very well  There s no real reason not to use it  unless you happen to also have other things you need to be doing which  don t require coordination with the operations  For example  doing some dishes  Why wait idle staring at the toaster constantly for the toast to pop  when you know it ll take a bit of time  and you could wash a whole dish while it finishes  That s where two other solutions known respectively as non-blocking and asynchronous come into play  Non-blocking is when you choose to do other unrelated things while you wait for the operation to be done  Checking back on the availability of the response as you see fit  So instead of looking at the toaster for it to pop  You go and wash a whole dish  And then you peek at the toaster to see if the toasts have popped  If they havn t  you go wash another dish  checking back at the toaster between each dish  When you see the toasts have popped  you stop washing the dishes  and instead you take the toast and move on to putting butter on them  Having to constantly check on the toasts can be annoying though  imagine the toaster is in another room  In between dishes you waste your time going to that other room to check on the toast  Here comes asynchronous  Asynchronous is when you choose to do other unrelated things while you wait for the operation to be done  Instead of checking on it though  you delegate the work of checking to something else  could be the operation itself or a watcher  and you have that thing notify and possibly interupt you when the response is availaible so you can proceed to the other operation that needed it  Its a weird terminology  Doesn t make a whole lot of sense  since all these solutions are ways to create asynchronous coordination of dependent tasks  That s why I prefer to call it evented  So for this one  you decide to upgrade your toaster so it beeps when the toasts  are done  You happen to be constantly listening  even while you are doing dishes  On hearing the beep  you queue up in your memory that as soon as you are done washing your current dish  you ll stop and go put the butter on the toast  Or you could choose to interupt the washing of the current dish  and deal with the toast right away  If you have trouble hearing the beep  you can have your partner watch the toaster for you  and come tell you when the toast is ready  Your partner can itself choose any of the above three strategies to coordinate its task of watching the toaster and telling you when they are ready  On a final note  it s good to understand that while non-blocking and async  or what I prefer to call evented  do allow you to do other things while you wait  you don t have too  You can choose to constantly loop on checking the status of a non-blocking call  doing nothing else  That s often worse than blocking though  like looking at the toaster  then away  then back at it until its done   so a lot of non-blocking APIs allow you to transition into a blocking mode from it  For evented  you can just wait idle until you are notified  The downside in that case is that adding the notification was complex and potentially costly to begin with  You had to buy a new toaster with beep functionality  or convince your partner to watch it for you  And one more thing  you need to realize the trade offs all three provide  One is not obviously better than the others  Think of my example  If your toaster is so fast  you won t have time to wash a dish  not even begin washing it  that s how fast your toaster is  Getting started on something else in that case is just a waste of time and effort  Blocking will do  Similarly  if washing a dish will take 10 times longer then the toasting  You have to ask yourself what s more important to get done  The toast might get cold and hard by that time  not worth it  blocking will also do  Or you should pick faster things to do while you wait  There s more obviously  but my answer is already pretty long  my point is you need to think about all that  and the complexities of implementing each to decide if its worth it  and if it ll actually improve your throughput or performance  Edit  Even though this is already long  I also want it to be complete  so I ll add two more points   There also commonly exists a fourth model known as multiplexed  This is when while you wait for one task  you start another  and while you wait for both  you start one more  and so on  until you ve got many tasks all started and then  you wait idle  but on all of them  So as soon as any is done  you can proceed with handling its response  and then go back to waiting for the others  It s known as multiplexed  because while you wait  you need to check each task one after the other to see if they are done  ad vitam  until one is  It s a bit of an extension on top of normal non-blocking   In our example it would be like starting the toaster  then the dishwasher  then the microwave  etc  And then waiting on any of them  Where you d check the toaster to see if it s done  if not  you d check the dishwasher  if not  the microwave  and around again   Even though I believe it to be a big mistake  synchronous is often used to mean one thing at a time  And asynchronous many things at a time  Thus you ll see synchronous blocking and non-blocking used to refer to blocking and non-blocking  And asynchronous blocking and non-blocking used to refer to multiplexed and evented   I don t really understand how we got there  But when it comes to IO and Computation  synchronous and asynchronous often refer to what is better known as non-overlapped and overlapped  That is  asynchronous means that IO and Computation are overlapped  aka  happening concurrently  While synchronous means they are not  thus happening  sequentially  For synchronous non-blocking  that would mean you don t start other IO or Computation  you just busy wait and simulate a blocking call  I wish people stopped misusing syncronous and asynchronous like that  So I m not encouraging it

[asynchronous] asynchronous vs non-blocking

Examples related to asynchronous

Examples related to blocking

Examples related to synchronous