Memcached - 具体使用与工具类-低调大师

Memcached - 具体使用与工具类

2018-01-11 615

【1】memcached.properties

//服务器信息
servers=127.0.0.1\:11211

1
2
3

【初始连接数、最小连接数、最大连接数、最大空闲时间】

initialConnections=10
minSpareConnections=5
maxSpareConnections=50
maxIdleTime=1800000

1
2
3
4
5

【最长租用时间】

其使用主要有两点，一是自查线程会检查正在被租用的连接，
如果发现已经被租用的时间超过这个值得，会将其从被租用的记录里剔除，并关闭这个连接；
另一个应用是上层进行MUTIL操作时，读取所有的数据的时间不能超过这个时间。

maxBusyTime=3000000

1
2

【连接池睡眠、超时、等待时间】


//设置连接池守护线程的睡眠时间
maintThreadSleep=5000

//Socket阻塞读取数据的超时时间
socketTimeOut=3000

//Socket阻塞建立连接的等待时间
socketConnectTO=3000

1
2
3
4
5
6
7
8
9
10
11

【nagleAlg：Socket的参数，如果是true在写数据时不缓冲，立即发送出去】

nagleAlg=false

1

【 hashingAlg】

 int hashingAlg = NATIVE_HASH – 池的hash bucket方式，主要是分为简单的hashCode取hash bucket数目的模
    和一致性哈希，前者在扩容时会造成命中率很大程度的下降，后者的好处是扩容时很大程度减少了缓存的重新
    分布

1
2
3

【2】MemcachedConn工具类

初始化MemcachedConn；

package com.atguigu.springmvc.test;

import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;

import java.io.IOException;

public class MemcachedConn
{
  private static String memcached_file = "/memcached.properties";

  private static String[] this_servers = { "192.168.4.188:11111" };

  private static int initialConnections = 10;

  private static int minSpareConnections = 5;

  private static int maxSpareConnections = 50;

  private static long maxIdleTime = 1800000L;

  private static long maxBusyTime = 300000L;

  private static long maintThreadSleep = 5000L;

  private static int socketTimeOut = 3000;

  private static int socketConnectTO = 3000;

  private static boolean nagleAlg = false;

  static String keyFlg = "";

    //获取SockIOPool 实例
  private static SockIOPool pool = SockIOPool.getInstance();

  static
  {
    try
    {
      ParseProperties parseProperties = ParseProperties.getInstance();
      parseProperties.setFilepath(memcached_file);

      if (parseProperties.getValueByKey("servers") != null) {
        String servers = parseProperties.getValueByKey("servers");

        if (servers.contains(";"))
          this_servers = servers.split(";");
        else {
          this_servers[0] = servers;
        }

      }

      if (parseProperties.getValueByKey("initialConnections") != null) {
        initialConnections = Integer.parseInt(parseProperties.getValueByKey("initialConnections"));
      }
      if (parseProperties.getValueByKey("minSpareConnections") != null) {
        minSpareConnections = Integer.parseInt(parseProperties.getValueByKey("minSpareConnections"));
      }
      if (parseProperties.getValueByKey("maxSpareConnections") != null) {
        maxSpareConnections = Integer.parseInt(parseProperties.getValueByKey("maxSpareConnections"));
      }
      if (parseProperties.getValueByKey("maxIdleTime") != null) {
        maxIdleTime = Integer.parseInt(parseProperties.getValueByKey("maxIdleTime"));
      }
      if (parseProperties.getValueByKey("maxBusyTime") != null) {
        maxBusyTime = Integer.parseInt(parseProperties.getValueByKey("maxBusyTime"));
      }
      if (parseProperties.getValueByKey("maintThreadSleep") != null) {
        maintThreadSleep = Integer.parseInt(parseProperties.getValueByKey("maintThreadSleep"));
      }
      if (parseProperties.getValueByKey("socketTimeOut") != null) {
        socketTimeOut = Integer.parseInt(parseProperties.getValueByKey("socketTimeOut"));
      }
      if (parseProperties.getValueByKey("socketConnectTO") != null) {
        socketConnectTO = Integer.parseInt(parseProperties.getValueByKey("socketConnectTO"));
      }
      if (parseProperties.getValueByKey("nagleAlg") != null) {
        if (parseProperties.getValueByKey("nagleAlg").equals("true"))
          nagleAlg = true;
        else {
          nagleAlg = false;
        }
      }
    }
    catch (IOException e)
    {
      e.printStackTrace();
    }
  }

