blocks|key|1184772|text|虽然Lock的答案非常好，但我想我应该发布一个使用不同数据结构的替代方案。本质上，你的各种线程想要知道哪些记录被锁定，哪些没有被锁定。一种方法是跟踪被锁定的记录，并确保数据结构具有正确的原子操作来将记录添加到锁定的集合中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1184773|我将使用CopyOnWriteArrayList作为示例，因为它不那么“神奇”。CopyOnWriteArraySet是一种更合适的结构。平均而言，如果您同时锁定了大量记录，那么这些实现可能会影响性能。一个正确同步的HashSet也可以工作，锁也很短。|1184774|基本上，用法代码将如下所示：|1184775|CopyOnWriteArrayList<Record>+lockedRecords+=+....
...
if+(!lockedRecords.addIfAbsent(record))
++++return;+//+didn't+get+the+lock,+record+is+already+locked

try+{
++++//+Do+the+record+stuff
}++++++++
finally+{
++++lockedRecords.remove(record);
}|code-block|syntax|javascript|1184776|它使您不必管理每个记录的锁，并提供了一个单独的位置，以防出于某种原因需要清除所有锁。另一方面，如果你有很多条记录，那么真正的同步HashSet可能会做得更好，因为添加/删除查找将是O(1)而不是线性的。|1184777|只是一种不同的看待事物的方式。这取决于你的实际线程需求是什么。就我个人而言，我会使用Collections.synchronizedSet(新的HashSet()+)，因为它会非常快……唯一的含义是线程可能会让步，否则它们就不会让步。|1184778|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

While the Lock answers are very good, I thought I'd post an alternative using a different data structure. Essentially, your various threads want to know which records are locked and which aren't. One way to do this is to keep track of the locked records and make sure that data structure has the right atomic operations for adding records to the locked set.

I will use CopyOnWriteArrayList as an example because it's less "magic" for illustration. CopyOnWriteArraySet is a more appropriate structure. If you have lots and lots of records locked at the same time on average then there may be performance implications with these implementations. A properly synchronized HashSet would work too and locks are brief.

Basically, usage code would look like this:

<pre><code>CopyOnWriteArrayList&lt;Record&gt; lockedRecords = ....
...
if (!lockedRecords.addIfAbsent(record))
 return; // didn't get the lock, record is already locked

try {
 // Do the record stuff
} 
finally {
 lockedRecords.remove(record);
}
</code></pre>

It keeps you from having to manage a lock per record and provides a single place should clearing all locks be necessary for some reason. On the other hand, if you ever have more than a handful of records then a real HashSet with synchronization may do better since the add/remove look-ups will be O(1) instead of linear.

Just a different way of looking at things. Just depends on what your actual threading requirements are. Personally, I would use a Collections.synchronizedSet( new HashSet() ) because it will be really fast... the only implication is that threads may yield when they otherwise wouldn't have.

blocks|key|1184866|text|虽然上面使用Lock对象的方法是最好的方法，但如果您必须能够使用监视器检查锁定，也可以这样做。但是，它确实带来了健康警告，因为该技术不能移植到非Oracle+Java+VM，并且它可能会在未来的VM版本中中断，因为它不是一个受支持的公共API。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1184867|下面是如何做的：|1184868|private+static+sun.misc.Unsafe+getUnsafe()+{
++++try+{
++++++++Field+field+=+sun.misc.Unsafe.class.getDeclaredField("theUnsafe");
++++++++field.setAccessible(true);
++++++++return+(Unsafe)+field.get(null);
++++}+catch+(Exception+e)+{
++++++++throw+new+RuntimeException(e);
++++}
}

public+void+doSomething()+{
++Object+record+=+new+Object();
++sun.misc.Unsafe+unsafe+=+getUnsafe();+
++if+(unsafe.tryMonitorEnter(record))+{
++++try+{
++++++//+record+is+locked+-+perform+operations+on+it
++++}+finally+{
++++++unsafe.monitorExit(record);
++++}
++}+else+{
++++++//+could+not+lock+record
++}
}|code-block|syntax|javascript|1184869|我的建议是，只有在不能重构代码以使用Oracle对象的情况下，并且运行在java.util.concurrent+VM上时，才使用这种方法。|1184870|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Whilst the above approach using a Lock object is the best way to do it, if you have to be able to check for locking using a monitor, it can be done. However, it does come with a health warning as the technique isn't portable to non Oracle Java VMs and it may break in future VM versions as it isn't a supported public API.

