实战Concurrent(4)

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

 

4、AtomicInteger

对变量的读写操作都是原子操作（除了long或者double的变量），但像数值类型的++ --操作不是原子操作，像i++中包含了获得i的原始值、加1、写回i、返回原始值，在进行类似i++这样的操作时如果不进行同步问题就大了。好在java.util.concurrent.atomic为我们提供了很多工具类，可以以原子方式更新变量。

 

以AtomicInteger为例，提供了代替++ --的getAndIncrement()、incrementAndGet()、getAndDecrement()和decrementAndGet()方法，还有加减给定值的方法、当前值等于预期值时更新的compareAndSet()方法。

 

下面的例子中用AtomicInteger保存全局验证次数(第69行做了自增的操作)，因为validateNode()方法会同时被多个线程调用，所以直接用int不同步是不行的，但用AtomicInteger在这种场合下就很合适。

package
 service.mock;

import
 java.util.ArrayList;
import
 java.util.HashMap;
import
 java.util.List;
import
 java.util.Map;
import
 java.util.concurrent.atomic.AtomicInteger;
import
 java.util.logging.Logger;

import
 service.Node;

/**
 * 模拟执行节点验证的Mock类
 *
 * @author DigitalSonic
 */
public
 
class
 MockNodeValidator {
    public
 
static
 
final
 List<Node>         ENTRIES  = 
new
 ArrayList<Node>();
    private
 
static
 
final
 Map<String, Node> NODE_MAP = 
new
 HashMap<String, Node>();

    private
 
static
 AtomicInteger           count    = 
new
 AtomicInteger(
0
);
    private
 
static
 Logger                  logger   = Logger.getLogger(
"MockNodeValidator"
);

    /*
     * 构造模拟数据
     */
    static
 {
        Node node0 = new
 Node(
"NODE0"
, 
"http://node0/check?wsdl"
); //入口
0
        Node node1 = new
 Node(
"NODE1"
, 
"http://node1/check?wsdl"
);
        Node node2 = new
 Node(
"NODE2"
, 
"http://node2/check?wsdl"
);
        Node node3 = new
 Node(
"NODE3"
, 
"http://node3/check?wsdl"
);
        Node node4 = new
 Node(
"NODE4"
, 
"http://node4/check?wsdl"
);
        Node node5 = new
 Node(
"NODE5"
, 
"http://node5/check?wsdl"
);
        Node node6 = new
 Node(
"NODE6"
, 
"http://node6/check?wsdl"
); //入口
1
        Node node7 = new
 Node(
"NODE7"
, 
"http://node7/check?wsdl"
);
        Node node8 = new
 Node(
"NODE8"
, 
"http://node8/check?wsdl"
);
        Node node9 = new
 Node(
"NODE9"
, 
"http://node9/check?wsdl"
);

        node0.setDependencies(new
 String[] { node1.getWsdl(), node2.getWsdl() });
        node1.setDependencies(new
 String[] { node3.getWsdl(), node4.getWsdl() });
        node2.setDependencies(new
 String[] { node5.getWsdl() });
        node6.setDependencies(new
 String[] { node7.getWsdl(), node8.getWsdl() });
        node7.setDependencies(new
 String[] { node5.getWsdl(), node9.getWsdl() });
        node8.setDependencies(new
 String[] { node3.getWsdl(), node4.getWsdl() });

        node2.setResult("FAILED"
);

        NODE_MAP.put(node0.getWsdl(), node0);
        NODE_MAP.put(node1.getWsdl(), node1);
        NODE_MAP.put(node2.getWsdl(), node2);
        NODE_MAP.put(node3.getWsdl(), node3);
        NODE_MAP.put(node4.getWsdl(), node4);
        NODE_MAP.put(node5.getWsdl(), node5);
        NODE_MAP.put(node6.getWsdl(), node6);
        NODE_MAP.put(node7.getWsdl(), node7);
        NODE_MAP.put(node8.getWsdl(), node8);
        NODE_MAP.put(node9.getWsdl(), node9);

        ENTRIES.add(node0);
        ENTRIES.add(node6);
    }

    /**
     * 模拟执行远程验证返回节点，每次调用等待500ms
     */
    public
 
static
 Node validateNode(String wsdl) {
        Node node = cloneNode(NODE_MAP.get(wsdl));
        logger.info("验证节点"
 + node.getName() + 
"["
 + node.getWsdl() + 
"]"
);
        count.getAndIncrement();
        try
 {
            Thread.sleep(500
);
        } catch
 (InterruptedException e) {
            e.printStackTrace();
        }
        return
 node;
    }

    /**
     * 获得计数器的值
     */
    public
 
static
 
int
 getCount() {
        return
 count.intValue();
    }

    /**
     * 克隆一个新的Node对象（未执行深度克隆）
     */
    public
 
static
 Node cloneNode(Node originalNode) {
        Node newNode = new
 Node();

        newNode.setName(originalNode.getName());
        newNode.setWsdl(originalNode.getWsdl());
        newNode.setResult(originalNode.getResult());
        newNode.setDependencies(originalNode.getDependencies());

        return
 newNode;
    }
}

 

上述代码还有另一个功能，就是构造测试用的节点数据，一共10个节点，有2个入口点，通过这两个点能够遍历整个系统。每次调用会模拟远程访问，等待500ms。环境间节点依赖如下：

环境依赖

Node0 [Node1, Node2]
Node1 [Node3, Node4]
Node2 [Node5]
Node6 [Node7, Node8]
Node7 [Node5, Node9]
Node8 [Node3, Node4]