Java资源网
首
页		 | JAVA基础 | 环境配置 | JDBC | 线程技术 | Socket编程 | JavaMail | JAVA与XML | 设计模式 | 技术新闻 | Java认证 | 程序人生 软件下载
| JSP&Servlet | Spring | Struts | Hibernate | JBuilder | Eclipse | WebService | EJB技术 | J2ME开发 | 应用服务器 | JXTA | Ajax
Articles search文章搜索
   关键字:
   类　别:
       
New download 最新下载
· [组件]HTML Parser 1.5
· [教程]WebSphere Studio应用教程
· [组件]JDom 1.0
· [工具]Junit3.8.1
· [教程]EJB编程及J2EE系统架构和设计
· [教程]EJB教程
· [教程]J2EE Tutorial中文版
· [教程]Java编程思想2(英文)
· [教程]java编程思想（完整版）
· [教程]Java网络编程
New articles 最新文章
· 设计移动 Web 服务
· 解析XML的时候完全忽略DTD
· 理解XML Schema XML Schema 初步
· 标签库的深入研究
· 提升JSP应用程序的七大绝招
· 如何使用JDOM对XML文件进行操作
· 处理XML字符串中特殊字符
· 利用Digester把XML转换成为Java对象
· 使用WebService 和RMI远程协作
· 使用Axis开发Web Service程序
Articles top 热门文章
· Eclipse基础－－plugin插件安装(6644)
· eclipse+tomcat+lomboz的安装配置说明(4774)
· Java程序员就业前景(4584)
· Windows下JAVA环境变量的设置祥解(3788)
· Tomcat下JSP、Servlet和JavaBean环境的配置(3716)
· 使用links方式安装Eclipse插件(3698)
· 一个老程序员的心理话(3533)
· linux下jdk的安装与配置(3459)
· 初学者入门：Structs中基本配置入门(3334)
· Eclipse 运行命令行参数大全(3084)
您的位置:首页>>线程技术>>关于多线程同步的初步教程－－Metux的设计及使用
关于多线程同步的初步教程－－Metux的设计及使用
2007-04-13   来源:www.javaresearch.org  作者:未知

    Mutex是互斥体，广泛地应用在多线程编程中。本文以广为流程的Doug Lea的concurrent工具包的Mutex实现为例，进行一点探讨。在Doug Lea的concurrent工具包中，Mutex实现了Sync接口，该接口是concurrent工具包中所有锁（lock）、门（gate）和条件变量（condition）的公共接口，Sync的实现类主要有：Mutex、Semaphore及其子类、Latch、CountDown、ReentrantLock等。这也体现了面向抽象编程的思想，使我们可以在不改变代码或者改变少量代码的情况下，选择使用Sync的不同实现。下面是Sync接口的定义：

  1. public interface Sync {
  2.   public void acquire() throws InterruptedException; //获取许可
  3.   public boolean attempt(long msecs) throws InterruptedException; //尝试获取许可
  4.   public void release(); //释放许可
  5. }

通过使用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()以保证获得的锁能够被正确释放。比如：

  1. class X {
  2.    Sync gate;
  3.    // ...
  5.    public void m() { 
  6.      try {
  7.        gate.acquire();  // block until condition holds
  8.        try {
  9.          // ... method body
  10.        }
  11.        finally {
  12.          gate.release();
  13.        }
  14.      }
  15.      catch (InterruptedException ex) {
  16.        // ... evasive action
  17.      }
  18.    }
  19. }



