Understanding async/await without threads [duplicate]

According to MSDN, async and await do not create new threads:

The async and await keywords don't cause additional threads to be created.

With this in mind, I'm having difficulty understanding control flow of some simple programs. My complete example is below. Note that it requires the Dataflow library, which you can install from NuGet.

using System;
using System.Threading.Tasks.Dataflow;

namespace TaskSandbox
{
    class Program
    {
        static void Main(string[] args)
        {
            BufferBlock<int> bufferBlock = new BufferBlock<int>();

            Consume(bufferBlock);
            Produce(bufferBlock);

            Console.ReadLine();
        }

        static bool touched;
        static void Produce(ITargetBlock<int> target)
        {
            for (int i = 0; i < 5; i++)
            {
                Console.Error.WriteLine("Producing " + i);
                target.Post(i);
                Console.Error.WriteLine("Performing intensive computation");
                touched = false;
                for (int j = 0; j < 100000000; j++)
                    ;
                Console.Error.WriteLine("Finished intensive computation. Touched: " + touched);
            }

            target.Complete();
        }

        static async void Consume(ISourceBlock<int> source)
        {
            while (await source.OutputAvailableAsync())
            {
                touched = true;
                int received = source.Receive();
                Console.Error.WriteLine("Received " + received);
            }
        }
    }
}

Output:

Producing 0
Performing intensive computation
Received 0
Finished intensive computation. Touched: True
Producing 1
Performing intensive computation
Received 1
Finished intensive computation. Touched: True
Producing 2
Performing intensive computation
Received 2
Finished intensive computation. Touched: False
Producing 3
Performing intensive computation
Received 3
Finished intensive computation. Touched: False
Producing 4
Performing intensive computation
Received 4
Finished intensive computation. Touched: True

This seems to indicate that Consume is given control while the for loop is running, as the OutputAvailableAsync task completes:

for (int j = 0; j < 100000000; j++)
    ;

This would be unsurprising in a threaded model. But if no additional threads are involved, how can Produce yield control in the middle of the for loop?

• @I4V: The answer to that question states that "it's necessary that all blocking operations explicitly yield control using the async/await model." But in my question, control passes from Produce to Consume without Produce explicitly yielding control. That is the part that I am confused about. - Matthew
• @Matthew Since this is a Console application there is no SynchronizationContext, which means that all of the callbacks from await calls go to SynchronizationContext.Default, which is the thread pool, so technically there are actually two threads running at times during the execution of this program. To prevent the creation of additional threads you'd need to create your own custom sync context and set that. If you did, you'd see that the Recieved calls wouldn't be called until all of the producing was done specifically because you're not yielding control while producing. - Servy
• @Servy: If there are multiple threads involved, why does MSDN claim that "In particular, this approach is better than BackgroundWorker for IO-bound operations because...you don't have to guard against race conditions"? I edited my example to add a simple race condition. - Matthew
• @Matthew Using await doesn't necessarily involve the creation of thread. You can use it in ways that don't ever create threads. You simply haven't done so. Also note that it's using the thread pool thread just to run the callback. That thread pool thread isn't blocking when it has nothing to do, it's actually doing nothing and is released back to the pool; it's capable of handling another request. This is important because it means you don't have 100 thread pool thread sitting there blocking, waiting for IO to be completed. - Servy
• @Matthew You may find my async/await intro helpful. I tried to cover the basics (with all relevant details) in a single post. - Stephen Cleary