阵列并发问题（Java）

对于我正在研究的一个算法，我尝试开发一种黑名单机制，可以用一种特定的方式将数组列入黑名单：如果“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;

    }

}

公共类黑名单{
私有静态最终整数数组_增长=10；
私有最终节点根=新节点（）；
私有静态类节点{
私有易失性节点[]子节点=新节点[数组_增长]；
private volatile boolean blacklisted=false；
公开作废黑名单（）{
this.blacklisted=true；
this.childNodes=null；
}
}
公共void add（最终int[]数组）{
已同步（根）{
节点currentNode=this.root；
用于（最终整数边：数组）{
如果（currentNode.blacklisted）
返回；
else if（currentNode.childNodes.length编辑：
我在一个测试套件中运行了您的代码，其中有十个线程添加并比较了数千个模式，但我发现您的实现没有任何错误。我相信您误解了数据。例如，在线程化环境中，这有时会返回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[]）
方法，然后不泄漏任何引用。这确保一次只能有一个线程使用黑名单对象

我在试图理解您的代码的同时对其进行了修改，因此您不妨：

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); }

    }
}

我觉得还可以。同步应该可以防止并发调用add和contains时出现所有问题，因此我猜您的问题出在调用它们的代码上。顺便说一句，通过同步，您不需要在节点volatile中声明变量。我觉得也可以：）这些变量只是易变的，因为我认为这可能会有所帮助。但它们是否易变似乎没有什么区别。为什么黑名单方法是公共的？你确定没有其他线程调用它吗？@Istao，黑名单方法位于私有的内部类节点中，除非它们获得根节点的引用（它们没有根节点），否则没有人可以调用它@Istao，它是在一个私有的内部类中，因此没有人可以从外部调用它-至少如果上面是
黑名单
@Johannes的完整定义，是这样吗？“要使类防弹，只需同步add（int[]）和contains（int[]）方法，然后不要泄漏任何引用。”-他已经做了所有这些…从挑剔的角度来看，你在
黑名单
对象上的同步实际上比他在内部
根
对象上的同步更容易受到攻击，因为外部的任何人都看不到后者，所以只有这个
黑名单
实例可以锁定它。非常感谢，y我们的代码运行得很好。仍然不太清楚原因，但我明天会仔细看一看。
而且我知道集合框架。我只是想如果我使用一个简单的数组，它可能会稍微快一点：）
无论如何，再次感谢。HashMap版本的性能大致相同（~3%差异）对于较小的数字。您的版本需要更多的工作来编写，更难读取，负数崩溃，大数堆空间不足。：）结果证明您是对的。真正的问题是，一个线程将一个数组列入黑名单，而另一个线程仍假定它未列入黑名单。您的解决方案不会出现这种情况，因为它的行为和我的不完全一样。现在我知道这其实很明显。无论如何，再次感谢你的帮助。漫长的白天和愉快的夜晚；）愿你拥有双倍的数字。
blacklist.add(new int[] {1, 2000, 3000, 4000});