Question

对于我正在研究的算法，我尝试开发一种黑名单机制，可以按特定方式将数组列入黑名单：如果“1,2,3”被列入黑名单，“1,2,3,4,5”也是被列入黑名单我对目前为止提出的解决方案感到非常满意。但是当我从多个线程访问黑名单时似乎存在一些严重的问题。方法“contains”（参见下面的代码）有时会返回true，即使数组未列入黑名单。如果我只使用一个线程，则不会发生此问题，因此很可能是并发问题我尝试添加一些同步，但它没有改变任何东西。我还尝试了一些使用java.util.concurrent类的稍微不同的实现。关于如何解决这个问题的任何想法？

public class Blacklist {

private static final int ARRAY_GROWTH = 10;

private final Node root = new Node();

private static class Node{

    private volatile Node[] childNodes = new Node[ARRAY_GROWTH];

    private volatile boolean blacklisted = false;

    public void blacklist(){
        this.blacklisted = true;
        this.childNodes = null;
    }
}

public void add(final int[] array){

    synchronized (root) {

        Node currentNode = this.root;

        for(final int edge : array){
            if(currentNode.blacklisted)
                return;

            else if(currentNode.childNodes.length <= edge) {
                currentNode.childNodes = Arrays.copyOf(currentNode.childNodes, edge + ARRAY_GROWTH);
            }

            if(currentNode.childNodes[edge] == null) {
                currentNode.childNodes[edge] = new Node();
            }

            currentNode = currentNode.childNodes[edge];
        }

        currentNode.blacklist();
    }


}

public boolean contains(final int[] array){

    synchronized (root) {

        Node currentNode = this.root;

        for(final int edge : array){
            if(currentNode.blacklisted)
                return true;

            else if(currentNode.childNodes.length <= edge || currentNode.childNodes[edge] == null)
                return false;

            currentNode = currentNode.childNodes[edge];
        }

        return currentNode.blacklisted;

    }

}

}

Answer 1

修改： 我通过一个测试套件运行你的代码，其中有10个线程添加并比较了数千个模式，但我发现你的实现没有任何问题。我相信你误解了你的数据。例如，在线程环境中，这有时会返回false：

// sometimes this can be false
blacklist.contains(pattern) == blacklist.contains(pattern);

另一个线程在第一次调用之后但在第二次调用之前更改了黑名单。这是正常行为，类本身无法阻止它。如果这不是您想要的行为，您可以从类外部同步它：

synchronized (blacklist) {
    // this will always be true
    blacklist.contains(pattern) == blacklist.contains(pattern);
}

原始回复：
您同步根节点，但这不会同步其任何子节点。要使您的类具有防弹性，您只需同步add(int[])和contains(int[])方法，然后不泄漏任何引用。这确保了一次只能有一个线程使用Blacklist对象。

我在尝试理解你的代码时摆弄了你的代码，所以你不妨拥有它：

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

public class Blacklist {
    private final Node root = new Node(Integer.MIN_VALUE, false);

    public synchronized void add(int[] array) {
        if (array == null) return;
        Node next, cur = root;

        for(int i = 0; i < array.length-1 && !cur.isLeaf(); i++) {
            next = cur.getChild(array[i]);

            if (next == null) { 
                next = new Node(array[i], false);
                cur.addChild(next);
            }

            cur = next;
        }

        if (!cur.isLeaf()) {
            next = cur.getChild(array[array.length-1]); 
            if (next == null || !next.isLeaf())
                cur.addChild(new Node(array[array.length-1], true));
        }
    }

    public synchronized boolean contains(int[] array) {
        if (array == null) return false;
        Node cur = root;

        for (int i = 0; i < array.length; i++) {
            cur = cur.getChild(array[i]);
            if (cur == null) return false;
            if (cur.isLeaf()) return true;
        }

        return false;
    }

    private static class Node {
        private final Map<Integer, Node> children; 
        private final int value;

        public Node(int _value, boolean leaf) { 
            children = (leaf?null:new HashMap<Integer, Node>());
            value = _value;
        }

        public void addChild(Node child) { children.put(child.value, child); }
        public Node getChild(int value) { return children.get(value); }
        public boolean isLeaf() { return (children == null); }

    }
}

Collections framework可以让事情变得更轻松。通过重新实现ArrayList，你不会给自己任何好处。

这里我使用HashMap，这样你就不必为这样的事情分配超过9000个引用：

blacklist.add(new int[] {1, 2000, 3000, 4000});

数组的并发问题（Java）

1 个答案: