blocks|key|969421|text|查看此页面：http://www.oracle.com/technetwork/articles/javase/index-140767.html|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|969422|它有一个略微不同的模式，这(我认为)是你正在寻找的：|969423|try+{
++mutex.acquire();
++try+{
++++//+do+something
++}+finally+{
++++mutex.release();
++}
}+catch(InterruptedException+ie)+{
++//+...
}|code-block|syntax|javascript|969424|在这种用法中，您只能在acquire()成功之后调用release()|style|CODE|969425|entityMap|0|LINK|mutability|MUTABLE|url|http://www.oracle.com/technetwork/articles/javase/index-140767.html^0|6|1V|0|0|0|0|B|9|Q|9|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|12|8|@$A|13|B|14|M|N]|$A|15|B|16|M|N]]|9|@]|C|$]]|$1|O|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

See this page: <a href="http://www.oracle.com/technetwork/articles/javase/index-140767.html" rel="noreferrer">http://www.oracle.com/technetwork/articles/javase/index-140767.html</a>

It has a slightly different pattern which is (I think) what you are looking for:

<pre><code>try {
 mutex.acquire();
 try {
 // do something
 } finally {
 mutex.release();
 }
} catch(InterruptedException ie) {
 // ...
}
</code></pre>

In this usage, you're only calling <code>release()</code> after a successful <code>acquire()</code>

blocks|key|753883|text|Java中的任何对象都可以使用synchronized块作为锁。当发生异常时，这也会自动释放锁。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|753884|Object+someObject+=+...;

synchronized+(someObject)+{
++...
}|code-block|syntax|javascript|753885|你可以在这里阅读更多信息：Intrinsic+Locks+and+Synchronization|753886|entityMap|0|LINK|mutability|MUTABLE|url|http://download.oracle.com/javase/tutorial/essential/concurrency/locksync.html^0|F|C|0|0|D|Z|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

Any object in Java can be used as a lock using a <code>synchronized</code> block. This will also automatically take care of releasing the lock when an exception occurs.

<pre><code>Object someObject = ...;

synchronized (someObject) {
 ...
}
</code></pre>

You can read more about this here: <a href="http://download.oracle.com/javase/tutorial/essential/concurrency/locksync.html" rel="noreferrer">Intrinsic Locks and Synchronization</a>

blocks|key|969508|text|为了确保Semaphore是二进制的，您只需要确保在创建信号量时将许可的数量作为1传递。Javadocs有更多解释。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|969509|entityMap|0|LINK|mutability|MUTABLE|url|http://download.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/Semaphore.html^0|4|9|18|8|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

To ensure that a <code>Semaphore</code> is binary you just need to make sure you pass in the number of permits as 1 when creating the semaphore. The <a href="http://download.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/Semaphore.html" rel="nofollow">Javadocs</a> have a bit more explanation.

