synchronization

If I have two processes accessing a given registry key (e.g. HKLM ), should I wrap the the logic in a mutex? The registry will make sure the actions are atomic, so you don't have to synchronize it yourself. However, if you have multiple processes / threads accessing the registry at the same time, it doesn't make any guarantees about which happens first. Only that you won't get garbled data. Edit: Further reading, see The inability to lock someone out of the registry is a feature, not a bug . As others have mentioned, individual operations are atomic. If you need to make a larger set of

I read somewhere that x86 processors have cache coherency and can sync the value of fields across multiple cores anyway on each write. Does that mean that we can code without using the 'volatile' keywoard in java if we plan on running only on x86 processors? Update: Ok assuming that we leave out the issue of instruction reordering, can we assume that the issue of an assignment to a non-volatile field not being visible across cores is not present on x86 processors? No -- the volatile keyword has more implications than just cache coherency; it also places restrictions on what the runtime can and

class MyService { public void a() { synchronized(somekey) { b(); } } @Transactional(propagation = Propagation.REQUIRES_NEW) public void b() { ...do DB works... } } My aim is 1 - get the key 2 - start transaction 3 - commit transaction 4 - release the key When i call a() method from outside, transaction doesn't work. Any suggestions ? Thanks. Unless you're using code weaving, this can't work. The default way Spring handles transactions is through AOP proxies . The call to a transactional method goes like this: caller --> ProxyClass.a() --> YourClass.a() If you call another method on the same

I was reading a bit of Mutex and semaphore. I have piece of code int func() { i++; return i; } i is declared somewhere outside as a global variable. If i create counting semaphore with count as 3 won't it have a race condition? does that mean i should be using a binary semaphore or a Mutex in this case ? Can somebody give me some practical senarios where Mutex, critical section and semaphores can be used. probably i read lot. At the end i am a bit confused now. Can somebody clear the thought. P.S: I have understood that primary diff between mutex and binary semaphore is the ownership. and

Class Future { private volatile boolean ready; private Object data; public Object get() { if(!ready) return null; return data; } public synchronized void setOnce(Object o) { if(ready) throw...; data = o; ready = true; } } It said "if a thread reads data, there is a happens-before edge from write to read of that guarantees visibility of data" I know from my learning: volatile ensures that every read/write will be in the memory instead of only in cache or registers; volatile ensures reorder: that is, in setOnce() method data = o can only be scheduled after if(ready) throw..., and before ready =