locking

I have simple service that running in the background and I just want to know when the user is on the lock screen or not, that way I know when to start a process. mopsled Check out a similar question asked here . Use KeyguardManager to check if the device is locked. KeyguardManager kgMgr = (KeyguardManager) getSystemService(Context.KEYGUARD_SERVICE); boolean showing = kgMgr.inKeyguardRestrictedInputMode(); 1) You need to firstly register a BroadcastReceiver in your Service to listen when power button is pressed (turns screen on/off): @Override public void onCreate() { super.onCreate();

The JVM performs a neat trick called lock elision to avoid the cost of locking on objects that are only visible to one thread. There's a good description of the trick here: http://www.ibm.com/developerworks/java/library/j-jtp10185/ Does the .Net CLR do something similar? If not then why not? It's neat, but is it useful? I have a hard time coming up with an example where the compiler can prove that a lock is thread local. Almost all classes don't use locking by default, and when you choose one that locks, then in most cases it will be referenced from some kind of static variable foiling the

Daily we run mysql dumps on about 50 individual databases, package them up and then store them offsite. Some of these databases are rather large and contain myisam tables (which CANNOT be changed so suggesting it is pointless).. I have been reading up on using the skip-lock-tables option when doing a dump but have not read what the downside would be. All I see are basically different iterations of "it could have adverse effects if data is inserted to a table while it is dumping." What are these adverse effects? Does it just mean we will miss those queries upon a restore or will it mean the

I am trying to create a lock-free queue implementation in Java, mainly for personal learning. The queue should be a general one, allowing any number of readers and/or writers concurrently. Would you please review it, and suggest any improvements/issues you find? Thank you. import java.util.concurrent.atomic.AtomicReference; public class LockFreeQueue<T> { private static class Node<E> { E value; volatile Node<E> next; Node(E value) { this.value = value; } } private AtomicReference<Node<T>> head, tail; public LockFreeQueue() { // have both head and tail point to a dummy node Node<T> dummyNode =

should I lock event in the following case: event foo; thread A: will call foo += handler; thread B: will call foo -= handler; should I lock foo? Locking on foo is a bad idea, because the value will change each time. You should lock on a variable which doesn't change: private readonly object eventLock = new object(); private EventHandler fooHandler; public event EventHandler Foo { add { lock (eventLock) { fooHandler += value; } } remove { lock (eventLock) { fooHandler -= value; } } } private void OnFoo(EventArgs e) { EventHandler handler; lock (eventLock) { handler = fooHandler; } if (handler !

Let's say we execute... SELECT * FROM MY_TABLE FOR UPDATE ...and there is more than one row in MY_TABLE. Theoretically, if two concurrent transactions execute this statement, but it happens to traverse (and therefore lock) the rows in different order, a deadlock may occur. For example: Transaction 1: Locks row A. Transaction 2: Locks row B. Transaction 1: Attempts to lock row B and blocks. Transaction 2: Attempts to lock row A and deadlocks. The way to resolve this is to use ORDER BY to ensure rows are always locked in the same order. So, my question is: will this theoretical deadlock ever