Here is how to do it:

<pre><code>private static sun.misc.Unsafe getUnsafe() {
 try {
 Field field = sun.misc.Unsafe.class.getDeclaredField("theUnsafe");
 field.setAccessible(true);
 return (Unsafe) field.get(null);
 } catch (Exception e) {
 throw new RuntimeException(e);
 }
}

public void doSomething() {
 Object record = new Object();
 sun.misc.Unsafe unsafe = getUnsafe(); 
 if (unsafe.tryMonitorEnter(record)) {
 try {
 // record is locked - perform operations on it
 } finally {
 unsafe.monitorExit(record);
 }
 } else {
 // could not lock record
 }
}
</code></pre>

My advice would be to use this approach only if you cannot refactor your code to use java.util.concurrent Lock objects for this and if you are running on an Oracle VM.

blocks|key|1400452|text|另一个解决办法是(如果你没有机会得到这里给出的答案)是使用超时。也就是说，在1秒挂起后，低于1的将返回null：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1400453|ExecutorService+executor+=+Executors.newSingleThreadExecutor();
++++++++//create+a+callable+for+the+thread
++++++++Future<String>+futureTask+=+executor.submit(new+Callable<String>()+{
++++++++++++@Override
++++++++++++public+String+call()+throws+Exception+{
++++++++++++++++return+myObject.getSomething();
++++++++++++}
++++++++});

++++++++try+{
++++++++++++return+futureTask.get(1000,+TimeUnit.MILLISECONDS);
++++++++}+catch+(InterruptedException+%7C+ExecutionException+%7C+TimeoutException+e)+{
++++++++++++//object+is+already+locked+check+exception+type
++++++++++++return+null;
++++++++}|code-block|syntax|javascript|1400454|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another workaround is (in case of you didnt have chance with the answers given here )is using timeouts. i.e. below one will return null after 1 second hanging:

<pre><code>ExecutorService executor = Executors.newSingleThreadExecutor();
 //create a callable for the thread
 Future&lt;String&gt; futureTask = executor.submit(new Callable&lt;String&gt;() {
 @Override
 public String call() throws Exception {
 return myObject.getSomething();
 }
 });

 try {
 return futureTask.get(1000, TimeUnit.MILLISECONDS);
 } catch (InterruptedException | ExecutionException | TimeoutException e) {
 //object is already locked check exception type
 return null;
 }
</code></pre>

blocks|key|1400597|text|我也需要找到一个解决方案，所以我搜索了Java+Concurrency+API，发现了StampedLock。这个项目使用的是Java8。我使用的是一个大量线程的异步数据服务，它与一个本机库进行通信，并且包含长生命周期的配置对象，有时需要使用复杂的并发逻辑；值得庆幸的是，使用StampedLock类可以实现相对简单的并发逻辑。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1400598|StampedLock有一个名为tryOptimisticRead的方法，它不等待，它只是以长时间戳的形式返回状态，其中零(0)表示持有排它锁。然后我会延迟到一秒钟，但你可以只使用这个函数，而不需要任何延迟。|1400599|下面是我如何检测是否存在排它锁，这个范例在多个位置使用，并包括错误处理：|1400600|++++int+delayCount+=+0;

