double-checked-locking

Checkstyle reports this code as "The double-checked locking idiom is broken", but I don't think that my code actually is affected by the problems with double-checked locking. The code is supposed to create a row in a database if a row with that id doesn't exist. It runs in a multi-threaded environment and I want to avoid the primary-key-exists SQL-exceptions. The pseudo-code: private void createRow(int id) { Row row = dao().fetch(id); if (row == null) { synchronized (TestClass.class) { row = dao().fetch(id); if (row == null) { dao().create(id); } } } } I can agree that it looks like double

void undefined_behaviour_with_double_checked_locking() { if(!resource_ptr) #1 { std::lock_guard<std::mutex> lk(resource_mutex); #2 if(!resource_ptr) #3 { resource_ptr.reset(new some_resource); #4 } } resource_ptr->do_something(); #5 } if a thread sees the pointer written by another thread, it might not see the newly-created instance of some_resource, resulting in the call to do_something() operating on incorrect values. This is an example of the type of race condition defined as a data race by the C++ Standard, and thus specified as undefined behaviour. Question > I have seen the above

I have the following code which could be called via multiple web-requests at the same second. As such, I don't want the second+ request hitting the database, but waiting until the first one does. Should I refactor this to use the Lazy<T> keyword class instead? If 10 calls to a Lazy<T> piece of code occur at the same time, do 9 of those calls wait for the first one to complete? public class ThemeService : IThemeService { private static readonly object SyncLock = new object(); private static IList<Theme> _themes; private readonly IRepository<Theme> _themeRepository; <snip snip snip> #region

Why is the pattern considered broken? It looks fine to me? Any ideas? public static Singleton getInst() { if (instace == null) createInst(); return instace; } private static synchronized createInst() { if (instace == null) { instace = new Singleton(); } } It looks okay at first glance, but this technique has many subtle problems and should usually be avoided. For example, consider the following sequence of events: Thread A notices that the value is not initialized, so it obtains the lock and begins to initialize the value. The code generated by the compiler is allowed to update the shared

I have a piece of code that can be executed by multiple threads that needs to perform an I/O-bound operation in order to initialize a shared resource that is stored in a ConcurrentMap . I need to make this code thread safe and avoid unnecessary calls to initialize the shared resource. Here's the buggy code: private ConcurrentMap<String, Resource> map; // ..... String key = "somekey"; Resource resource; if (map.containsKey(key)) { resource = map.get(key); } else { resource = getResource(key); // I/O-bound, expensive operation map.put(key, resource); } With the above code, multiple threads may