我被要求执行 fine grained locking 在 hashlist . 我已经用synchronized做了这个，但是问题告诉我要用synchronized Lock 相反。
我在构造函数中创建了一个对象的哈希列表

private LinkedList<E> data[];;
    private Lock lock[];
    private Lock lockR = new ReentrantLock();

    // The constructors ensure that both the data and the dataLock are the same size
    @SuppressWarnings("unchecked")
    public ConcurrentHashList(int n){
        if(n > 1000) {
            data = (LinkedList<E>[])(new LinkedList[n/10]);
            lock = new Lock [n/10]; 
        }
        else {
            data = (LinkedList<E>[])(new LinkedList[100]);
            lock = new Lock [100]; ;
        }

        for(int j = 0; j < data.length;j++) {
            data[j] = new LinkedList<E>();
            lock[j] = new ReentrantLock();// Adding a lock to each bucket index
        }
    }

原始方法

public void add(E x){
         if(x != null){
             lock.lock();
             try{
                 int index = hashC(x);
                 if(!data[index].contains(x))
                     data[index].add(x);
             }finally{lock.unlock();}
          }
     }

使用同步获取对象哈希列表上的句柄以允许可变 Threads 同时处理可变索引。

public void add(E x){
    if(x != null){
        int index = hashC(x);
        synchronized (dataLock[index]) { // Getting handle before adding 
            if(!data[index].contains(x))
                data[index].add(x);
        }       
    }
}

我不知道如何使用 Lock 虽然我不能锁定数组中的单个元素，但只能锁定整个方法，这意味着它不是 coarse grained .
使用数组 ReentrantLock ```
public void add(E x){
if(x != null){
int index = hashC(x);
dataLock[index].lock();
try {
// Getting handle before adding
if(!data[index].contains(x))
data[index].add(x);
}finally {dataLock[index].unlock();}
}
}

散列函数

private int hashC(E x){
int k = x.hashCode();
int h = Math.abs(k % data.length);
return(h);
}