Java CacheImpl类代码示例

import com.thimbleware.jmemcached.CacheImpl; //导入依赖的package包/类
public static void newQueueInstance(int port) {
    InetSocketAddress addr = new InetSocketAddress("0.0.0.0", port);
    int idle = -1;
    boolean verbose = false;
    MemCacheDaemon.memcachedVersion = "0.1";
    final MemCacheDaemon<LocalCacheElement> daemon = new MemCacheDaemon<LocalCacheElement>();
    CacheStorage<String, LocalCacheElement> storage = new FSStorage();
    CacheImpl cacheImpl = new CacheImpl(storage);
    daemon.setCache(cacheImpl);
    daemon.setAddr(addr);
    daemon.setBinary(false);
    daemon.setIdleTime(idle);
    daemon.setVerbose(verbose);
    daemon.start();
    log.info("\r\n\t         FQueue instance started,port:" + port
            + " [version 0.1] \r\n\t\t\t Copyright (C) 2011 sunli");
    Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
        public void run() {
            if (daemon != null && daemon.isRunning())
                daemon.stop();
            log.info("shutdown server");
        }
    }));
}
 

import com.thimbleware.jmemcached.CacheImpl; //导入依赖的package包/类
public static int startServer() {
    if (daemon == null) {
        System.setProperty("net.spy.log.LoggerImpl", SLF4JLogger.class.getName());

        // Get next free port for the test server
        portForInstance = SocketUtils.findAvailableTcpPort();

        //noinspection NonThreadSafeLazyInitialization
        daemon = new MemCacheDaemon<>();
        CacheStorage<Key, LocalCacheElement> storage = ConcurrentLinkedHashMap.create(ConcurrentLinkedHashMap.EvictionPolicy.FIFO, 1024 * 1024, 1024 * 1024 * 1024);
        daemon.setCache(new CacheImpl(storage));
        daemon.setAddr(new InetSocketAddress(portForInstance));
        daemon.setVerbose(true);
        daemon.start();
    }
    return portForInstance;
}
 

import com.thimbleware.jmemcached.CacheImpl; //导入依赖的package包/类
public static void main(String[] args) {
       // create daemon and start it
	Logger log = LogManager.getLogger("QuickTest");
	
       MemCacheDaemon daemon = new MemCacheDaemon<LocalCacheElement>();
       CacheStorage<Key, LocalCacheElement> map = ConcurrentLinkedHashMap.create(
       						ConcurrentLinkedHashMap.EvictionPolicy.FIFO, MAX_SIZE, MAX_BYTES);
       
       daemon.setCache(new CacheImpl(map));
       daemon.setBinary(false);
       
       daemon.setAddr(new InetSocketAddress(11211));
       daemon.setVerbose(false);
       
       try {
       	daemon.start();
       } catch (Exception e) {
       	e.printStackTrace();
       	return;
       }

       Cache cache = daemon.getCache();
}
 

import com.thimbleware.jmemcached.CacheImpl; //导入依赖的package包/类
public void start(final String host, final int port) {
    logger.debug("Starting memcache...");

    final CountDownLatch startupLatch = new CountDownLatch(1);
    ExecutorService executor = Executors.newSingleThreadExecutor();
    executor.execute(new Runnable() {
        @Override
        public void run() {
            CacheStorage<Key, LocalCacheElement> storage = ConcurrentLinkedHashMap.create(ConcurrentLinkedHashMap
                    .EvictionPolicy.FIFO, DEFAULT_STORAGE_CAPACITY, DEFAULT_STORAGE_MEMORY_CAPACITY);
            memcacheDaemon = new MemCacheDaemon<>();
            memcacheDaemon.setCache(new CacheImpl(storage));
            memcacheDaemon.setAddr(new InetSocketAddress(host, port));
            memcacheDaemon.start();
            startupLatch.countDown();
        }
    });
    try {
        if (!startupLatch.await(DEFAULT_STARTUP_TIMEOUT, MILLISECONDS)) {
            logger.error("Memcache daemon did not start after {}ms. Consider increasing the timeout", MILLISECONDS);
            throw new AssertionError("Memcache daemon did not start within timeout");
        }
    } catch (InterruptedException e) {
        logger.error("Interrupted waiting for Memcache daemon to start:", e);
        throw new AssertionError(e);
    }
}
 