Mutex是一个非重入的互斥锁。Mutex广泛地用在需要跨越方法的before/after类型的同步环境中。下面是Doug Lea的concurrent工具包中的Mutex的实现。

  1. public class Mutex implements Sync  {
  3.   /** The lock status **/
  4.   protected boolean inuse_ = false;
  6.   public void acquire() throws InterruptedException {
  7.     if (Thread.interrupted()) throw new InterruptedException(); //(1)
  8.     synchronized(this) {
  9.       try {
  10.         while (inuse_) wait(); 
  11.         inuse_ = true;
  12.       }
  13.       catch (InterruptedException ex) { //(2)
  14.         notify();
  15.         throw ex;
  16.       }
  17.     }
  18.   }
  20.   public synchronized void release()  {
  21.     inuse_ = false;
  22.     notify(); 
  23.   }
  26.   public boolean attempt(long msecs) throws InterruptedException {
  27.     if (Thread.interrupted()) throw new InterruptedException();
  28.     synchronized(this) {
  29.       if (!inuse_) {
  30.         inuse_ = true;
  31.         return true;
  32.       }
  33.       else if (msecs <= 0)
  34.         return false;
  35.       else {
  36.         long waitTime = msecs;
  37.         long start = System.currentTimeMillis();
  38.         try {
  39.           for (;;) { 
  40.             wait(waitTime);
  41.             if (!inuse_) {
  42.               inuse_ = true;
  43.               return true;
  44.             }
  45.             else {
  46.               waitTime = msecs - (System.currentTimeMillis() - start);
  47.               if (waitTime <= 0) // (3)
  48.                 return false;
  49.             }
  50.           }
  51.         }
  52.         catch (InterruptedException ex) {
  53.           notify();
  54.           throw ex;
  55.         }
  56.       }
  57.     }  
  58.   }
  60. }


    为什么要在acquire()和attempt(0方法的开始都要检查当前线程的中断标志呢？这是为了在当前线程已经被打断时，可以立即返回，而不会仍然在锁标志上等待。调用一个线程的interrupt()方法根据当前线程所处的状态，可能产生两种不同的结果：当线程在运行过程中被打断，则设置当前线程的中断标志为true；如果当前线程阻塞于wait()、sleep()、join()，则当前线程的中断标志被清空，同时抛出InterruptedException。所以在上面代码的位置（2）也捕获了InterruptedException，然后再次抛出InterruptedException。
    release()方法简单地重置inuse_标志，并通知其它线程。
    attempt()方法是利用Java的Object.wait(long)进行计时的，由于Object.wait(long)不是一个精确的时钟，所以attempt(long)方法也是一个粗略的计时。注意代码中位置（3），在超时时返回。
    Mutex是Sync的一个基本实现，除了实现了Sync接口中的方法外，并没有添加新的方法。所以，Mutex的使用和Sync的完全一样。在concurrent包的API中Doug给出了一个精细锁定的List的实现示例，我们这儿也给出，作为对Mutex和Sync使用的一个例子：

  1. class Node { 
  2.    Object item; 
  3.    Node next; 
  4.    Mutex lock = new Mutex(); // 每一个节点都持有一个锁
  6.    Node(Object x, Node n) { item = x; next = n; }
  7.  }
  9.  class List {
  10.     protected Node head; // 指向列表的头
  12.     // 使用Java的synchronized保护head域
  13.     //  (我们当然可以使用Mutex，但是这儿似乎没有这样做的必要
  14.     protected synchronized Node getHead() { return head; }
  16.     boolean search(Object x) throws InterruptedException {
  17.       Node p = getHead();
  18.       if (p == null) return false;
  20.       //  (这儿可以更加紧凑，但是为了演示的清楚，各种情况都分别进行处理)
  22.       p.lock.acquire();                  // Prime loop by acquiring first lock.
  23.                                      //    (If the acquire fails due to
  24.                                      //    interrupt, the method will throw
  25.                                      //    InterruptedException now,
  26.                                      //    so there is no need for any
  27.                                      //    further cleanup.)
  28.       for (;;) {
  29.         if (x.equals(p.item)) {
  30.           p.lock.release();          // 释放当前节点的锁
  31.           return true;
  32.         }
  33.         else {
  34.           Node nextp = p.next;
  35.           if (nextp == null) {
  36.             p.lock.release();       // 释放最后持有的锁
  37.             return false;
  38.           }
  39.           else {
  40.             try {
  41.               nextp.lock.acquire(); // 在释放当前锁之前获取下一个节点的锁
  42.             }
  43.             catch (InterruptedException ex) {
  44.               p.lock.release();    // 如果获取失败，也释放当前的锁
  45.               throw ex;
  46.             }
  47.             p.lock.release();      // 释放上个节点的锁，现在已经持有新的锁了
  48.             p = nextp;
  49.           }
  50.         }
  51.       }
  52.     }
  54.     synchronized void add(Object x) { // 使用synchronized保护head域
  55.       head = new Node(x, head);
  56.     }
  58.     // ...  other similar traversal and update methods ...
  59.  }
　　--相关文章--
· 彻底明白Java的多线程-线程间的通信 (2007-04-13)
· 彻底明白Java的多线程-实现多线程及线程的同步 (2007-04-13)
· 对Swing线程的再思索nbsp;(下) (2007-04-13)
· 如何使用线程 (2007-04-13)
· 关于多线程同步的初步教程－－可重入锁的设计及使用 (2007-04-13)
· 关于多线程同步的初步教程－－使用synchronized (2007-04-13)

版权所有©2005-2006 JAVA资源网 渝ICP备05007591号 虚拟主机 | 关于我们 | 联系方式 | 广告业务 | 网站地图 | 友情链接