Question

我根据使用单独锁的数组实现并发循环队列在队列的头部和尾部。队列中的每个节点如下所示：

  private class Node<T> 
  {
        public T item;
        ReentrantLock lock = new ReentrantLock();
        Node(){}
        void lock() {lock.lock();}
        void unlock() {lock.unlock();}
  }

我无法在队列类的构造函数中创建队列。

public Queue(int capacity) {
    items = (Node[]) new Object[capacity];//This line gives the problem
    head = size = 0;
  }

我找到了解决方案here，但是这段代码：

@SuppressWarnings("unchecked")
    Node<T>[] slots = (Node<T>[]) new Node<?>[capacity];

给出以下编译器错误：

Cannot create a generic array of Queue<T>.Node<?>

我的问题是初始化通用对象数组的正确方法是什么？

Answer 1

我认为Node<T>应该是静态的。

private static class Node<T> 
{
    public T item;
    ReentrantLock lock = new ReentrantLock();

    void lock() {lock.lock();}
    void unlock() {lock.unlock();}
}

...

@SuppressWarnings("unchecked")
Node<T>[] slots = (Node<T>[]) new Node<?>[capacity];

通常我们有两种选择：

非静态课程

public class Queue2<T> {

    public Queue2(int capacity) {   

        Queue2<T>.Node2[] slots2 =  new Queue2.Node2[capacity];     
    }


    private class Node2 
    {
        private T item;
        ReentrantLock lock = new ReentrantLock();

        public Node2(Object object) {}
        void lock() {lock.lock();}
        void unlock() {lock.unlock();}
    }
}

静态课程

public class Queue<T>  {

    public Queue(int capacity) {

        Queue.Node<T>[] slots = (Node<T>[]) new Node<?>[capacity];
    }   

    private static class Node<T> 
    {
        public T item;
        ReentrantLock lock = new ReentrantLock();

        void lock() {lock.lock();}
        void unlock() {lock.unlock();}
    }
}

您将第一个示例中的节点类称为Queue2<T>.Node，而您将第二个示例中的节点类称为Queue.Node<T>。

在这里显示的两个替代方案中，第二个是优选的。嵌套类不是静态是通过包含对封闭实例的引用来实现的，因为它们通常可以访问该实例的组件。静态嵌套类通常更简单，更有效。

Answer 2

还有另外两种方法可以进行编译。

让Node成为公共课
将Node保留为私有的非静态类，并从实例化中删除通配符：

Node<T>[] slots = (Node<T>[]) new Node[capacity];

通用节点数组Java

2 个答案: