synchronization

Lets asume I have a code like the following: var shared = 100; function workWithIt(){ shared += 100; } setTimeout(workWithIt, 500); setTimeout(workWithIt, 500); Ideally, this piece of code should add 200 to the variable shared , which is 300 afterwards. But, as I know from c , there can be some implications, if the operation += is split into multiple commands. Lets say, that this is the execution-order of the function: setTimeout() --> create Thread A setTimeout() --> create Thread B wait 500ms **Thread A** | **Thread B** --------------------------------+--------------------------------- var

I've got a web application where people ask for resources. This resources are cached using a synchronized hash map for efficiency. The problem here is when two different requests come for the same uncached resource at the same time: the operation retrieving the resources takes up a lot of memory, so I want to avoid calling it more than once for the same resource. Can somebody please tell me if there is any potential problem with the following snippet? Thanks in advance. private Map<String, Resource> resources = Collections.synchronizedMap(new HashMap<String, Resource>()); public void request

For my cross-platform application I have started to use Boost, but I can't understand how I can implement code to reproduce behavior of Win32's critical section or .Net's lock . I want to write a method Foo that can be called from different threads to control write operations to shared fields. Recursive calls within the same thread should be allowed (Foo() -> Foo()). In C# this implementation is very simple: object _synch = new object(); void Foo() { lock (_synch) // one thread can't be lock by him self, but another threads must wait untill { // do some works if (...) { Foo(); } } } Alexander

I have 2 processes (producer and consumer) sharing an int deque in shared memory, I have the producer process put 2 numbers in the deque and then it gets in a wait state losing its mutex lock. I then have the consumer process removing the numbers and printing them. It then does a notify on the condition which the producer is waiting on. The consumer then goes on its own wait on a second condition. After this case the producer does not wake up. I am using the same mutex between the processes. Please find all code below. Include file shared_memory.h: #ifndef SharedMemory_h #define SharedMemory_h

My sample code posted below shows two classes. One implements KeyListener and the other implements Runnable and is running in an infinite loop sleeping every 20 ms. When a key is pressed the keyChar, which is in the form of an int, is used as an index setting the index of a boolean array true or false, representing with the key was pressed or not. At the same time the process loop is searching the key array for its true or false values and setting the true ones false then printing out the char. My question is whether or not I need to use synchronization using a lock for accessing the charArray