synchronization

I have a small test application that executes two threads simultaneously. One increments a static long _value , the other one decrements it. I've ensured with ProcessThread.ProcessorAffinity that the threads are associated with different physical (no HT) cores to force intra processor communication and I have ensured that they overlap in execution time for a significant amount of time. Of course, the following does not lead to zero: for (long i = 0; i < 10000000; i++) { _value += offset; } So, the logical conclusion would be to: for (long i = 0; i < 10000000; i++) { Interlocked.Add(ref _value,

Say that I update values of two variables in a synchronized method. Would it be possible that the new values set in synchronized method be visible to other threads before exiting the synchronized block? public synchronized void setValues(){ a=5; // assume thread is preempted after this assignment // would the value 5 be visible to other threads? // my understanding is that the values will not be flushed to // main memory until the lock is released- i.e., until the synchronized // method is complete. So the changes will not be visible to other // threads even when not using synchronization b=10

so I have a boolean type in C++ on a multiprocessor machine. The variable starts out life as true, and then there are a few threads, any one or more of which might write it to be false. At the same time, these threads may also read this variable to check its state. I don't care if reading this variable is synchronized with any of the writes, they each happen at different places in the code, and it doesn't matter if it comes before or after any particular write. Now, do I need a lock for this boolean? The only way I would need a lock is if at the very low level, memory can get corrupted by two

I have a C# library that would like to have the ability to Send/Post work to the "main" ui thread (if one exists). This library may be used by: A winforms application A native application (with UI) A console application (with no UI) In the library I'd like to capture something (A SynchronizationContext, a Dispatcher, a Task Scheduler, or something else) during initialization, that will allow me to (at a later time) Send/Post work to the main thread (if the main thread has that ability--i.e. it has a message pump). For example, the library would like to put up some Winforms UI on the main

I've been mulling this over & reading but can find an absolute authoritative answer. I have several deep data structures made up of objects containing ArrayLists, Strings & primitive values. I can guarantee that the data in these structures will not change (no thread will ever make structural changes to lists, change references, change primitives). I'm wondering if reading data in these structures is thread safe; i.e. is it safe to recursively read variables from the objects, iterate the ArrayLists etc. to extract information from the structures in multiple threads without synchronization? The

From the Performance and Scalability chapter of the JCIP book : The synchronized mechanism is optimized for the uncontended case(volatile is always uncontended), and at this writing, the performance cost of a "fast-path" uncontended synchronization ranges from 20 to 250 clock cycles for most systems. What does the author mean by fast-path uncontended synchronization here? I'm not familiar with the topic of the book, but in general a “fast path” is a specific possible control flow branch which is significantly more efficient than the others and therefore preferred, but cannot handle complex