blocks|key|969583|text|每个对象的锁与互斥锁/信号量设计略有不同。例如，没有办法通过释放前一个节点的锁并捕获下一个节点来正确地实现遍历链接节点。但是使用互斥锁很容易实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|969584|Node+p+=+getHead();
if+(p+==+null+%7C%7C+x+==+null)+return+false;
p.lock.acquire();++//+Prime+loop+by+acquiring+first+lock.
//+If+above+acquire+fails+due+to+interrupt,+the+method+will
//+++throw+InterruptedException+now,+so+there+is+no+need+for
//+++further+cleanup.
for+(;;)+{
Node+nextp+=+null;
boolean+found;
try+{+
+found+=+x.equals(p.item);+
+if+(!found)+{+
+++nextp+=+p.next;+
+++if+(nextp+!=+null)+{+
+++++try+{++++++//+Acquire+next+lock+
++++++++++++++++//+++while+still+holding+current+
+++++++nextp.lock.acquire();+
+++++}+
+++++catch+(InterruptedException+ie)+{+
++++++throw+ie;++++//+Note+that+finally+clause+will+
+++++++++++++++++++//+++execute+before+the+throw+
+++++}+
+++}+
+}+
}finally+{+++++//+release+old+lock+regardless+of+outcome+
+++p.lock.release();
}+|code-block|syntax|javascript|969585|目前，在java.util.concurrent中还没有这样的类，但是您可以在Mutex.java中找到Mutext的实现。至于标准库，Semaphore提供了所有这些功能以及更多功能。|offset|length|style|CODE|969586|entityMap|0|LINK|mutability|MUTABLE|url|http://www.docjar.org/html/api/EDU/oswego/cs/dl/util/concurrent/Mutex.java.html^0|0|0|4|K|13|A|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]]|9|@$I|Z|J|10|1|11]]|A|$]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

Each object's lock is little different from Mutex/Semaphore design.
For example there is no way to correctly implement traversing linked nodes with releasing previous node's lock and capturing next one. But with mutex it is easy to implement:

<pre><code>Node p = getHead();
if (p == null || x == null) return false;
p.lock.acquire(); // Prime loop by acquiring first lock.
// If above acquire fails due to interrupt, the method will
// throw InterruptedException now, so there is no need for
// further cleanup.
for (;;) {
Node nextp = null;
boolean found;
try { 
 found = x.equals(p.item); 
 if (!found) { 
 nextp = p.next; 
 if (nextp != null) { 
 try { // Acquire next lock 
 // while still holding current 
 nextp.lock.acquire(); 
 } 
 catch (InterruptedException ie) { 
 throw ie; // Note that finally clause will 
 // execute before the throw 
 } 
 } 
 } 
}finally { // release old lock regardless of outcome 
 p.lock.release();
} 
</code></pre>

Currently, there is no such class in <code>java.util.concurrent</code>, but you can find Mutext implementation here <a href="http://www.docjar.org/html/api/EDU/oswego/cs/dl/util/concurrent/Mutex.java.html" rel="nofollow">Mutex.java</a>. As for standard libraries, Semaphore provides all this functionality and much more.

blocks|key|969615|text|import+java.util.concurrent.locks.Lock;
import+java.util.concurrent.locks.ReentrantLock;


private+final+Lock+_mutex+=+new+ReentrantLock(true);

_mutex.lock();

//+your+protected+code+here

_mutex.unlock();|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|969616|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


private final Lock _mutex = new ReentrantLock(true);

_mutex.lock();

// your protected code here

_mutex.unlock();
</code></pre>

blocks|key|754056|text|原始post中的错误是try循环内设置的acquire()调用。下面是使用“二进制”信号量(Mutex)的正确方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|754057|semaphore.acquire();
try+{
+++//do+stuff
}+catch+(Exception+e)+{
+++//exception+stuff
}+finally+{
+++semaphore.release();
}|code-block|syntax|javascript|754058|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|$]]

Mistake in original post is acquire() call set inside the try loop. 
Here is a correct approach to use "binary" semaphore (Mutex):

<pre><code>semaphore.acquire();
try {
 //do stuff
} catch (Exception e) {
 //exception stuff
} finally {
 semaphore.release();
}
</code></pre>

blocks|key|754089|text|我认为你应该尝试一下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|754090|当信号量初始化时：|754091|Semaphore+semaphore+=+new+Semaphore(1,+true);|code-block|syntax|javascript|754092|在你的Runnable+Implementation中|offset|length|style|CODE|754093|try+
{
+++semaphore.acquire(1);
+++//+do+stuff

}+
catch+(Exception+e)+
{
//+Logging
}
finally
{
+++semaphore.release(1);
}|754094|entityMap^0|0|0|0|3|N|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I think you should try with :

While Semaphore initialization :

<pre><code>Semaphore semaphore = new Semaphore(1, true);
</code></pre>

And in your <code>Runnable Implementation</code>

<pre><code>try 
{
 semaphore.acquire(1);
 // do stuff

} 
catch (Exception e) 
{
// Logging
}
finally
{
 semaphore.release(1);
}
</code></pre>

Is there a Mutex object in java or a way to create one?
I am asking because a Semaphore object initialized with 1 permit does not help me.
Think of this case:

<pre><code>try {
 semaphore.acquire();
 //do stuff
 semaphore.release();
} catch (Exception e) {
 semaphore.release();
}
</code></pre>

if an exception happens at the first acquire, the release in the catch block will increase the permits, and the semaphore is no longer a binary semaphore.

Will the correct way be? 

<pre><code>try {
 semaphore.acquire();
 //do stuff
} catch (Exception e) {
 //exception stuff
} finally {
 semaphore.release();
}
</code></pre>

Will the above code ensure that the semaphore will be binary?

Is there a Mutex in Java?

Java

java中有没有Mutex对象或者创建一个对象的方法？我之所以问这个问题，是因为用1许可初始化的信号量对象对我没有帮助。想一想这个例子：try {   semaphore.acquire();   //do stuff   semaphore.release();} catch (Exception e) {   se...

问Java中有互斥锁吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中有互斥锁吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中有互斥锁吗？
EN