.Net和Mono中的C＃Task.WaitAll（）

Question

Why does this code behave different on Windows and Linux (using Mono)?

static void Main(string[] args)
{
    Stopwatch stopwatch = Stopwatch.StartNew();
    Task[] tasks = new Task[1];

    tasks[0] = Task.Run(() =>
    {
        IPHostEntry iphe = Dns.GetHostEntry("8.8.8.8.dnsrbl.org");
    });
    Task.WaitAll(tasks, 2000);
    Console.WriteLine("Done in " + stopwatch.ElapsedMilliseconds + " ms");
}

8.8.8.8.dnsrbl.ru is an example of a query that will eventually time out. I believe there is no working DNS server (or its firewall is blocking me).

Anyway, the point is not getting a result from the DNS server, the point is how Task.WaitAll() behaves on Windows and Mono when waiting for a task containing a call to Dns.GetHostEntry() .

On Windows the program takes more or less 2 seconds to run when the query is not returning any result within the timeout period (2s). That is, Task.WaitAll with timeout seems to work. Running this program on Linux with Mono takes 2 seconds to get the output, but the program does not terminate until the task exits. Why is that?

It seems like I get the same execution time regardless if I use Time.WaitAll with timeout or not.

The clue is in Dns.GetHostEntry() because Task.WaitAll() works as expected if I start a task with a Thread.Sleep() simulating a long running task. This works as expected:

tasks[0] = Task.Run(() => Thread.Sleep(10000));

Is there a way to force Task.WaitAll(Task[] tasks, int millisecondsTimeout) to actually time out when running in Mono?

Edit: Task.WaitAll() does in fact return after the timeout period, but the program doesn't terminate when running in Mono (until Dns.GetHostEntry times out).

And it's not the compiler. I get the same result whether I compile with Visual Studio or the Mono C# compiler.

Answer 1

I'll answer my own question although credit should go to Evk who guided me on the right track (thanks mate!)

The subject on this question is bad to say the least. The problem has nothing to do with Task.WaitAll but rather the Mono implementation of Dns.GetHostEntry . As Evk said in a comment:

That means (most likely) that Dns.GetHostEntry on linux starts new non-background thread. Program cannot complete until all non-background threads are finished.

The GetHostEntry() method is located in the source file Dns.cs and when called with a string it calls GetHostByName which then calls GetHostByName_internal which is an external C function located in w32socket.c. Finally mono_get_address_info (in networking-posix.c) is called and we are down in the libc function getaddrinfo . Phew!

I cannot see any new non-background threads being started, but I found this:

MONO_ENTER_GC_SAFE;
ret = getaddrinfo (hostname, service_name, &hints, &info);
MONO_EXIT_GC_SAFE;

MONO_ENTER_GC_SAFE and MONO_EXIT_GC_SAFE are macros defined in mono-threads-api.h

#define MONO_ENTER_GC_SAFE  \
    do {    \
        gpointer __gc_safe_dummy;   \
        gpointer __gc_safe_cookie = mono_threads_enter_gc_safe_region (&__gc_safe_dummy)

#define MONO_EXIT_GC_SAFE   \
        mono_threads_exit_gc_safe_region (__gc_safe_cookie, &__gc_safe_dummy);  \
    } while (0)

I did not dig any further, but I believe Evk is right.

So, the answer to my question: Dns.GetHostEntry() cannot be terminated or cancelled in Mono. A program calling this method will not terminate until all queries has been processed or timed out. That's the way it is. My guess is that is has to do with the garbage collector (GC) which probably runs in non-background thread and hence cannot be cancelled/terminated.

Edit: (A few days later) The reason for this was obvious once I got down to the man-page for getaddrinfo . This function returns a linked list to the result. This list is of course allocated on the heap, and has to be freed at some point to avoid memory leakage. The function for that is freeaddrinfo .

Anyway, thanks again to Evk!

So how can we fire multiple DNS queries in parallel with a timeout (using Mono)? Easy! This function can be called in a Task and it will be happy to obey WaitAll with timeout:

private static string host(string query)
{
    ProcessStartInfo psi = new ProcessStartInfo("host", query);
    psi.UseShellExecute = false;
    psi.RedirectStandardOutput = true;
    Process p = Process.Start(psi);
    return p.StandardOutput.ReadToEnd();
}