xiaobian
- 浏览: 579194 次
- 来自: 北京
-
文章分类
最新评论
-
lidi2011：
很通俗易懂的文章，很形象。
同步synchronized方法和代码块 -
inuyasha027：
领教了，谢谢。
Hadoop安装， Hive 安装。 -
xbmujfly：
好文 ，本人发现晚了
学习笔记 - java.util.concurrent 多线程框架 -
hanazawakana：
学习学习！
ANT-build.xml文件详解 -
david.org：
似乎还忽略一点，那就是cassandra不同数据中心的同步，H ...
Cassandra Vs HBase
LRU算法实现：
package com.javaeye.xiaobian.jgroups;
import java.util.LinkedHashMap;
import java.util.Set;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LRUCache<K, V> extends LinkedHashMap<K, V> {
private final int maxCapacity;
private static final float DEFAULT_LOAD_FACTOR = 0.75f;
private final Lock lock = new ReentrantLock();
public LRUCache(int maxCapacity) {
super(maxCapacity, DEFAULT_LOAD_FACTOR, true);
this.maxCapacity = maxCapacity;
}
@Override
protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
return size() > maxCapacity;
}
/**
* Weather contains someone Object according to a key
*
* @param key
*/
@Override
public boolean containsKey(Object key) {
lock.lock();
try {
return super.containsKey(key);
} finally {
lock.unlock();
}
}
/**
* Get one Object according to a key
*
* ��ȡ@param key
*/
@Override
public V get(Object key) {
lock.lock();
try {
return super.get(key);
} finally {
lock.unlock();
}
}
/**
* Put an Object to cache
*
* @param key,valueӻ���
*/
@Override
public V put(K key, V value) {
lock.lock();
try {
return super.put(key, value);
} finally {
lock.unlock();
}
}
/**
* The cache's size
*/
public int size() {
lock.lock();
try {
return super.size();
} finally {
lock.unlock();
}
}
/**
* clear the cache
*
*/
public void clear() {
lock.lock();
try {
super.clear();
} finally {
lock.unlock();
}
}
/**
* Delete one Object from cache
*
* @param key
*/
public void delete(Object key) {
lock.lock();
try {
super.remove(key);
} finally {
lock.unlock();
}
}
/**
* Delete some Objects from cache
*
* @param objArrs
*/
public void batchDelete(Object[] objArrs) {
lock.lock();
try {
for (int i = 0; i < objArrs.length; i++) {
delete(objArrs[i]);
}
} finally {
lock.unlock();
}
}
/**
* Get all Objects from cache
*
* @return Set
*/
public Set getAll() {
lock.lock();
try {
return this.entrySet();
} finally {
lock.unlock();
}
}
/**
* Update one Object in the Cache
*
* @param key
* @param value
*/
public void update(K key, V value) {
lock.lock();
try {
super.remove(key);
this.put(key, value);
} finally {
lock.unlock();
}
}
}
利用Jgroups实现集群同步:
package com.javaeye.xiaobian.jgroups;
import java.io.Serializable;
import org.jgroups.Channel;
import org.jgroups.ExtendedReceiverAdapter;
import org.jgroups.JChannel;
import org.jgroups.Message;
public class CacheSynchronizer {
private static String protocolStackString = "UDP(mcast_addr=236.11.11.11;mcast_port=32767;ip_ttl=64;"
+ "mcast_send_buf_size=32000;mcast_recv_buf_size=64000):"
+ "PING(timeout=2000;num_initial_members=3):"
+ "MERGE2(min_interval=5000;max_interval=10000):"
+ "FD_SOCK:"
+ "VERIFY_SUSPECT(timeout=1500):"
+ "pbcast.NAKACK(gc_lag=50;retransmit_timeout=300,600,1200,2400,4800):"
+ "pbcast.STABLE(desired_avg_gossip=20000):"
+ "UNICAST(timeout=2500,5000):"
+ "FRAG:"
+ "pbcast.GMS(join_timeout=5000;join_retry_timeout=2000;shun=false;print_local_addr=false)";
private static String groupName = "CACHEGROUP";
private Channel channel = null;
private ReceiveCallback recvCallback = null;
// inner class ，receive the broadcast and handle
private class ReceiveCallback extends ExtendedReceiverAdapter {
private Cache cache = null;
public void setCache(Cache baseCache) {
cache = baseCache;
}
public void receive(Message msg) {
if (cache == null)
return;
CacheMessage message = (CacheMessage) msg.getObject();
Object key = message.getKey();
Object value = message.getValue();
if (message.getOperation() == CacheConstants.CLUSTER_ENTRY_ADD) {
cache.put(key, value);
} else if (message.getOperation() == CacheConstants.CLUSTER_ENTRY_DELETE) {
cache.delete(key);
} else if (message.getOperation() == CacheConstants.CLUSTER_ENTRY_DELETE_SOME) {
cache.batchDelete((Object[]) key);
} else if (message.getOperation() == CacheConstants.CLUSTER_ENTRY_UPDATE) {
cache.update(key, value);
}
}
}
public CacheSynchronizer(Cache cache) throws Exception {
channel = new JChannel(protocolStackString);
recvCallback = new ReceiveCallback();
recvCallback.setCache(cache);
channel.setReceiver(recvCallback);
channel.connect(groupName);
}
/**
* Send broadcast message
*
* @param msg
* @throws Exception
*/
public void sendCacheFlushMessage(Object msg) throws Exception {
channel.send(null, null, (Serializable) msg); // 发送广播
}
}
辅助类：
package com.javaeye.xiaobian.jgroups;
public class CacheConstants {
/**
* Cluster add handle
*/
public final static int CLUSTER_ENTRY_ADD = 10;
/**
* Cluster update handle
*/
public final static int CLUSTER_ENTRY_UPDATE = 20;
/**
* Cluster delete handle
*/
public final static int CLUSTER_ENTRY_DELETE = 30;
/**
* Cluster delete sone handle
*/
public final static int CLUSTER_ENTRY_DELETE_SOME = 40;
}
package com.javaeye.xiaobian.jgroups;
import java.io.Serializable;
public abstract class CacheMessage implements Serializable {
public abstract int getOperation();
public abstract Object getKey();
public abstract Object getValue();
}
package com.javaeye.xiaobian.jgroups;
import java.io.Serializable;
public class SynCacheMessage extends CacheMessage implements Serializable {
private Object key;
private Object value;
private int op;
public SynCacheMessage() {
}
public SynCacheMessage(Object key, Object value, int op) {
this.key = key;
this.op = op;
this.value = value;
}
public Object getKey() {
return key;
}
public int getOperation() {
return op;
}
public Object getValue() {
return value;
}
}
实际使用的Cache类：
package com.javaeye.xiaobian.jgroups;
import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Cache {
private static Cache singleton = null;
private LRUCache lruCache = null;
private CacheSynchronizer cacheSyncer = null;
private Cache(int size) {
lruCache = new LRUCache(size);
createSynchronizer();
}
public static Cache getInstance() {
if (singleton == null) {
singleton = new Cache(100000);
}
return singleton;
}
public CacheSynchronizer getSynchronizer() {
return cacheSyncer;
}
public int size() {
return lruCache.size();
}
public void createSynchronizer() {
try {
cacheSyncer = new CacheSynchronizer(this);
} catch (Exception e) {
e.printStackTrace();
}
}
public void batchDelete(Object[] objArrs) {
lruCache.batchDelete(objArrs);
}
public void delete(Object key) {
lruCache.remove(key);
}
public void deleteAll() {
lruCache.clear();
}
public Object get(Object key) {
return lruCache.get(key);
}
public void put(Object key, Object value) {
lruCache.put(key, value);
}
public void update(Object key, Object value) {
lruCache.update(key, value);
}
public Set getAll() {
return lruCache.getAll();
}
@Override
public String toString() {
Set set = Collections.synchronizedSet(getAll());
StringBuffer sb = new StringBuffer();
Iterator it = set.iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
sb.append("key == " + entry.getKey());
sb.append(" value == " + entry.getValue());
sb.append("\n");
}
return sb.toString();
}
}
测试：
package com.javaeye.xiaobian.jgroups;
public class Test {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
Cache cache = Cache.getInstance();
for (int i = 0; i < 10; i++) {
cache.put(String.valueOf(i), "cache" + String.valueOf(i));
CacheMessage msg = new SynCacheMessage(String.valueOf(i), "cache"
+ String.valueOf(i), CacheConstants.CLUSTER_ENTRY_ADD);
cache.getSynchronizer().sendCacheFlushMessage(msg);
System.out.println(cache.size());
System.out.println(cache.toString());
Thread.currentThread().sleep(1000 * 5);
}
/*
* Object[] keys = new Object[10]; for (int i = 0; i < 10; i++) {
* keys[i] = String.valueOf(i); } CacheMessage msg1 = new
* SynCacheMessage(keys, "cache",
* CacheConstants.CLUSTER_ENTRY_DELETE_SOME);
*
* cache.getSynchronizer().sendCacheFlushMessage(msg1);
*/
for (int i = 0; i < 10; i++) {
CacheMessage msg = new SynCacheMessage(String.valueOf(i),
"cacheUpdate" + String.valueOf(i),
CacheConstants.CLUSTER_ENTRY_UPDATE);
cache.update(String.valueOf(i), "cacheUpdate" + String.valueOf(i));
cache.getSynchronizer().sendCacheFlushMessage(msg);
System.out.println(cache.size());
System.out.println(cache.toString());
Thread.currentThread().sleep(1000 * 5);
}
}
}
参考：
http://www.blogjava.net/swingboat/archive/2007/07/16/130565.html
http://bbs.81tech.com/read.php?tid=84461
http://whitesock.iteye.com/blog/199956
1
顶
顶
0
踩
踩
分享到：
发表评论
-
Cassandra Vs HBase
2011-03-31 17:27 2073Cassandra vs HBaseBy Vaibhav Pu ... -
Slope one：简单高效的推荐算法
2011-03-31 17:16 2659推荐系统最早在亚马逊的网站上应用，根据以往用户的购买行为， ... -
Hive 与 Hbase 的简单区别
2011-03-28 11:10 4127Hive是為簡化編寫MapReduce程序而生的，使用MapR ... -
Unsupported major.minor version 49.0
2009-07-14 16:03 1495http://www.blogjava.net/Unmi/ar ... -
Apache Commons Logging 是如何决定使用哪个日志实现类的
2009-07-14 16:01 1635http://www.blogjava.net/Unmi/ar ... -
Spring Quartz 任务调度
2009-07-07 10:22 2160要执行的任务类：CronTask pa ... -
利用java.util.concurrent包实现多线程开发
2009-06-23 16:09 2548有一个网站列表，我们分别使用单线程和多线程来测试这个网站是否允 ... -
Ngnix初探
2009-06-15 17:03 3143Nginx是什么？ ... -
使用eclipse生成文档 javadoc
2009-06-15 10:20 13681，在项目列表中按右键，选择Export（导出），然后在Exp ... -
Java 日期类操作
2009-06-11 14:43 2245java之中操作日期的类分别为： #系统的日期时间类 ... -
留个记号。
2009-06-10 16:01 978Comparable Comparator具体区别 h ... -
Java中java.io.Serializable接口的应用
2009-06-10 10:33 2489在Java中java.io.Serializable 用于实现 ... -
Java中的克隆功能的应用
2009-06-09 13:30 1608在JAVA中对象的克隆有的时候是必要的，克隆分两种：浅克隆、深 ... -
判断SQL注入的字符
2009-06-08 13:13 1401判断SQL注入的字符 public static bo ... -
ThreadLocal的设计与使用（原理篇）
2009-06-05 17:17 1033在jdk1.2推出时开始支持java.lang.ThreadL ... -
探索Java类加载机制
2009-06-05 10:34 1661java虚拟【java.dll】存在于JRE目中下的bin目录 ... -
Nagios介绍
2009-05-26 13:33 1635系统管理员如何能够监视大量的机器和服务以便提前解决问题防止人们 ... -
Memecached实现缓存系统搭建。
2009-05-25 17:51 27901.在windows系统或Linux系统上安装memecach ... -
Java动态代理实现。
2009-05-25 13:33 894HelloWorld.java 接口文件 public i ... -
Java回调函数的实现方式。
2009-05-14 15:13 1715接口Callback类 public interface ...
相关推荐
该资源是Java实现LRU算法的相关代码，将页面序号和进程分配的模块数，运行出具体的变化过程，真实可靠，可实现。
LRU算法实现LRU算法实现LRU算法实现LRU算法实现LRU算法实现
LRU算法的java实现
使用c语言是实现的LRU算法，带测试用例，供大家学习参考使用
编写程序实现LRU算法及其近似算法，并分析各算法的时间复杂度、空间复杂度和实现难度；通过随机生成页面访问序列，测试所实现算法的页错误率，并加以比较和分析。 此资源含完整代码和完整实验报告（加上你的学号姓名...
LRU算法LRU算法LRU算法LRU算法
操作系统中的一个算法 C++实现的，Lru算法
用Java写的一个Cache，内部实现了LRU算法~
近期最少使用算法
使用LRU算法实现页面置换算法。LRU算法基于一种假设，长期不使用的数据，在未来的使用性也不大。因此，当数据占用内存达到一定的阙值时，我们要移除最近最少使用的数据。LRU算法中，使用了一种有趣的数据结构，叫做...
操作系统os 页面置换算法 （java实现） Clock.java Lru.java Opt.java Fifo.java
1.资源包含LRU算法整个项目，可直接在vs2019上运行项目，如果版本不对可选择把项目中cpp文件复制到自己的vs中运行 2.LRU 算法的设计原则是：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也...
jq实现操作系统LRU置换算法
缓存淘汰算法之LRU
LRU算法是常用的缓存替代算法，文档中告诉我们如何实现LRU算法
这里的LRUCache类维护了一个双向链表和一个哈希表，用于实现LRU算法。具体实现细节如下： - get方法：首先在哈希表中查找对应的键值对，如果不存在，则返回-1；如果存在，则将对应的节点从双向链表中删除，并将其...
一个LRU算法的实现.适合于计算机体系结构课程的实验
操作系统LRU算法