I am a big fan of **Flask** - in part because it is simple and in part because has a lot of [extensions][1].  However, Flask is meant to be used in a WSGI environment, and WSGI is not a non-blocking, so (I believe) it doesn&#39;t scale as well as **Tornado** for certain kinds of applications.

Since each one has an URL dispatcher which will call a function, and both will use Python files (in Django you dont launch the python file but in flask or tornado you do) do does it make sense to  have two seperate parts to your website - one part running the non-blocking jobs with Tornado, and the other part written with Flask?

If this is a good idea, how would you go about sharing cookies / sessions between Flask and Tornado? Will I run into issues, since Flask will use it own system and Tornado will use its own system?


  [1]: http://flask.pocoo.org/extensions/

using Flask and Tornado together?

Can someone explain/ redirect me, what is the difference between Node.js&#39;s async model(non blocking thread) vs any other language for example c#&#39;s asynchronous way of handling the I/O. This looks to me that both are same model. Kindly suggest. 

Node.js vs Async/await in .net

I am somewhat confused over how Go handles non blocking IO.
API&#39;s mostly look synchronous to me, and when watching presentations on Go, its not uncommon to hear comments like &quot;and the call blocks&quot;

Is Go using blocking IO when reading from files or network?
Or is there some kind of magic that re-writes the code when used from inside a Go Routine?

Coming from a C# background, this feels very non intuitive, in C# we have the `await` keyword when consuming async API&#39;s.
Which clearly communicates that the API can yield the current thread and continue later inside a continuation.

So TLDR;
Will Go block the current thread when doing IO inside a Go routine, or will it be transformed into a C# like async await state machine using continuations?


Golang blocking and non blocking

Here&#39;s my problem. I implemented a small script that does some heavy calculation, as a node.js module. So, if I type &quot;node myModule.js&quot;, it calculates for a second, then returns a value.
Now, I want to use that module from my main Node.JS program. I could just put all the calculation in a &quot;doSomeCalculation&quot; function then do:

    var myModule = require(&quot;./myModule&quot;);
    myModule.doSomeCalculation();

But that would be blocking, thus it&#39;d be bad. I&#39;d like to use it in a non-blocking way, like DB calls natively are, for instance. So I tried to use child_process.spawn and exec, like this:

    var spawn = require(&quot;child_process&quot;).spawn;
    var ext = spawn(&quot;node ./myModule.js&quot;, function(err, stdout, stderr) { /* whatevs */ });
    ext.on(&quot;exit&quot;, function() { console.log(&quot;calculation over!&quot;); });

But, of course, it doesn&#39;t work. I tried to use an EventEmitter in myModule, emitting &quot;calculationDone&quot; events and trying to add the associated listener on the &quot;ext&quot; variable in the example above. Still doesn&#39;t work.

As for forks, they&#39;re not really what I&#39;m trying to do. Forks would require putting the calculation-related code in the main program, forking, calculating in the child while the parent does whatever it does, and then how would I return the result?

So here&#39;s my question: can I use a child process to do some non-blocking calculation, when the calculation is put in a Node file, or is it just impossible? Should I do the heavy calculation in a Python script instead? In both cases, how can I pass arguments to the child process - for instance, an image?

How can I execute a node.js module as a child process of a node.js program?

I wonder if there is a way to make asynchronous calls to a database?

For instance, imagine that I&#39;ve a big request that take a very long time to process, I want to send the request and receive a notification when the request will return a value (by passing a Listener/callback or something). I don&#39;t want to block waiting for the database to answer.

I don&#39;t consider that using a pool of threads is a solution because it doesn&#39;t scale, in the case of heavy concurrent requests this will spawn a very large number of threads.

We are facing this kind of problem with network servers and we have found solutions by using select/poll/epoll system call to avoid having one thread per connection. I&#39;m just wondering how to have a similar feature with database request?

Note:
I&#39;m aware that using a FixedThreadPool may be a good work-around, but I&#39;m surprised that nobody has developed a system really asynchronous (without the usage of extra thread).

** Update **  
Because of the lack of real practical solutions, I decided to create a library (part of finagle) myself: [finagle-mysql][1]. It basically decodes/decodes mysql request/response, and use Finagle/Netty under the hood. It scales extremely well even with huge number of connections.


  [1]: https://github.com/twitter/finagle/tree/master/finagle-mysql

Is asynchronous jdbc call possible?

I saw in WCF they have the `[OperationContract(IsOneWay = true)]` attribute.  But WCF seems kind of slow and heavy just to do create a nonblocking function.  Ideally there would be something like  static void nonblocking `MethodFoo(){}`, but I don&#39;t think that exists.

What is the quickest way to create a nonblocking method call in C#?

E.g.

    class Foo
    {
        static void Main()
        {
            FireAway(); //No callback, just go away
            Console.WriteLine(&quot;Happens immediately&quot;);
        }
    
        static void FireAway()
        {
            System.Threading.Thread.Sleep(5000);
            Console.WriteLine(&quot;5 seconds later&quot;);
        }
    }

