实战Concurrent(2)

来自http://www.iteye.com/topic/363625

 

2、Lock

多线程编程中常常要锁定某个对象，之前会用synchronized来实现，现在又多了另一种选择，那就是java.util.concurrent.locks。通过Lock能够实现更灵活的锁定机制，它还提供了很多synchronized所没有的功能，例如尝试获得锁(tryLock())。

 

使用Lock时需要自己获得锁并在使用后手动释放，这一点与synchronized有所不同，所以通常Lock的使用方式是这样的：

Lock l = ...;
l.lock();
try
 {
    // 执行操作
} finally
 {
    l.unlock();
}

 

java.util.concurrent.locks中提供了几个Lock接口的实现类，比较常用的应该是ReentrantLock。以下范例中使用了ReentrantLock进行节点锁定：

package
 service;

import
 java.util.concurrent.locks.Lock;
import
 java.util.concurrent.locks.ReentrantLock;

/**
 * 节点类
 *
 * @author DigitalSonic
 */
public
 
class
 Node {
    private
 String name;
    private
 String wsdl;
    private
 String result = 
"PASS"
;
    private
 String[] dependencies = 
new
 String[] {};
    private
 Lock lock = 
new
 ReentrantLock();
    /**
     * 默认构造方法
     */
    public
 Node() {
    }

    /**
     * 构造节点对象，设置名称及WSDL
     */
    public
 Node(String name, String wsdl) {
        this
.name = name;
        this
.wsdl = wsdl;
    }

    /**
     * 返回包含节点名称、WSDL以及验证结果的字符串
     */
    @Override
    public
 String toString() {
        String toString = "Node: "
 + name + 
" WSDL: "
 + wsdl + 
" Result: "
 + result;
        return
 toString;
    }

    // Getter & Setter
    ...

}

package
 service;

import
 java.util.concurrent.Callable;
import
 java.util.concurrent.locks.Lock;
import
 java.util.logging.Logger;

import
 service.mock.MockNodeValidator;

/**
 * 执行验证的任务类
 *
 * @author DigitalSonic
 */
public
 
class
 ValidationTask 
implements
 Callable<Node> {
    private
 
static
 Logger logger = Logger.getLogger(
"ValidationTask"
);

    private
 String        wsdl;

    /**
     * 构造方法，传入节点的WSDL
     */
    public
 ValidationTask(String wsdl) {
        this
.wsdl = wsdl;
    }

    /**
     * 执行针对某个节点的验证<br/>
     * 如果正有别的线程在执行同一节点的验证则等待其结果，不重复执行验证
     */
    @Override
    public
 Node call() 
throws
 Exception {
        Node node = ValidationService.NODE_MAP.get(wsdl);
        Lock lock = null
;
        logger.info("开始验证节点："
 + wsdl);
        if
 (node != 
null
) {
            lock = node.getLock();
            if
 (lock.tryLock()) {
                // 当前没有其他线程验证该节点
                logger.info("当前没有其他线程验证节点"
 + node.getName() + 
"["
 + wsdl + 
"]"
);
                try
 {
                    Node result = MockNodeValidator.validateNode(wsdl);
                    mergeNode(result, node);
                } finally
 {
                    lock.unlock();
                }
            } else
 {
                // 当前有别的线程正在验证该节点，等待结果
                logger.info("当前有别的线程正在验证节点"
 + node.getName() + 
"["
 + wsdl + 
"]，等待结果"
);
                lock.lock();
                lock.unlock();
            }
        } else
 {
            // 从未进行过验证，这种情况应该只出现在系统启动初期
            // 这时是在做初始化，不应该有冲突发生
            logger.info("首次验证节点："
 + wsdl);
            node = MockNodeValidator.validateNode(wsdl);
            ValidationService.NODE_MAP.put(wsdl, node);
        }
        logger.info("节点"
 + node.getName() + 
"["
 + wsdl + 
"]验证结束，验证结果："
 + node.getResult());
        return
 node;
    }

    /**
     * 将src的内容合并进dest节点中，不进行深度拷贝
     */
    private
 Node mergeNode(Node src, Node dest) {
        dest.setName(src.getName());
        dest.setWsdl(src.getWsdl());
        dest.setDependencies(src.getDependencies());
        dest.setResult(src.getResult());
        return
 dest;
    }
}

   

请注意ValidationTask的call()方法，这里会先检查节点是否被锁定，如果被锁定则表示当前有另一个线程正在验证该节点，那就不用重复进行验证。第50行和第51行，那到锁后立即释放，这里只是为了等待验证结束。

 

讲到Lock，就不能不讲Conditon，前者代替了synchronized，而后者则代替了Object对象上的wait()、notify()和notifyAll()方法(Condition中提供了await()、signal()和signalAll()方法)，当满足运行条件前挂起线程。Condition是与Lock结合使用的，通过Lock.newCondition()方法能够创建与Lock绑定的Condition实例。JDK的JavaDoc中有一个例子能够很好地说明Condition的用途及用法：

class
 BoundedBuffer {
  final
 Lock lock = 
new
 ReentrantLock();
  final
 Condition notFull  = lock.newCondition();
  final
 Condition notEmpty = lock.newCondition();

  final
 Object[] items = 
new
 Object[
100
];
  int
 putptr, takeptr, count;

  public
 
void
 put(Object x) 
throws
 InterruptedException {
    lock.lock();
    try
 {
      while
 (count == items.length)
        notFull.await();
      items[putptr] = x;
      if
 (++putptr == items.length) putptr = 
0
;
      ++count;
      notEmpty.signal();
    } finally
 {
      lock.unlock();
    }
  }

  public
 Object take() 
throws
 InterruptedException {
    lock.lock();
    try
 {
      while
 (count == 
0
)
        notEmpty.await();
      Object x = items[takeptr];
      if
 (++takeptr == items.length) takeptr = 
0
;
      --count;
      notFull.signal();
      return
 x;
    } finally
 {
      lock.unlock();
    }
  }
}

说到这里，让我解释一下之前的例子里为什么没有选择Condition来等待验证结束。await()方法在调用时当前线程先要获得对应的锁，既然我都拿到锁了，那也就是说验证已经结束了。。。