Yes, you can read from it and write to it safely – but you can’t do anything compound such as incrementing it safely, as that’s a read/modify/write cycle. There’s also the matter of how it interacts with access to other variables. The precise nature of volatile is frankly confusing (see the memory model section of … Read more
There are two products that can help you there: Microsoft Chess Typemock Racer Both check for deadlocks in your code (via unit test) and I think Chess checks for race conditions as well. Using both tools is easy – you write a simple unit test and the run your code several times and check if … Read more
Use: System.Windows.Application.Current.Dispatcher.Invoke( System.Windows.Threading.DispatcherPriority.Normal, (Action)delegate() { // Your Action Code });
For singletons there is an elegant solution by delegating the task to the JVM code for static initialization. public class Something { private Something() { } private static class LazyHolder { public static final Something INSTANCE = new Something(); } public static Something getInstance() { return LazyHolder.INSTANCE; } } see http://en.wikipedia.org/wiki/Initialization_on_demand_holder_idiom and this blog post … Read more
The SynchronizedCollection<T> class was introduced first in .NET 2.0 to provide a thread-safe collection class. It does this via locking so that you essentially have a List<T> where every access is wrapped in a lock statement. The System.Collections.Concurrent namespace is much newer. It wasn’t introduced until .NET 4.0 and it includes a substantially improved and … Read more
Two threads, accessing a non-atomic, non-guarded variable are U.B. This concerns finished. You could make finished of type std::atomic<bool> to fix this. My fix: #include <iostream> #include <future> #include <atomic> static std::atomic<bool> finished = false; int func() { size_t i = 0; while (!finished) ++i; return i; } int main() { auto result=std::async(std::launch::async, func); std::this_thread::sleep_for(std::chrono::seconds(1)); … Read more
A picture is worth 1000 words. The first SELECT statement reads the value of 50, while the second SELECT reads the value of 10 since in between the two read operations a write operation was executed. Linearizability means that modifications happen instantaneously, and once a registry value is written, any subsequent read operation will find … Read more
There are several ways in which a function can be thread safe. It can be reentrant. This means that a function has no state, and does not touch any global or static variables, so it can be called from multiple threads simultaneously. The term comes from allowing one thread to enter the function while another … Read more
If the JDBC driver is spec-compliant, then technically yes, the object is thread-safe, but you should avoid sharing connections between threads, since the activity on the connection will mean that only one thread will be able to do anything at a time. You should use a connection pool (like Apache Commons DBCP) to ensure that … Read more
The simplest way is to interrupt() it, which will cause Thread.currentThread().isInterrupted() to return true, and may also throw an InterruptedException under certain circumstances where the Thread is waiting, for example Thread.sleep(), otherThread.join(), object.wait() etc. Inside the run() method you would need catch that exception and/or regularly check the Thread.currentThread().isInterrupted() value and do something (for example, … Read more