日期：2011-03-22 16:16:00 来源：本站整理

Java多线程同步筹划中操纵Metux[Java编程]

赞助商链接

分享到： QQ空间新浪微博腾讯微博人人网

　　本文“Java多线程同步筹划中操纵Metux[Java编程]”是由七道奇为您精心收集，来源于网络转载，文章版权归文章作者所有，本站不对其观点以及内容做任何评价，请读者自行判断，以下是其具体内容：

Mutex是互斥体,遍及地利用在多线程编程中.本文以广为流程的Doug Lea的concurrent工具包的Mutex实现为例,举行一点探究.在Doug Lea的concurrent工具包中,Mutex实现了Sync接口,该接口是concurrent工具包中全部锁（lock）、门（gate）和条件变量（condition）的大众接口,Sync的实现类主要有:Mutex、Semaphore及其子类、Latch、CountDown、ReentrantLock等.这也表现了面向抽象编程的思惟,使我们可以在不改变代码大概改变少量代码的情形下,挑选利用Sync的差别实现.下面是Sync接口的定义:

public interface Sync
{
　 public void acquire() throws InterruptedException;
　 //获得答应
　 public boolean attempt(long msecs) throws InterruptedException;
　 //尝试获得答应
　 public void release();
　 //释放答应
}

通过利用Sync可以替换Java synchronized关键字,并供应越发机动的同步掌握.当然,并非说　concurrent工具包是和Java synchronized独立的技术,其实concurrent工具包也是在synchronized的底子上搭建的,从下面对Mutex源码的解析便可以看到这一点.synchronized关键字仅在办法内大概代码块内有效,而利用Sync却可以超越办法乃至通过在对象之间传送,超越对象举行同步.这是Sync及concurrent工具包比直接利用synchronized愈加强盛的地方.

注意Sync中的acquire()和attempt()城市抛出InterruptedException,所以利用Sync及其子类时,调用这些办法一定要捕捉InterruptedException.而release()办法并不会抛出InterruptedException,这是因为在acquire()和attempt()办法中大概会调用wait（）等候别的线程释放锁.而release()在实现上举行了简化,直接释放锁,不管能否真的持有.所以,你可以对一个并没有acquire()的线程调用release()这也不会有什么问题.而由于release()不会抛出InterruptedException,所以我们可以在catch或finally子句中调用release()以保证得到的锁可以被精确释放.比方:

class X
{
　 Sync gate; // ...
　 public void m()
　 {
　　 try
　　 {
　　　 gate.acquire();
　　　 // block until condition holds
　　　 try
　　　 {
　　　　 // ... method body
　　　 }
　　　 finally { gate.release(); }
　　 }
　　 catch (InterruptedException ex) { // ... evasive action }
　 }
}

Mutex是一个非重入的互斥锁.Mutex遍及地用在需求超越办法的before/after范例的同步环境中.下面是Doug Lea的concurrent工具包中的Mutex的实现.

public class Mutex implements Sync
{
　 /** The lock status **/
　 protected boolean inuse_ = false;
　 public void acquire() throws InterruptedException
　 {
　　 if (Thread.interrupted()) throw new InterruptedException();//(1)
　　 synchronized(this)
　　 {
　　　 try
　　　 {
　　　　 while (inuse_) wait();
　　　　 inuse_ = true;
　　　 }
　　　 catch (InterruptedException ex)
　　　 {
　　　　 //(2)
　　　　 notify();
　　　　 throw ex;
　　　 }
　　 }
　 }
　 public synchronized void release()
　 {
　　 inuse_ = false;
　　 notify();
　 }
　 public boolean attempt(long msecs) throws InterruptedException
　 {
　　 if (Thread.interrupted()) throw new InterruptedException();
　　 synchronized(this)
　　 {
　　　 if (!inuse_)
　　　 {
　　　　 inuse_ = true;
　　　　 return true;
　　　 }
　　　 else if (msecs <= 0)
　　　　 return false;
　　　 else
　　　 {
　　　　 long waitTime = msecs;
　　　　 long start = System.currentTimeMillis();
　　　　 try
　　　　 {
　　　　　 for (;;)
　　　　　 {
　　　　　　 wait(waitTime);
　　　　　　 if (!inuse_)
　　　　　　 {
　　　　　　　 inuse_ = true;
　　　　　　　 return true;
　　　　　　 }
　　　　　　 else
　　　　　　 {
　　　　　　　 waitTime = msecs - (System.currentTimeMillis() - start);
　　　　　　　 if (waitTime <= 0) // (3)
　　　　　　　　 return false;
　　　　　　 }
　　　　　 }
　　　　 }
　　　　 catch (InterruptedException ex)
　　　　 {
　　　　　 notify();
　　　　　 throw ex;
　　　　 }
　　　 }
　　 }
　 }
}