You’re doing it wrong. If you don’t have the lock on the object you can’t check if it is locked (and if you have the lock you will know in advance). You can “ask” “is locked?” and get a “not” as response, then on the next nanosecond another thread can take the lock and your … Read more
Django 1.4+ supports select_for_update, in earlier versions you may execute raw SQL queries e.g. select … for update which depending on underlying DB will lock the row from any updates, you can do whatever you want with that row until the end of transaction. e.g. from django.db import transaction @transaction.commit_manually() def add_points(request): user = User.objects.select_for_update().get(id=request.user.id) … Read more
What is the difference between lockf and fcntl: On many systems, the lockf() library routine is just a wrapper around fcntl(). That is to say lockf offers a subset of the functionality that fcntl does. Source But on some systems, fcntl and lockf locks are completely independent. Source Since it is implementation dependent, make sure … Read more
A trivial solution would be synchronized(player) { synchronized(field) { // code } } However, make sure that you always lock the resources in the same order to avoid deadlocks. Note that in practice, the bottleneck is the field, so a single lock on the field (or on a dedicated, common lock object, as @ripper234 rightly … Read more
You will get “waiting to lock” in the thread dump when using intrinsic locks and “parking to wait for” when using locks from java.util.concurrent. Consider the following example: import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class LockTest { final Lock lock = new ReentrantLock(true); synchronized void intrinsicLock() { Thread th = new Thread(new Runnable() { public void … Read more
It is never OK to read something possibly modified in a different thread without synchronization. What level of synchronization is needed depends on what you are actually reading. For primitive types, you should have a look at atomic reads, e.g. in the form of std::atomic<bool>. The reason synchronization is always needed is that the processors … Read more
If a synchronized method calls another non-synchronized method, is there a lock on the non-synchronized method The answer depends on the context. If you are in a synchronized method for an object, then calls by other threads to other methods of the same object instance that are also synchronized are locked. However calls by other … Read more
From the C# language reference here: In general, avoid locking on a public type, or instances beyond your code’s control. The common constructs lock (this), lock (typeof (MyType)), and lock (“myLock”) violate this guideline: lock (this) is a problem if the instance can be accessed publicly. lock (typeof (MyType)) is a problem if MyType is … Read more
I don’t think there is a fully crossplatform way. On unix, the fcntl module will do this for you. However on windows (which I assume you are by the paths), you’ll need to use the win32file module. Fortunately, there is a portable implementation (portalocker) using the platform appropriate method at the python cookbook. To use … Read more
ReaderWriterLockSlim is a thread-affine lock type, so it usually cannot be used with async and await. You should either use SemaphoreSlim with WaitAsync, or (if you really need a reader/writer lock), use my AsyncReaderWriterLock from AsyncEx or Stephen Toub’s AsyncReaderWriterLock.