import com.thimbleware.jmemcached.CacheImpl; //导入依赖的package包/类
@Before
public void setup() throws InterruptedException {

    // create daemon and start it
    final CacheStorage<Key, LocalCacheElement> storage = ConcurrentLinkedHashMap
            .create(ConcurrentLinkedHashMap.EvictionPolicy.FIFO, 10000,
                    10000);
    daemon.setCache(new CacheImpl(storage));
    daemon.setBinary(true);
    daemon.setAddr(new InetSocketAddress(11242));
    daemon.setIdleTime(1000);
    daemon.setVerbose(true);
    daemon.start();
}
 

import com.thimbleware.jmemcached.CacheImpl; //导入依赖的package包/类
@Override
public void start(final String host, final int port) {
    logger.debug("Starting memcache...");

    final CountDownLatch startupLatch = new CountDownLatch(1);
    ExecutorService executor = Executors.newSingleThreadExecutor();
    executor.execute(new Runnable() {
        @Override
        public void run() {
            CacheStorage<Key, LocalCacheElement> storage = ConcurrentLinkedHashMap.create(ConcurrentLinkedHashMap
                .EvictionPolicy.FIFO, DEFAULT_STORAGE_CAPACITY, DEFAULT_STORAGE_MEMORY_CAPACITY);
            memcacheDaemon = new MemCacheDaemon<>();
            memcacheDaemon.setCache(new CacheImpl(storage));
            memcacheDaemon.setAddr(new InetSocketAddress(host, port));
            memcacheDaemon.start();
            startupLatch.countDown();
        }
    });
    try {
        if (!startupLatch.await(DEFAULT_STARTUP_TIMEOUT, MILLISECONDS)) {
            logger.error("Memcache daemon did not start after {}ms. Consider increasing the timeout", MILLISECONDS);
            throw new AssertionError("Memcache daemon did not start within timeout");
        }
    } catch (InterruptedException e) {
        logger.error("Interrupted waiting for Memcache daemon to start:", e);
        throw new AssertionError(e);
    }
}
 

import com.thimbleware.jmemcached.CacheImpl; //导入依赖的package包/类
private static CacheImpl defaultCache() {
  final int maxItems = 1492;
  final int maxBytes = 1024 * 1000;
  final ConcurrentLinkedHashMap<Key, LocalCacheElement> storage = ConcurrentLinkedHashMap.create(
      ConcurrentLinkedHashMap.EvictionPolicy.FIFO, maxItems, maxBytes);
  return new CacheImpl(storage);
}
 

import com.thimbleware.jmemcached.CacheImpl; //导入依赖的package包/类
private MemCacheDaemon<LocalCacheElement> build(final Server server) {
    final MemCacheDaemon<LocalCacheElement> daemon = new MemCacheDaemon<LocalCacheElement>();

    CacheStorage<Key, LocalCacheElement> storage = ConcurrentLinkedHashMap.create(ConcurrentLinkedHashMap.EvictionPolicy.FIFO,
            server.getMaximumCapacity(), server.getMaximumMemoryCapacity());
    daemon.setCache(new CacheImpl(storage));
    daemon.setBinary(server.isBinary());
    daemon.setAddr(new InetSocketAddress("localhost", server.getPort()));
    daemon.setVerbose(server.isVerbose());
    
    return daemon;
}
 

import com.thimbleware.jmemcached.CacheImpl; //导入依赖的package包/类
private static void createCacheDaemon() {
  if (cacheDaemon != null) {
    return;
  }
  cacheDaemon = new MemCacheDaemon<>();
  cacheDaemon.setCache(new CacheImpl(ConcurrentLinkedHashMap.create(ConcurrentLinkedHashMap.EvictionPolicy.FIFO, 1000, 4194304)));
  cacheDaemon.setAddr(new InetSocketAddress(MEMCACHED_PORT));
  cacheDaemon.setBinary(false); // NOTE: JMemcached seem to have binary protocol bugs...
  cacheDaemon.setVerbose(false);
  cacheDaemon.start();
}
 

import com.thimbleware.jmemcached.CacheImpl; //导入依赖的package包/类
@Override
public void afterPropertiesSet() throws Exception {

	logger.info("Initializing JMemcached Server");

	jmemcached = new MemCacheDaemon<LocalCacheElement>();

	CacheStorage<Key, LocalCacheElement> storage = ConcurrentLinkedHashMap.create(
			ConcurrentLinkedHashMap.EvictionPolicy.FIFO, maxItems, maxBytes);
	jmemcached.setCache(new CacheImpl(storage));

	jmemcached.setAddr(AddrUtil.getAddresses(serverUrl).get(0));

	jmemcached.start();

	logger.info("Initialized JMemcached Server");
}