3

考虑以下树：

树

我想要做的是模拟树波算法，这样如果一个节点从除一个直接连接的邻居之外的所有节点接收到一个令牌，它就会向那个沉默的邻居发送一个令牌（对于叶节点总是如此）。如果一个节点从沉默的邻居那里收到一个令牌，就会做出决定。节点总是 7，树结构相同，所以我总是知道每个节点的邻居（直接连接的节点）。

树算法伪代码：

树算法

我有以下对象：

public final class Node implements Runnable {

    private final int name;

    // Indicating token receiving from neighbours
    private Map<Node, Boolean> neigh = new 
            HashMap<Node, Boolean>();

    public Node(int name) {
        this.name = name;
    }

    public int getName() {
        return name;
    }

    public void addNeigh(Node node) {
        neigh.put(node, false);
    }

    private int flag() {
        Collection<Boolean> c = neigh.values();
        int count = 0;
        for (Boolean bool : c) {
            if (!bool) {
                count++;
            }
        }
        return count;
    }

    private Node getSilentNeigh() {
        for (Entry<Node, Boolean> entry : neigh.entrySet()) {
            if (false == entry.getValue()) {
                return entry.getKey();
            }
        }
        return null;
    }

    public void sendToken(Node from, String token) {

        Node n;
        if ((n = getSilentNeigh()) != null && flag() == 1) {
            if (from.equals(n)) {
                System.out.println(name + " decides!");
            }
        }

        neigh.put(from, true);
    }

    @Override
    public boolean equals(Object obj) {

        if (this == obj) {
            return true;
        }

        if (!(obj instanceof Node)) {
            return false;
        }

        final Node n = (Node) obj;
        return name == n.name;
    }

    @Override
    public int hashCode() {
        int hc = 17;
        return 37 * hc + name;
    }

    @Override
    public void run() {
        while(flag() > 1);

        Node n = getSilentNeigh();

        System.out.println(name + " sends token to " + n.getName());

        n.sendToken(this, "token");
    }

    @Override
    public String toString() {
        return "Node " + name;
    }
}

在 run() 方法内部有一个 while(condition) 实际上意味着.. 等待（从邻居接收令牌），当只有一个邻居节点没有收到令牌时，向他发送令牌。

这就是我创建节点以及相互关联的方式：

        // Number of nodes
        int numberOfNodes = 7;

        // Array of nodes
        Node[] nodes = new Node[numberOfNodes]; 

        for (int i = 0; i < nodes.length; i++) {
            // Creating node
            nodes[i] = new Node(i);
        }

        nodes[0].addNeigh(nodes[1]);
        nodes[0].addNeigh(nodes[2]);
        nodes[1].addNeigh(nodes[0]);
        nodes[1].addNeigh(nodes[3]);
        nodes[1].addNeigh(nodes[4]);
        nodes[2].addNeigh(nodes[0]);
        nodes[2].addNeigh(nodes[5]);
        nodes[2].addNeigh(nodes[6]);    
        nodes[3].addNeigh(nodes[1]);
        nodes[4].addNeigh(nodes[1]);
        nodes[5].addNeigh(nodes[2]);
        nodes[6].addNeigh(nodes[2]);

我所做的是随机选择要执行的节点顺序：

        // List holding random node numbers
        List numbers = new ArrayList<Integer>();

        int chosen = 0;
        while (chosen < numberOfNodes) {
            int processNum = randInt(0, (numberOfNodes - 1));
            if (!numbers.contains(Integer.valueOf(processNum))) {
                 numbers.add(new Integer(processNum));
                 chosen++;
            }
        }

因此，例如节点可以按任何顺序排列：

0, 5, 3, 4, 6, 2, 1
5, 3, 0, 2, 1, 6, 4
3, 1, 0, 2, 4, 6, 5

然后我启动线程：

for (Integer number : numbers) {
    Thread thread = new Thread(nodes[number]);
    thread.start();
}

有时我会得到预期的结果（2 必须决定）：

Nodes selected: 0, 4, 5, 2, 6, 3, 1
5 sends token to 2
4 sends token to 1
6 sends token to 2
3 sends token to 1
1 sends token to 0
0 sends token to 2
2 decides!
2 sends token to 0
0 decides!

但通常我得到一个错误，只有一个决定：

Nodes selected: 5, 3, 4, 6, 0, 2, 1
3 sends token to 1
5 sends token to 2
4 sends token to 1
6 sends token to 2
2 sends token to 0
0 sends token to 1
1 decides!
Exception in thread "Thread-6" java.lang.NullPointerException
    at uk.ac.ncl.csc8103.wave.Node.run(Node.java:86)
    at java.lang.Thread.run(Thread.java:745)

是的，这是一个作业，我真的很接近这些人..但我正面临这个问题。

4

2 回答 2

1 
Inside the run() method there is a while(condition) that actually means.. wait (receiving tokens from neighbours)

根据您的代码，这不是真的

  while(flag() > 1);

如果节点只有一个节点（ 4 /5 / 6 ） - 对于这些，flag() 将返回 1 并将终止 while 循环，然后将向前移动并发送请求，甚至在发起者开始发送消息之前

更新

如您所知，此代码有 4 个启动器 (3,4,5,6) 并且除了退出 while 循环..

拿着这个

选择的节点：5、3、4、6、0、2、1 3 向 1 发送令牌 5 向 2 发送令牌 4 向 1 发送令牌 6 向 2 发送令牌 2 向 0 发送令牌 0 向 1 发送令牌 1 决定！

这纯粹是一种竞争条件，如果先前启动的发起者 (5) 已经到达 / 向其他发起者 (3) 的邻居 (1) 发送消息怎么办。而 Initator(3) 尝试启动并获取 SlientNeigh 它会得到 Null ( no slient neigh) 。因此您在 n.sendToken 处得到空指针异常。

算法参考 ：您不需要 sycn（我们没有规定每个节点只能接收来自邻居的一条消息）。

从参考三个简单的属性

  – In each computation there is one initiator, which starts the algorithm by sending out exactly one message

–– A process, upon receipt of a message, either sends out one message or decides


–– The algorithm terminates in the initiator and when this happens, each process has sent a message at least once
于 2014-10-24T20:50:01.647 回答
1

好吧，您的run方法调用Node n = getSilentNeigh();此调用可能返回 null，并且您使用该n变量而不检查它是否为 null。

@Override
public void run() {
    while(flag() > 1);
    Node n = getSilentNeigh(); // this call can return null
    System.out.println(name + " sends token to " + n.getName()); // you are probably getting 
                                                                 // NullPointerException here
    n.sendToken(this, "token");
}
于 2014-10-24T18:59:07.687 回答