  public static MemcachedConn getInstance()
  {
    conn();

    return new MemcachedConn();
  }
  /**
   * 单例模式--懒汉式
   * @return
   */
  public static MemCachedClient getMemCachedClient()
  {
    conn();

    MemCachedClient memCachedClient = new MemCachedClient();

    return memCachedClient;
  }
    //初始化pool，仅需要一次
  private static void conn()
  {
    pool.setServers(this_servers);

    //初始化时对每个服务器建立的连接数目
    pool.setInitConn(initialConnections);

    // 每个服务器建立最小的连接数，当自查线程发现与某个服务器建立连接数目小于这个数目时会弥补剩下的连接
    pool.setMinConn(minSpareConnections);
    /*每个服务器建立最大的连接数，当自查线程发现与某个服务器建立连接数目大于这个数目时就会逐个检查这些连接的空闲时间是否大于maxIdleTime，如果大于会关闭这些连接，直到连接数等于maxIdleTime*/
    pool.setMaxConn(maxSpareConnections);
    pool.setMaxIdle(maxIdleTime);
    pool.setMaxBusyTime(maxBusyTime);
    pool.setMaintSleep(maintThreadSleep);
    pool.setSocketTO(socketTimeOut);
    pool.setSocketConnectTO(socketConnectTO);
    pool.setNagle(nagleAlg);
    pool.setHashingAlg(2);
    //初始化是否完成的标志，只有初始化完成后上层才能正常使用池
    pool.initialize();
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

【3】Memcached使用

通过MemcachedConn使用memcached；

package com.atguigu.springmvc.test;

import com.danga.MemCached.MemCachedClient;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class MemcachedHelper
{
  private static MemCachedClient memCachedClient = MemcachedConn.getMemCachedClient();

  public static MemcachedHelper getInstance()
  {
    return new MemcachedHelper();
  }

  public boolean add(String key, Object value)
  {
    return memCachedClient.add(MemcachedConn.keyFlg + key, value);
  }

  public boolean add(String key, Object value, Date expiry)
  {
    return memCachedClient.add(MemcachedConn.keyFlg + key, value, expiry);
  }

  public boolean add(String key, Object value, Integer flg)
  {
    return memCachedClient.add(MemcachedConn.keyFlg + key, value, flg);
  }

  public boolean update(String key, Object value)
  {
    return memCachedClient.replace(MemcachedConn.keyFlg + key, value);
  }

  public boolean update(String key, Object value, Date expiry)
  {
    return memCachedClient.replace(MemcachedConn.keyFlg + key, value, expiry);
  }

  public boolean update(String key, Object value, Integer flg)
  {
    return memCachedClient.replace(MemcachedConn.keyFlg + key, value, flg);
  }

  public boolean delete(String key)
  {
    return memCachedClient.delete(MemcachedConn.keyFlg + key);
  }

  public Object get(String key)
  {
    return memCachedClient.get(MemcachedConn.keyFlg + key);
  }

  public Object get(String key, Integer flg) {
    return memCachedClient.get(MemcachedConn.keyFlg + key, flg);
  }

  public List<String> getAllKeys()
  {
    List list = new ArrayList();

    Map items = memCachedClient.statsItems();
    Iterator mapsIt;
    for (Iterator itemIt = items.keySet().iterator(); itemIt.hasNext(); 
      mapsIt.hasNext())
    {
      String itemKey = (String)itemIt.next();

      Map maps = (Map)items.get(itemKey);

      mapsIt = maps.keySet().iterator(); continue;
      String mapsKey = (String)mapsIt.next();
      String mapsValue = (String)maps.get(mapsKey);
      //memcached key 类型  item_str:integer:str number
      if (mapsKey.endsWith("number")) {
        String[] arr = mapsKey.split(":");
        int slabNumber = Integer.valueOf(arr[1].trim()).intValue();
        int limit = Integer.valueOf(mapsValue.trim()).intValue();

        Map dumpMaps = memCachedClient.statsCacheDump(slabNumber, limit);
        Iterator allIt;
        for (Iterator dumpIt = dumpMaps.keySet().iterator(); dumpIt.hasNext(); 
          allIt.hasNext())
        {
          String dumpKey = (String)dumpIt.next();

          Map allMap = (Map)dumpMaps.get(dumpKey);
          allIt = allMap.keySet().iterator(); continue;
          String allKey = (String)allIt.next();
          list.add(allKey.trim());
        }

      }

    }

    return list;
  }

  public boolean existsKey(String key)
  {
    return memCachedClient.keyExists(MemcachedConn.keyFlg + key);
  }

  private void clearAll()
  {
    memCachedClient.flushAll();
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

Linux下key的样式如下：

微信关注我们

原文链接：https://yq.aliyun.com/articles/353449

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

jdk分析工具:jps和jstack

jps 用来查看基于HotSpotJVM里面所有进程的具体状态,包括进程ID，进程启动的路径等等。与unix上的ps类似，用来显示本地有权限的java进程，可以查看本地运行着几个java程序，并显示他们的进程号。使用jps时，不需要传递进程号做为参数。 Jps也可以显示远程系统上的JAVA进程，这需要远程服务上开启了jstat服务，以及RMI注及服务，不过常用都是对本对的JAVA进程的查看。命令格式 jps[options][hostid] 常用参数说明 -m输出传递给main方法的参数，如果是内嵌的JVM则输出为null。 -l输出应用程序主类的完整包名，或者是应用程序JAR文件的完整路径。 -v输出传给JVM的参数。使用示例 blue@blue-pc:~$ jps 8710 Jps 5661 Bootstrap 2491 2967 blue@blue-pc:~$ jps -ml 5661 org.apache.catalina.startup.Bootstrap start 2491 8724 sun.tools.jps.Jps -ml 2967 blue@blue-pc:~$...

2018-01-12

605

使用开源的类库Newtonsoft.Json(下载地址http://json.codeplex.com/)。下载后添加dll引用就能用。首先添加引用：using Newtonsoft.Json; 1.Json字符串普通格式解析(常用) string jsonText = "{\"one\":\"西瓜\",\"two\":\"南瓜\"}"; JObject aaa = (JObject)JsonConvert.DeserializeObject(jsonText); string one = aaa["one"].ToString(); string two = aaa["two"].ToString(); 2.Json字符串嵌套格式解析 string jsonText = "{\"fruit\":{\"name\":\"西瓜\",\"name_en\":\"watermelon\"}}"; JObject jo = (JObject)JsonConvert.DeserializeObject(jsonText); string name = jo["fruit"]["name"].T...

2018-01-12

587

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。