**NB**: Everyone reading this should think about if they actually want the method to finish. (See #2 top answer)  If the method has to finish, then in some places, like an ASP.NET application, you will need to do something to block and keep the thread alive. Otherwise, this could lead to &quot;fire-forget-but-never-actually-execute&quot;, in which case,of course, it would be simpler to write no code at all. ([A good description of how this works in ASP.NET][1])


  [1]: https://github.com/StephenCleary/AspNetBackgroundTasks

Simplest way to do a fire and forget method in C#?

In the context of Server Side Javascript engines, what is non-blocking I/O or asynchronous I/O? I see this being mentioned as an advantage over Java server side implementations.


What is non-blocking or asynchronous I/O in Node.js?

I searched the web on some technical details about blocking I/O and non blocking I/O and I found several people stating that non-blocking I/O would be faster than blocking I/O. For example in [this document][1].

If I use blocking I/O, then of course the thread that is currently blocked can&#39;t do anything else... Because it&#39;s blocked. But as soon as a thread starts being blocked, the OS can switch to another thread and not switch back until there is something to do for the blocked thread. So as long as there is another thread on the system that needs CPU and is not blocked, there should not be any more CPU idle time compared to an event based non-blocking approach, is there?

Besides reducing the time the CPU is idle I see one more option to increase the number of tasks a computer can perform in a given time frame: Reduce the overhead introduced by switching threads. But how can this be done? And is the overhead large enough to show measurable effects? Here is an idea on how I can picture it working:

 1. To load the contents of a file, an application delegates this task to an event-based i/o framework, passing a callback function along with a filename
 2. The event framework delegates to the operating system, which programs a DMA controller of the hard disk to write the file directly to memory
 3. The event framework allows further code to run.
 4. Upon completion of the disk-to-memory copy, the DMA controller causes an interrupt.
 5. The operating system&#39;s interrupt handler notifies the event-based i/o framework about the file being completely loaded into memory. How does it do that? Using a signal??
 6. The code that is currently run within the event i/o framework finishes.
 7. The event-based i/o framework checks its queue and sees the operating system&#39;s message from step 5 and executes the callback it got in step 1.

Is that how it works? If it does not, how does it work? That means that the event system can work without ever having the need to explicitly touch the stack (such as a real scheduler that would need to backup the stack and copy the stack of another thread into memory while switching threads)? How much time does this actually save? Is there more to it?

  [1]: http://code.danyork.com/2011/01/25/node-js-doctors-offices-and-fast-food-restaurants-understanding-event-driven-programming/

Is non-blocking I/O really faster than multi-threaded blocking I/O? How?

I&#39;m using the [subprocess module][1] to start a subprocess and connect to its output stream (standard output). I want to be able to execute non-blocking reads on its standard output. Is there a way to make .readline non-blocking or to check if there is data on the stream before I invoke `.readline`? I&#39;d like this to be portable or at least work under Windows and Linux.

Here is how I do it for now (it&#39;s blocking on the `.readline` if no data is available):

    p = subprocess.Popen(&#39;myprogram.exe&#39;, stdout = subprocess.PIPE)
    output_str = p.stdout.readline()

  [1]: http://docs.python.org/library/subprocess.html


A non-blocking read on a subprocess.PIPE in Python

1. What&#39;s the difference between:

- **Asynchronous**,
- **Non-Blocking**, and
- **Event-base** architectures?

2. Can something be both *asynchronous* and *non-blocking* (and *event-based*)?

3. What&#39;s most important in programming, to have something: asynchronous, non-blocking and/or event-base (or all 3)?

If you could provide examples, that would be great.

This question is being asked because I was reading this great [StackOverflow][1] article on a similar topic but it doesn&#39;t answer my questions above.

  [1]: https://stackoverflow.com/questions/2625493/asynchronous-vs-non-blocking

What&#39;s the difference between: Asynchronous, Non-Blocking, Event-Base architectures?

I&#39;m trying to write a program in C (on Linux) that loops until the user presses a key, but shouldn&#39;t require a keypress to continue each loop.

Is there a simple way to do this? I figure I could possibly do it with `select()` but that seems like a lot of work.

Alternatively, is there a way to catch a &lt;kbd&gt;ctrl&lt;/kbd&gt;-&lt;kbd&gt;c&lt;/kbd&gt; keypress to do cleanup before the program closes instead of non-blocking io?



C non-blocking keyboard input

Ok, Tornado is non-blocking and quite fast and it can handle a lot of standing requests easily.

But I guess it&#39;s not a silver bullet and if we just blindly run Django-based or any other site with Tornado it won&#39;t give any performance boost.

I couldn&#39;t find comprehensive explanation of this, so I&#39;m asking it here:

 - When should Tornado be used?
 - When is it useless?
 - When using it, what should be taken into account?
 - How can we make *inefficient* site using Tornado?
 - There is a server and a webframework.
   When should we use framework and when can we replace it with other one?

When and how to use Tornado? When is it useless?

Trying to summarize for myself the difference between these 2 concepts (because I&#39;m really confused when I see people are using both of them in one sentence, like &quot;non-blocking async IO&quot; which I&#39;m trying to figure out what does it mean).

So, in my understanding non-blocking IO is primary the OS mechanism to process the IO if there is any data ready, otherwise just return error/do nothing. 

In async IO you just provide a callback, and your application will be notified when the data is available.

So what is actually &quot;non-blocking async IO&quot;? And how all them can be implemented in Java (standard JDK, without external libs, I know there are `java.nio.channels.{Channels, Selector, SelectorKey}` and `java.nio.channels.{AsynchronousSocketChannel}`): non-blocking IO, async IO, and non-blocking async IO (if there is such thing)?

non-blocking IO vs async IO and implementation in Java

Basically, I&#39;ve read in several places that `socket.recv()` will return whatever it can read, or an empty string signalling that the other side has shut down  (the official docs don&#39;t even mention what it returns when the connection is shut down... great!). This is all fine and dandy for blocking sockets, since we know that `recv()` only returns when there actually is something to receive, so when it returns an empty string, it **MUST** mean the other side has closed the connection, right?

Okay, fine, but what happens when my socket is non-blocking?? I have searched a bit (maybe not enough, who knows?) and can&#39;t figure out how to tell when the other side has closed the connection using a non-blocking socket. There seems to be no method or attribute that tells us this, and comparing the return value of `recv()` to the empty string seems absolutely useless... is it just me having this problem?

As a simple example, let&#39;s say my socket&#39;s timeout is set to 1.2342342 (whatever non-negative number you like here) seconds and I call `socket.recv(1024)`, but the other side doesn&#39;t send anything during that 1.2342342 second period. The `recv()` call will return an empty string and I have no clue as to whether the connection is still standing or not...


What does Python&#39;s socket.recv() return for non-blocking sockets if no data is received until a timeout occurs?

How can I poll the keyboard from a console python app? Specifically, I would like to do something akin to this in the midst of a lot of other I/O activities (socket selects, serial port access, etc.):

    while True:
        # doing amazing pythonic embedded stuff
        # ...

        # periodically do a non-blocking check to see if
        # we are being told to do something else
        x = keyboard.read(1000, timeout = 0)

        if len(x):
            # ok, some key got pressed
            # do something

What is the correct pythonic way to do this on Windows? Also, portability to Linux wouldn&#39;t be bad, though it&#39;s not required.


Polling the keyboard (detect a keypress) in python

I&#39;ve noticed a couple of oddities when dealing with named pipes (FIFOs) under various flavors of UNIX (Linux, FreeBSD and MacOS X) using Python.  The first, and perhaps most annoying is that attempts to open an empty/idle FIFO read-only will block (unless I use `os.O_NONBLOCK` with the lower level `os.open()` call).  However, if I open it for read/write then I get no blocking.

Examples:

    f = open(&#39;./myfifo&#39;, &#39;r&#39;)               # Blocks unless data is already in the pipe
    f = os.open(&#39;./myfifo&#39;, os.O_RDONLY)    # ditto

    # Contrast to:
    f = open(&#39;./myfifo&#39;, &#39;w+&#39;)                           # does NOT block
    f = os.open(&#39;./myfifo&#39;, os.O_RDWR)                   # ditto
    f = os.open(&#39;./myfifo&#39;, os.O_RDONLY|os.O_NONBLOCK)   # ditto


I&#39;m just curious why.  Why does the open call block rather than some subsequent read operation?

Also I&#39;ve noticed that a non-blocking file descriptor can exhibit to different behaviors in Python.  In the case where I use `os.open()` with the `os.O_NONBLOCK` for the initial opening operation then an `os.read()` seems to return an empty string if data isn&#39;t ready on the file descriptor.  However, if I use `fcntl.fcnt(f.fileno(), fcntl.F_SETFL, fcntl.GETFL | os.O_NONBLOCK)` then an `os.read` raises an exception (`errno.EWOULDBLOCK`)

Is there some other flag being set by the normal `open()` that&#39;s not set by my `os.open()` example?  How are they different and why?

Why does a read-only open of a named pipe block?

Once upon a time I bumped into [Introduction to Indy][1] article and can&#39;t stop thinking about blocking vs non-blocking IO ever since then.

Looking for some good articles describing what are pros and cons of blocking IO and non-blocking IO and **how to design your application in each case** to get natural, easy to understand and easy to maintain code.  
Would like to understand BIG picture...


  [1]: http://www.swissdelphicenter.ch/en/showarticle.php?id=4

All Nonblocking Solutions on Gang of Coders

Total of 17 Nonblocking Solutions