++++//Makes+sure+that+if+there+is+data+being+written+to+this+field+at
++++//+this+moment,+wait+until+the+operation+is+finished+writing+the
++++//+updated+data.
++++while+(data1StampedLock.tryOptimisticRead()+==+0)
++++{
++++++++try
++++++++{
++++++++++++delay(WRITE_LOCK_SHORT_DELAY);
++++++++++++delayCount+%2B=+1;
++++++++}
++++++++catch+(InterruptedException+e)
++++++++{
++++++++++++logError("Interrupted+while+waiting+for+the+write+lock+to+be
+++++++++++++++++++++++released!",+e);
++++++++++++Thread.currentThread().interrupt();

++++++++++++//There+may+be+an+issue+with+the+JVM+if+this+occurs,+treat
++++++++++++//+it+like+we+might+crash+and+try+to+release+the+write+lock.
++++++++++++data1StampedLock.tryUnlockWrite();
++++++++++++break;
++++++++}

++++++++if+(delayCount+*+WRITE_LOCK_SHORT_DELAY+>+TimeUnit.SECONDS.toMillis(1))
++++++++{
++++++++++++logWarningWithAlert("Something+is+holding+a+write+lock+on"+%2B
++++++++++++++++"+the+data+for+a+very,+very+long+time+(>1s).+This+may"+%2B
++++++++++++++++"+indicate+a+problem+that+could+cause+cascading"+%2B
++++++++++++++++"+problems+in+the+near+future."+%2B
++++++++++++++++"+Also,+the+value+for+the+data+that+is+about+to+be"+%2B
++++++++++++++++"+retrieved+could+potentially+be+invalid.");
++++++++++++break;
++++++++}
++++}

++++long+nonExclusiveLockStamp+=+data1StampedLock.readLock();
++++Data+data1NonVolatile+=+data1;
++++data1StampedLock.unlockRead(nonExclusiveLockStamp);
++++
++++return+data1NonVolatile;|code-block|syntax|javascript|1400601|StampedLock上的读锁定是非独占的，就像从线程安全映射或HashTable中读取一样，其中它是多读/单写的。|1400602|下面是我如何使用排它锁与实例数据正在写入的其他线程进行通信：|1400603|++++long+d1LockStamp+=+data1StampedLock.writeLock();
++++this.data1+=+data1;
++++data1StampedLock.unlockWrite(d1LockStamp);|1400604|因此，如果您只想检查某事物是否在任何给定时刻被锁定，则只需使用类似以下语句的简单语句即可获得状态：|1400605|++++boolean+data1IsLocked+=+data1StampedLock.tryOptimisticRead()+==+0;|1400606|然后检查该布尔值的值。|1400607|当然，这里有其他答案中提到的警告和Be+Dragons信息(即信息立即过期)，但如果您确实需要锁定某些东西并从另一个线程检查该锁定，在我看来，这是使用java.util.concurrency包而不需要外部依赖的最合理、最安全和最有效的方法。|1400608|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/StampedLock.html|1|https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/StampedLock.html#tryOptimisticRead--^0|17|B|0|0|G|H|1|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@$A|1B|B|1C|1|1D]]|C|$]]|$1|D|3|E|5|6|7|1E|8|@]|9|@$A|1F|B|1G|1|1H]]|C|$]]|$1|F|3|G|5|6|7|1I|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|1J|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1K|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|1L|8|@]|9|@]|C|$]]|$1|Q|3|R|5|J|7|1M|8|@]|9|@]|C|$K|L]]|$1|S|3|T|5|6|7|1N|8|@]|9|@]|C|$]]|$1|U|3|V|5|J|7|1O|8|@]|9|@]|C|$K|L]]|$1|W|3|X|5|6|7|1P|8|@]|9|@]|C|$]]|$1|Y|3|Z|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|10|3|-4|5|6|7|1R|8|@]|9|@]|C|$]]]|11|$12|$5|13|14|15|C|$16|17]]|18|$5|13|14|15|C|$16|19]]]]

I needed to also find a solution to this, so searched the Java Concurrency API and came across <a href="https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/StampedLock.html" rel="nofollow noreferrer">StampedLock</a>. The project is using Java 8.
I am working in a heavily-threaded asynchronous data service that communicates with a native library and contains long-living configuration objects, necessitating sometimes-complex concurrency logic; thankfully this turned out to be relatively simple with the StampedLock class.
StampedLock has a method called <a href="https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/StampedLock.html#tryOptimisticRead--" rel="nofollow noreferrer">tryOptimisticRead</a> which does not wait, it just returns the status in the form of a long-time time stamp, where zero (0) indicates an exclusive lock is held. I then do delay for up to a second but you could just use the function without any sort of delay.
Here's how I'm detecting whether or not there's an exclusive lock, this paradigm is used in multiple locations and includes error handling:
<pre><code> int delayCount = 0;

 //Makes sure that if there is data being written to this field at
 // this moment, wait until the operation is finished writing the
 // updated data.
 while (data1StampedLock.tryOptimisticRead() == 0)
 {
 try
 {
 delay(WRITE_LOCK_SHORT_DELAY);
 delayCount += 1;
 }
 catch (InterruptedException e)
 {
 logError(&quot;Interrupted while waiting for the write lock to be
 released!&quot;, e);
 Thread.currentThread().interrupt();

 //There may be an issue with the JVM if this occurs, treat
 // it like we might crash and try to release the write lock.
 data1StampedLock.tryUnlockWrite();
 break;
 }

 if (delayCount * WRITE_LOCK_SHORT_DELAY &gt; TimeUnit.SECONDS.toMillis(1))
 {
 logWarningWithAlert(&quot;Something is holding a write lock on&quot; +
 &quot; the data for a very, very long time (&gt;1s). This may&quot; +
 &quot; indicate a problem that could cause cascading&quot; +
 &quot; problems in the near future.&quot; +
 &quot; Also, the value for the data that is about to be&quot; +
 &quot; retrieved could potentially be invalid.&quot;);
 break;
 }
 }

 long nonExclusiveLockStamp = data1StampedLock.readLock();
 Data data1NonVolatile = data1;
 data1StampedLock.unlockRead(nonExclusiveLockStamp);
 
 return data1NonVolatile;
</code></pre>
The read locks on a StampedLock are non-exclusive and are like reading from a thread-safe Map or HashTable, where it is multi-read/single-write.
Here is how I am using the exclusive lock to communicate to other threads that the instance data is being written to:
<pre><code> long d1LockStamp = data1StampedLock.writeLock();
 this.data1 = data1;
 data1StampedLock.unlockWrite(d1LockStamp);
</code></pre>
So if you wanted to only check whether or not something is locked at any given moment, you need only something simple like the following statement to get the status:
<pre><code> boolean data1IsLocked = data1StampedLock.tryOptimisticRead() == 0;
</code></pre>
Then check the value of that boolean.
There are, of course, the caveats and Here Be Dragons information mentioned in other answers (namely that the information is immediately stale), but if you really need to lock something and check that lock from another thread, this seemed to me to be the most reasonable, safe, and effective way that uses the java.util.concurrency package with no external dependencies.

I have a process A that contains a table in memory with a set of records (recordA, recordB, etc...)

Now, this process can launch many threads that affect the records, and sometimes we can have 2 threads trying to access the same record - this situation must be denied. Specifically if a record is LOCKED by one thread I want the other thread to abort (I do not want to BLOCK or WAIT).

Currently I do something like this:

<pre><code>synchronized(record)
{
performOperation(record);
}
</code></pre>

But this is causing me problems ... because while Process1 is performing the operation, if Process2 comes in it blocks/waits on the synchronized statement and when Process1 is finished it performs the operation. Instead I want something like this:

<pre><code>if (record is locked)
 return;

synchronized(record)
{
performOperation(record);
}
</code></pre>

Any clues on how this can be accomplished?
Any help would be much appreciated.
Thanks,

How do determine if an object is locked (synchronized) so not to block in Java?

数据结构

Java

我有一个进程A，它在内存中包含一个表，其中包含一组记录(recordA、recordB等)。现在，这个过程可能会启动许多影响记录的线程，有时我们可能有两个线程试图访问相同的记录-这种情况必须被拒绝。具体地说，如果一条记录被一个线程锁定，我希望另一个线程中止(我不想阻塞或等待)。目前我在做这样的事情：synchroniz...

问如何确定一个对象是否被锁定(同步)，以便在Java中不被阻塞？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何确定一个对象是否被锁定(同步)，以便在Java中不被阻塞？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何确定一个对象是否被锁定(同步)，以便在Java中不被阻塞？
EN