+

Author: vakinge

src/io/vakin/algorithm/ConsistencyHash.java

@@ -0,0 +1,105 @@
+/**
+ * 
+ */
+package io.vakin.algorithm;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Arrays;
+import java.util.List;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+/**
+ * @description <br>
+ * @author <a href="mailto:[email protected]">vakin</a>
+ * @date 2016年8月22日
+ */
+public class ConsistencyHash {
+	private TreeMap<Long, String> virtualNodes = new TreeMap<Long, String>();
+
+	// 设置虚拟节点数目
+	private static final int VIRTUAL_NUM = 32;
+	
+	
+
+	public ConsistencyHash(List<String> actualNodes) {
+		refresh(actualNodes);
+	}
+
+	public void refresh(List<String> actualNodes){
+		virtualNodes.clear();
+		for (int i = 0; i < actualNodes.size(); i++) {
+			String shardInfo = actualNodes.get(i);
+			for (int j = 0; j < VIRTUAL_NUM; j++) {
+				virtualNodes.put(hash(i + "-" + j), shardInfo);
+			}
+		}
+	}
+	
+	/**
+	 * 根据hash因子获取分配的真实节点
+	 * 
+	 * @param factor
+	 * @return
+	 */
+	public String getActualNode(Object factor) {
+		Long key = hash(factor.toString());
+		SortedMap<Long, String> tailMap = virtualNodes.tailMap(key);
+		if (tailMap.isEmpty()) {
+			key = virtualNodes.firstKey();
+		} else {
+			key = tailMap.firstKey();
+		}
+		return virtualNodes.get(key);
+	}
+
+	private static Long hash(String key) {
+        if(key == null)return 0L;
+		ByteBuffer buf = ByteBuffer.wrap(key.getBytes());
+		int seed = 0x1234ABCD;
+
+		ByteOrder byteOrder = buf.order();
+		buf.order(ByteOrder.LITTLE_ENDIAN);
+
+		long m = 0xc6a4a7935bd1e995L;
+		int r = 47;
+
+		long h = seed ^ (buf.remaining() * m);
+
+		long k;
+		while (buf.remaining() >= 8) {
+			k = buf.getLong();
+
+			k *= m;
+			k ^= k >>> r;
+			k *= m;
+
+			h ^= k;
+			h *= m;
+		}
+
+		if (buf.remaining() > 0) {
+			ByteBuffer finish = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN);
+			finish.put(buf).rewind();
+			h ^= finish.getLong();
+			h *= m;
+		}
+
+		h ^= h >>> r;
+		h *= m;
+		h ^= h >>> r;
+
+		buf.order(byteOrder);
+		return Math.abs(h);
+	}
+	
+	public static void main(String[] args) {
+		List<String> actualNodes = Arrays.asList("192.168.1.100","192.168.1.101","192.168.1.102","192.168.1.103");
+		ConsistencyHash hash = new ConsistencyHash(actualNodes);
+		for (int i = 0; i < VIRTUAL_NUM; i++) {
+			System.out.println(hash.getActualNode(i));
+		}
+	}
+	
+}

src/io/vakin/algorithm/LRU.java

@@ -5,121 +5,96 @@
 
 public class LRU<K, V> implements Iterable<K> {
 
-    private Node head;
-    private Node tail;
-    private HashMap<K, Node> map;
-    private int maxSize;
-
-    private class Node {
+	 int capacity;
+	    HashMap<K, Node> map = new HashMap<K, Node>();
+	    Node head=null;
+	    Node end=null;
+	 
+	    public LRU(int capacity) {
+	        this.capacity = capacity;
+	    }
+	 
+	    public V get(K key) {
+	        if(map.containsKey(key)){
+	            Node n = map.get(key);
+	            remove(n);
+	            setHead(n);
+	            return n.value;
+	        }
+	 
+	        return null;
+	    }
+	 
+	    public void remove(Node n){
+	        if(n.pre!=null){
+	            n.pre.next = n.next;
+	        }else{
+	            head = n.next;
+	        }
+	 
+	        if(n.next!=null){
+	            n.next.pre = n.pre;
+	        }else{
+	            end = n.pre;
+	        }
+	 
+	    }
+	 
+	    public void setHead(Node n){
+	        n.next = head;
+	        n.pre = null;
+	 
+	        if(head!=null)
+	            head.pre = n;
+	 
+	        head = n;
+	 
+	        if(end ==null)
+	            end = head;
+	    }
+	 
+	    public void set(K key, V value) {
+	        if(map.containsKey(key)){
+	            Node old = map.get(key);
+	            old.value = value;
+	            remove(old);
+	            setHead(old);
+	        }else{
+	            Node created = new Node(key, value);
+	            if(map.size()>=capacity){
+	                map.remove(end.key);
+	                remove(end);
+	                setHead(created);
+	 
+	            }else{
+	                setHead(created);
+	            }    
+	 
+	            map.put(key, created);
+	        }
+	    }
+	    
+	@Override
+	public Iterator<K> iterator() {
+		return map.keySet().iterator();
+	}
+	
+	
+	private class Node {
 
         Node pre;
         Node next;
-        K k;
-        V v;
+        K key;
+        V value;
 
         public Node(K k, V v) {
-            this.k = k;
-            this.v = v;
+            this.key = k;
+            this.value = v;
         }
     }
-
-    public LRU(int maxSize) {
-
-        this.maxSize = maxSize;
-        this.map = new HashMap<>(maxSize * 4 / 3);
-    }
-
-    public V get(K key) {
-
-        if (!map.containsKey(key)) {
-            return null;
-        }
-
-        Node node = map.get(key);
-        unlink(node);
-        appendHead(node);
-
-        return node.v;
-    }
-
-    public void put(K key, V value) {
-
-    	if(head == null){
-    		head = new Node(key, value);
-    		tail = head;
-    		return;
-    	}
-        if (map.containsKey(key)) {
-            Node node = map.get(key);
-            unlink(node);
-        }
-
-        Node node = new Node(key, value);
-        map.put(key, node);
-        appendHead(node);
-
-        if (map.size() > maxSize) {
-            Node toRemove = removeTail();
-            map.remove(toRemove);
-        }
-    }
-
-    private void unlink(Node node) {
-        Node pre = node.pre;
-        Node next = node.next;
-        if(pre == null){
-        }else {
-        	pre.next = next;
-        	next.pre = pre;
-        }
-    }
-
-    private void appendHead(Node node) {
-        node.next = head;
-        head.pre = node;
-    }
-
-    private Node removeTail() {
-    	Node node = tail;
-    	if(node == null)return null;
-    	tail = tail.pre;
-        return node;
-    }
-
-    @Override
-    public Iterator<K> iterator() {
-
-        return new Iterator<K>() {
-
-            private Node cur = head.next;
-
-            @Override
-            public boolean hasNext() {
-                return cur != tail;
-            }
-
-            @Override
-            public K next() {
-                Node node = cur;
-                cur = cur.next;
-                return node.k;
-            }
-        };
-    }
-    
-    public static void main(String[] args) {
-		LRU<Object, Object> lru = new LRU<>(10);
-		for (int i = 0; i < 5; i++) {
-			lru.put(i, i);
-		}
-		
-		lru.get(3);
-		lru.get(2);
-		
-		Iterator<Object> iterator = lru.iterator();
-		while(iterator.hasNext()){
-			System.out.println(iterator.next());
-		}
+	
+	public static void main(String[] args) {
 
 	}
+	
 }