threadpool

When I write asynchronous code with async/await, usually with ConfigureAwait(false) to avoid capturing the context, my code is jumping from one thread-pool thread to the next after each await . This raises concerns about thread safety. Is this code safe? static async Task Main() { int count = 0; for (int i = 0; i < 1_000_000; i++) { Interlocked.Increment(ref count); await Task.Yield(); } Console.WriteLine(count == 1_000_000 ? "OK" : "Error"); } The variable i is unprotected, and is accessed by multiple thread-pool threads*. Although the pattern of access is non-concurrent, it should be

I am investigating some crashes in my application caused by a Win32 exception, and I have narrowed it down that it must be occurring in the threadpool which is taking care of the EventLog.EntryWrittenEventHandler event handler in my application. I set this up like this: // Create the event log monitor eventLog.Log = "Application"; eventLog.EnableRaisingEvents = true; eventLog.EntryWritten += new EntryWrittenEventHandler(EventLogMonitor); EventLogMonitor is the handler for my event. I am wondering does anybody have any ideas as to where I could find out whats causing this exception. It seems

When a thread pool thread is done, does stuff like Name or thread local data get reset? So when the thread comes out of the pool next time, it's like brand new? Is there an "official" documentation on this aspect of the ThreadPool threads? It does NOT clear thread local storage when it's released, which is the most important aspect to note. http://msdn.microsoft.com/en-us/library/system.threading.threadpool.aspx When the thread pool reuses a thread, it does not clear the data in thread local storage or in fields that are marked with the ThreadStaticAttribute attribute. Therefore, data that is

The standard function std::async : The template function async runs the function f asynchronously (potentially in a separate thread which may be part of a thread pool) and returns a std::future that will eventually hold the result of that function call. There is two launch polices std::launch::async and std::launch::deferred . In my compiler's ( GCC 6.2 ) standard library impelmentation, the first one always creates a new thread and the second one does lazy evaluation on the calling thread. By default std::launch::deferred is used. Is there some implementation which uses thread pool with size

I read in Adam Bien's JavaEE night hacks book that while thread creation is prohibited on EJB containers, this is not the case for web containers. He actually creates a thread pool executor in his x-ray probe which runs on Tomcat. I'm a little confused now. While I faced situations in which I had to do manual thread-pool management in an EE app, I can somehow understand why it would be a bad idea to manually create threads in a JavaEE container. However, I don't understand the difference between an EJB container and a web container respecting thread creation when you can deploy a great portion