2

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

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

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

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

给出以下编译器错误：

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

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

4

2 回答 2

4

我认为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>。

在此处显示的两个备选方案中，第二个更可取。非静态的嵌套类通过包含对封闭实例的引用来实现，因为它们通常可以访问该实例的组件。静态嵌套类通常既简单又高效。

于 2013-10-20T14:24:30.190 回答
0

还有另外两种编译方法。

  1. 开设Node公开课

  2. 保留Node为私有的非静态类，并从实例化中删除通配符：

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

于 2013-10-20T14:39:00.077 回答