abstract：package cn.study.concurrency.ch11;
/**
* 锁分段
* @author xiaof
*
*/
public class StripedMap {
//同步策略：就是对数组进行分段上锁，n个节点用
package cn.study.concurrency.ch11;
/**
* 锁分段
* @author xiaof
*
*/
public class StripedMap {
//同步策略：就是对数组进行分段上锁，n个节点用n%LOCKS锁保护
private static final int N_LOCKS = 16;
private final Node[] buckets;
private final Object[] locks;
private static class Node
{
private String name;
private Node next;
private String key;
private String value;
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
}
public StripedMap(int numBuckets)
{
buckets = new Node[numBuckets];
//创建对应hash的锁
locks = new Object[N_LOCKS];
for(int i = 0; i < N_LOCKS; ++ i)
{
locks[i] = new Object();
}
}
private final int hash(Object key)
{
//取绝对值
return Math.abs(key.hashCode() % buckets.length);
}
//get和clear
public Object get(Object key)
{
int hash = hash(key);
synchronized(locks[hash % N_LOCKS])
{
//分段上锁
for(Node m = buckets[hash]; m != null; m = m.next)
{
if(m.key.equals(key))
return m.value;
}
}
return null;
}
/**
* 清除所有的数据，但是没有要求说要同时获取全部的锁的话，可以进行这样的释放操作
*/
public void clear()
{
for(int i = 0; i < buckets.length; ++i)
{
synchronized(locks[i % N_LOCKS])
{
buckets[i] = null;
}
}
}
}
