locking

I'm developing an application that asks for a PIN when you start it. That's not great, but I can live with it. The problem is I'm being asked to ask for the PIN each time the phone wakes from sleep, too. Combined with the OS asking for its passcode, it's too much. Is there any legitimate way to detect if the phone has a passcode required for waking, so I can skip requiring a PIN in this case? I don't want to know the PIN and I don't actually care if it was locked (for instance, if the phone was asleep very briefly), I just want to know that the data is in some way "protected." For AppStore or

How to properly synchronize this? At the moment it is possible that SetData is called after e.WaitOne() has completed so d could be already set to another value. I tried to insert locks but it resulted into a deadlock. AutoResetEvent e = new AutoResetEvent(false); public SetData(MyData d) { this.d=d; e.Set(); // notify that new data is available } // This runs in separate thread and waits for d to be set to a new value void Runner() { while (true) { e.WaitOne(); // waits for new data to process DoLongOperationWith_d(d); } } Will the best solution be to introduce a new boolean variable

So I've seen a lot of articles now claiming that on C++ double checked locking, commonly used to prevent multiple threads from trying to initialize a lazily created singleton, is broken. Normal double checked locking code reads like this: class singleton { private: singleton(); // private constructor so users must call instance() static boost::mutex _init_mutex; public: static singleton & instance() { static singleton* instance; if(!instance) { boost::mutex::scoped_lock lock(_init_mutex); if(!instance) instance = new singleton; } return *instance; } }; The problem apparently is the line

Suppose somewhere in my code I write an empty synchronized block: synchronized(obj){ //No code here } So as the synchronized block does not contain any code, will JIT compiler optimize that out by not locking on obj as it will be of no use? Java compiler does similar tricks such as Lock coarsening but will this synchronized block be also optimized out? EDIT: As per the point made by assylias, synchronized(new Object()){ //empty block } will the JIT compiler now be able to optimize this out, since I am using an Object which doesn't escape my method? This can't be optimized away on the basis of

I've noticed that if two users try to run CUDA programs at the same time, it tends to lock up either the card or the driver (or both?). We need to either reset the card or reboot the machine to restore normal behavior. Is there a way to get a lock on the GPU so other programs can't interfere while it's running? Edit OS is Ubuntu 11.10 running on a server. While there is no X Windows running, the card is used to display the text system console. There are multiple users. If you are running on either Linux or Windows with the TCC driver, you can put the GPU into compute exclusive mode using the

Here's the task: I need to lock based on a filename. There can be up to a million different filenames. (This is used for large-scale disk-based caching). I want low memory usage and low lookup times, which means I need a GC'd lock dictionary. (Only in-use locks can be present in the dict). The callback action can take minutes to complete, so a global lock is unacceptable. High throughput is critical. I've posted my current solution below, but I'm unhappy with the complexity. EDIT: Please do not post solutions that are not 100% correct. For example, a solution which permits a lock to be removed

lock uses this pattern if(Monitor.Enter(lock)) try { ... } finally { Monitor.Exit(lock); } // using this style to reduce post "height" if we don't want to wait infinite we can provide timeout if(!Monitor.TryEnter(lock, timeout)) throw new TimeoutException(); try { ... } finally { Monitor.Exit(lock); } I have scenario when method has to obtain multiple locks before it start doing anything. This looks awful: if(!Monitor.TryEnter(lockA, timeout)) throw new TimeoutException(); try { if(!Monitor.TryEnter(lockB, timeout)) throw new TimeoutException(); try { if(!Monitor.TryEnter(lockC, timeout))

The Django documentation states that: If you were relying on “automatic transactions” to provide locking between select_for_update() and a subsequent write operation — an extremely fragile design, but nonetheless possible — you must wrap the relevant code in atomic(). Is the reason why this no longer works is that autocommit is done at the database layer and not the application layer? Previously the transaction would be held open until a data-altering function is called : Django’s default behavior is to run with an open transaction which it commits automatically when any built-in, data