memcached演練(2) 訪問memcached服務

通過上節《memcached演練(1) 搭建memcached服務》，已經成功在linux虛擬機上安裝了memcached服務，并設置了自啟動。

STAT version 1.4.29
Mem:          1891

主要內容

• 使用telnet命令行工具，操作memcached服務

• 使用java spymemcached工具訪問memcached服務

• 監控插入不同數據量的數據，響應時間

• 監控memcached主機繁忙&清閑對比情況

• 調整memcached的內存指標，插入相同的數據量的數據，什么情況下性能最高

1.使用telnet命令行工具，操作memcached服務

1.1 驗證set&add添加命令

[hadoop@hadoop1 ~]$ ps -ef |grep memcached
nobody    2047     1  1 07:27 ?        00:08:59 /usr/local/memcached/bin/memcached -d -p 11211 -u nobody -m 64 -c 1024 -P /var/run/memcached/memcached.pid
hadoop    9037  6485  0 16:59 pts/0    00:00:00 grep memcached
#連接
[hadoop@hadoop1 ~]$ telnet 127.0.0.1 11211
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
#獲取key1的值
get key1
VALUE key1 0 4
abcd
END
#調用set命令，為一個已存在的key賦值成功
set key1 0 0 4
1234
STORED
get key1
VALUE key1 0 4
1234
END
#調用set命令，為一個已存在的key賦值失敗
add key1 0 0 4
abcd
NOT_STORED
get key1
VALUE key1 0 4
1234
END

結論：add和set命令雖然都可以添加數據，但兩者使用上存在區別，set可以為已存在的key賦值，而add命令不可以。

1.2 驗證get&gets獲取命令

#獲取1個鍵值
get key1
VALUE key1 0 4
1234
END
#獲取1個鍵值
get key2
VALUE key2 0 4
word
END
#同時獲取2個鍵值
get key1 key2
VALUE key1 0 4
1234
VALUE key2 0 4
word
END
---------------------------------------------
gets key1
VALUE key1 0 4 7695009
1234
END
gets key2
VALUE key2 0 4 7695010
word
END
gets key1 key2
VALUE key1 0 4 7695009
1234
VALUE key2 0 4 7695010
word
END

#gets命令返回比get命令，多了1個"不知名數字"
#修改key1的值
set key1 0 0 5
world
STORED
#確認變化
get key1
VALUE key1 0 5
world
END
#不知名數字從7695009變為7695011
gets key1
VALUE key1 0 5 7695011
world
END
#key2值沒有變化，所以不知名數字也沒有變
gets key2
VALUE key2 0 4 7695010
word
END
#再次修改key1的值
set key1 0 0 3
old
STORED
#用增加了1
gets key1 
VALUE key1 0 3 7695012
old
END

結論gets命令比get命令，多返回的數字，類似數據庫中的“變更版本號似的”，而且這個版本號是在各鍵值之間共享。

1.3測試下incr &decr命令

#某key不存在情況
incr seq 1
NOT_FOUND

set seq 0 0 1
1
STORED
get seq 1
VALUE seq 0 1
1
END
incr seq 1
2
...
get seq
VALUE seq 0 1
4
END
gets seq
VALUE seq 0 1 7695016
4
END
incr seq 1
5
#調用incr 命令，增加變更版本號
gets seq
VALUE seq 0 1 7695017
5
END

incr seq 10
15
decr seq 1
14
#不允許為負數
decr seq -1
CLIENT_ERROR invalid numeric delta argument
decr seq 10
4
#最小值為0
decr seq 10
0
#有最大值限制
decr seq 10000000000000000000000
CLIENT_ERROR invalid numeric delta argument
set seq2 0 0 1
a
STORED
#如果鍵值非數字，會報錯
incr seq2 1
CLIENT_ERROR cannot increment or decrement non-numeric value

通過實驗驗證：incr&decr命令，影響key的長度；最小值為0；增量可變化；必須作用在數字上；命令參數不允許為負數值。

1.4更新命令 append&preppend&replace

set updkey 0 0 5
world
STORED
get updkey
VALUE updkey 0 5
world
END
#在后面添加字符
append updkey 0 0 5
hello
STORED
get updkey
VALUE updkey 0 10
worldhello
#在前面添加字符
prepend updkey 0 0 10
1234567890
STORED
gets updkey
VALUE updkey 0 20 7695030
1234567890worldhello
END
#更改有效時間為1
prepend updkey 0 1 1
#一段時間后，還存在（說明更新操作不會影響有效時間）
get updkey
VALUE updkey 0 22
1u1234567890worldhello
END
#什么都不添加
prepend updkey 0 0 0

STORED
#雖然沒有變更值，但變更版本號也發生了變化
gets updkey
VALUE updkey 0 22 7695037
1u1234567890worldhello
#replace命令
replace updkey 0 10 1
m
STORED

get updkey
VALUE updkey 0 1
m
END
#replace命令變更了有效時間
gets updkey
END

結論：prepend 與append命令作用類似，一個在從前面添加字符，一個在后面追加字符。每一次行為，都會影響版本號；不會影響原來的有效時間；replace命令，不僅可以修改數據，而且可以變更有效時間。

還有其他一些指令，就不玩了。

2.使用java spymemcached工具訪問memcached服務

2.1 引入依賴

<dependency>
    <groupId>net.spy</groupId>
    <artifactId>spymemcached</artifactId>
    <version>2.11.5</version>
</dependency>

2.2 客戶端工具類

package com.nap.memcachedexample.service;
import  net.spy.memcached.MemcachedClient;
import java.io.IOException;
import java.net.InetSocketAddress;

/**
 * Created by Administrator on 2016/8/7.
 */
public class MemcachedUtil {
    private static MemcachedClient cachedClient = null;
    static {
        try {
            cachedClient = new MemcachedClient(new InetSocketAddress("192.168.163.146",11211));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static MemcachedClient getSpyMemcachedClient(){
        return cachedClient;
    }
}

2.2 測試對象

Employee.java  
package com.nap;
import org.apache.commons.lang.builder.ToStringBuilder;
import java.io.Serializable;
import java.util.*;
public class Employee implements Serializable{
    private long empNo;
    private String name;
    private Date birthDate;
    private int age;
    private double salary;
    private List<String> favoriteFoods;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getBirthDate() {
        return birthDate;
    }

    public long getEmpNo() {
        return empNo;
    }

    public void setEmpNo(long empNo) {
        this.empNo = empNo;
    }

    public void setBirthDate(Date birthDate) {
        this.birthDate = birthDate;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public List<String> getFavoriteFoods() {
        return favoriteFoods;
    }

    public void setFavoriteFoods(List<String> favoriteFoods) {
        this.favoriteFoods = favoriteFoods;
    }
    public String toString(){
        return ToStringBuilder.reflectionToString(this);
    }
}
--------------------------------------------------------------------------------------
EmployeeFactory.java 
package com.nap;
import com.nap.memcachedexample.service.MemcachedUtil;
import net.spy.memcached.MemcachedClient;
import net.spy.memcached.internal.OperationFuture;
import org.apache.commons.lang.RandomStringUtils;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutionException;
public class EmployeeFactory {
    static MemcachedClient mcc = MemcachedUtil.getSpyMemcachedClient();
    public static final String EMPNOSEQ = "empnoseq";

    static{
        Object cacheSeq = mcc.get("empnoseq");
        if(cacheSeq==null){
            OperationFuture<Boolean> seqFuture = mcc.set(EMPNOSEQ, 900, "0");
            try {
                if(seqFuture.get()){
                    System.out.println("set status: ok");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 構造測試對象(一個對象大約40B)
     * @return
     */
    public static Employee newEmployee(){
        long empNo = MemcachedUtil.getSpyMemcachedClient().incr("empnoseq",1);
        Calendar cal = Calendar.getInstance();
        Employee emp = new Employee();
        emp.setEmpNo(empNo);
        emp.setAge(new Random().nextInt(80));
        emp.setName(RandomStringUtils.randomAlphabetic(15));
        cal.set(Calendar.MONTH, new Random().nextInt(30));
        cal.set(Calendar.DAY_OF_YEAR, new Random().nextInt(366));
        emp.setBirthDate(cal.getTime());
        emp.setSalary(new Random().nextFloat());
        List<String> foods = new ArrayList<String>();
        for(int j=0;j< new Random().nextInt(10);j++){
            foods.add("foods_"+RandomStringUtils.randomAlphabetic(10));
        }
        emp.setFavoriteFoods(foods);
        return emp;
    }
}

package com.nap;
import com.nap.memcachedexample.service.MemcachedUtil;
import junit.framework.TestCase;
import net.spy.memcached.MemcachedClient;
import java.util.concurrent.ExecutionException;
public class SpyMemcachedClientTest  extends TestCase
{
    //測試set
    public void testAddBean() throws ExecutionException, InterruptedException {
        MemcachedClient mcc = MemcachedUtil.getSpyMemcachedClient();
        Employee emp = EmployeeFactory.newEmployee();
        System.out.println(emp);
        String key = "emp_" + emp.getEmpNo();
        System.out.println(key);
        mcc.set(key, 19000, emp);
        // Shutdowns the memcached client
        mcc.shutdown();
    }
    //測試get
    public void testGetBean() throws ExecutionException, InterruptedException {
        MemcachedClient mcc = MemcachedUtil.getSpyMemcachedClient();
        Object o = mcc.get("emp_1");
        System.out.println(o);
        // Shutdowns the memcached client
        mcc.shutdown();
    }
}

telnet輸出結果

get emp_1
VALUE emp_1 1 345
srcom.nap.Employee
favoriteFoodstLjava/util/List;LnametLjava/lang/String;xpetLjava/util/Date;L

                                                        ?佚U

通過結果分析，通過客戶端已經成功保存了。

3.監控插入不同數據量的數據，響應時間

存儲單位轉換器

package com.nap;
   
public enum SizeConverter {  
    /** 轉換任意單位的大小, 返回結果會包含兩位小數但不包含單位. */ 
    Arbitrary {  
        @Override 
        public String convert(float size) {  
            while (size > 1024) {  
                size /= 1024;  
            }  
            return String.format(FORMAT_F, size);  
        }  
    },  
       
    // -----------------------------------------------------------------------  
    // 有單位  
    /** 轉換單位為B的大小, 返回結果會包含兩位小數以及單位. 如: 1024B->1KB, (1024*1024)B->1MB */ 
    B {  
        @Override 
        public String convert(float B) {  
            return converter(0, B);  
        }  
    },  
    /** 轉換單位為B的大小, 返回結果會包含兩位小數以及單位. */ 
    KB {  
        @Override 
        public String convert(float KB) {  
            return converter(1, KB);  
        }  
    },  
    /** 轉換單位為MB的大小, 返回結果會包含兩位小數以及單位. */ 
    MB {  
        @Override 
        public String convert(float MB) {  
            return converter(2, MB);  
        }  
    },  
    /** 轉換單位為GB的大小, 返回結果會包含兩位小數以及單位. */ 
    GB {  
        @Override 
        public String convert(float GB) {  
            return converter(3, GB);  
        }  
    },  
    /** 轉換單位為TB的大小, 返回結果會包含兩位小數以及單位. */ 
    TB {  
        @Override 
        public String convert(float TB) {  
            return converter(4, TB);  
        }  
    },  
       
    // -----------------------------------------------------------------------  
    // trim沒單位  
    /** 轉換任意單位的大小, 返回結果小數部分為0時將去除兩位小數, 不包含單位. */ 
    ArbitraryTrim {  
        @Override 
        public String convert(float size) {  
            while (size > 1024) {  
                size /= 1024;  
            }  
   
            int sizeInt = (int) size;  
            boolean isfloat = size - sizeInt > 0.0F;  
            if (isfloat) {  
                return String.format(FORMAT_F, size);  
            }  
            return String.format(FORMAT_D, sizeInt);  
        }  
    },  
       
    // -----------------------------------------------------------------------  
    // trim有單位  
    /** 轉換單位為B的大小, 返回結果小數部分為0時將去除兩位小數, 會包含單位. */ 
    BTrim {  
        @Override 
        public String convert(float B) {  
            return trimConverter(0, B);  
        }  
    },  
    /** 轉換單位為KB的大小, 返回結果小數部分為0時將去除兩位小數, 會包含單位. */ 
    KBTrim {  
        @Override 
        public String convert(float KB) {  
            return trimConverter(1, KB);  
        }  
    },  
    /** 轉換單位為MB的大小, 返回結果小數部分為0時將去除兩位小數, 會包含單位. */ 
    MBTrim {  
        @Override 
        public String convert(float MB) {  
            return trimConverter(2, MB);  
        }  
    },  
    /** 轉換單位為GB的大小, 返回結果小數部分為0時將去除兩位小數, 會包含單位. */ 
    GBTrim {  
        @Override 
        public String convert(float GB) {  
            return trimConverter(3, GB);  
        }  
    },  
    /** 轉換單位為TB的大小, 返回結果小數部分為0時將去除兩位小數, 會包含單位. */ 
    TBTrim {  
        @Override 
        public String convert(float TB) {  
            return trimConverter(4, TB);  
        }  
    };  
    /*** 
     * <p> 將指定的大小轉換到1024范圍內的大小. 注意該方法的最大單位為PB, 最小單位為B,  
     * 任何超出該范圍的單位最終會顯示為**. </p> 
     *  
     * @param size 要轉換的大小, 注意是浮點數, 不要以×××的方式傳入, 容易造成溢出. 
     *         (如: 1024*1024*1024*1024*1024會溢出, 使結果為0, 因為它先將結果以int相乘后再轉換為float;  
     *         而1024.0F*1024.0F*1024.0F*1024.0F*1024.0F就不會溢出) 
     * @return 
     */ 
    abstract public String convert(float size);  
       
    // -----------------------------------------------------------------------  
    // 單位轉換  
       
    private static final String[] UNITS = new String[] {  
        "B", "KB", "MB", "GB", "TB", "PB", "**" 
    };  
       
    private static final int LAST_IDX = UNITS.length-1;  
       
    private static final String FORMAT_F = "%1$-1.2f";  
    private static final String FORMAT_F_UNIT = "%1$-1.2f%2$s";  
       
    private static final String FORMAT_D = "%1$-1d";  
    private static final String FORMAT_D_UNIT = "%1$-1d%2$s";  
       
    // -----------------------------------------------------------------------  
    private static String converter(int unit, float size) {  
        int unitIdx = unit;  
        while (size > 1024) {  
            unitIdx++;  
            size /= 1024;  
        }  
        int idx = unitIdx < LAST_IDX ? unitIdx : LAST_IDX;  
        return String.format(FORMAT_F_UNIT, size, UNITS[idx]);  
    }  
       
    private static String trimConverter(int unit, float size) {  
        int unitIdx = unit;  
        while (size > 1024) {  
            unitIdx++;  
            size /= 1024;  
        }  
   
        int sizeInt = (int) size;  
        boolean isfloat = size - sizeInt > 0.0F;  
        int idx = unitIdx < LAST_IDX ? unitIdx : LAST_IDX;  
        if (isfloat) {  
            return String.format(FORMAT_F_UNIT, size, UNITS[idx]);  
        }  
        return String.format(FORMAT_D_UNIT, sizeInt, UNITS[idx]);  
    }  
       
    // -----------------------------------------------------------------------  
    public static String convertBytes(float B, boolean trim) {  
        return trim ? trimConvert(0, B, true) : convert(0, B, true);  
    }  
       
    public static String convertKB(float KB, boolean trim) {  
        return trim ? trimConvert(1, KB, true) : convert(1, KB, true);  
    }  
       
    public static String convertMB(float MB, boolean trim) {  
        return trim ? trimConvert(2, MB, true) : convert(2, MB, true);  
    }  
       
    /*** 
     * <p> 存儲大小單位間的轉換. 注意該方法的最大單位為PB, 最小單位為B,  
     * 任何超出該范圍的單位最終會顯示為**. </p> 
     *  
     * @param unit 從哪個單位開始 
     * @param size 存儲大小, 注意是float, 不要以×××的形式傳入, 否則會溢出(如:1024*1024這種, 
     * 它是先將1024*1024作為int相乘再轉換為float的, 如果值過大的話就會溢出了,  
     * 所以這么寫1024.0F*1024.0F) 
     * @param withUnit 返回的結果字符串是否帶有對應的單位 
     * @return 
     */ 
    private static String convert(int unit, float size, boolean withUnit) {  
        int unitIdx = unit;  
        while (size > 1024) {  
            unitIdx++;  
            size /= 1024;  
        }  
        if (withUnit) {  
            int idx = unitIdx < LAST_IDX ? unitIdx : LAST_IDX;  
            return String.format(FORMAT_F_UNIT, size, UNITS[idx]);  
        }  
        return String.format(FORMAT_F, size);  
    }  
       
    /*** 
     * <p> 存儲大小單位間的轉換, 如果轉換后小數部分為0, 則去除小數部分.  
     * 注意該方法的最大單位為PB, 最小單位為B, 任何超出該范圍的單位最終會顯示為**. </p> 
     *  
     * @param unit 從哪個單位開始 
     * @param size 存儲大小, 注意是float, 不要以×××的形式傳入, 否則會溢出(如:1024*1024這種, 
     * 它是先將1024*1024作為int相乘再轉換為float的, 如果值過大的話就會溢出了,  
     * 所以這么寫1024.0F*1024.0F) 
     * @param withUnit 返回的結果字符串是否帶有對應的單位 
     * @return 
     */ 
    private static String trimConvert(int unit, float size, boolean withUnit) {  
        int unitIdx = unit;  
        while (size > 1024) {  
            unitIdx++;  
            size /= 1024;  
        }  
   
        int sizeInt = (int) size;  
        boolean isfloat = size - sizeInt > 0.0F;  
        if (withUnit) {  
            int idx = unitIdx < LAST_IDX ? unitIdx : LAST_IDX;  
            if (isfloat) {  
                return String.format(FORMAT_F_UNIT, size, UNITS[idx]);  
            }  
            return String.format(FORMAT_D_UNIT, sizeInt, UNITS[idx]);  
        }  
   
        if (isfloat) {  
            return String.format(FORMAT_F, size);  
        }  
        return String.format(FORMAT_D, sizeInt);  
    }

    public static void main(String[] args) {
        System.out.println(SizeConverter.BTrim.convert(1029000f));
    }
}

public class SpyMemcachedClientTest  extends TestCase{
//邏輯非常簡單，僅僅批量插入數量數據，經過估算一個Employee 對象，一般為40B。
public void testBatchAddBean() throws ExecutionException, InterruptedException {
    MemcachedClient mcc = MemcachedUtil.getSpyMemcachedClient();
    long startTime=System.currentTimeMillis();
    int size=10000000;
    for (int i=0;i<size;i++){
        Employee emp = EmployeeFactory.newEmployee();
        System.out.println(emp);
        mcc.set("emp_" + emp.getEmpNo(), 19000, emp);
    }

    long endTime=System.currentTimeMillis();
    System.out.println("保存對象"+size+"數據大小"+SizeConverter.BTrim.convert(size*40.0f)+";共耗時:"+(endTime-startTime));
    // Shutdowns the memcached client
    mcc.shutdown();
}
}

結論(memcached服務內存參數為64m，每次測試前最好執行下flush,降低換入換出影響)

通過分析得知，當數據量為10000-20000左右時，單位時間保存的數據最多。

（0.32 kb/ms,降至0.26kb/s）

4.監控memcached主機繁忙&清閑對比情況

由于僅僅考慮寫入情況，暫時不需要考慮命中率其他情況。主要記錄以下指標

（暫時不考慮內存使用情況,IO等待）

4.1CPU利用率

[root@hadoop1 ~]# sar -u 2 100 
Linux 2.6.32-358.el6.i686 (hadoop1)     08/07/2016      _i686_  (1 CPU)

07:06:47 PM     CPU     %user     %nice   %system   %iowait    %steal     %idle
07:06:49 PM     all      0.50      0.00      0.50      0.00      0.00     98.99
07:06:51 PM     all      0.00      0.00      0.51      0.00      0.00     99.49
07:06:53 PM     all      0.00      0.00      0.50      0.00      0.00     99.50
07:06:55 PM     all      0.00      0.00      0.50      0.50      0.00     99.00
---------------start-------------------------------
07:06:57 PM     all      0.00      0.00      5.18      0.00      0.00     94.82
07:06:59 PM     all      0.58      0.00     41.62      0.00      0.00     57.80
07:07:01 PM     all      0.00      0.00     61.69      0.00      0.00     38.31
07:07:03 PM     all      0.65      0.00     65.36      0.00      0.00     33.99
07:07:05 PM     all      0.62      0.00     70.19      0.00      0.00     29.19
07:07:07 PM     all      1.23      0.00     69.14      0.00      0.00     29.63
07:07:09 PM     all      0.00      0.00     70.55      0.00      0.00     29.45
07:07:11 PM     all      0.00      0.00     70.19      0.00      0.00     29.81
07:07:13 PM     all      0.00      0.00     70.81      0.00      0.00     29.19
07:07:15 PM     all      0.00      0.00     70.89      0.00      0.00     29.11
07:07:17 PM     all      0.00      0.00     71.52      0.00      0.00     28.48
07:07:19 PM     all      0.00      0.00     71.60      0.00      0.00     28.40
07:07:21 PM     all      1.27      0.00     69.43      0.00      0.00     29.30
07:07:23 PM     all      0.00      0.00     70.13      0.00      0.00     29.87
07:07:25 PM     all      0.66      0.00     69.74      0.00      0.00     29.61
07:07:27 PM     all      0.00      0.00     71.34      0.00      0.00     28.66
07:07:29 PM     all      1.85      0.00     69.75      0.00      0.00     28.40
07:07:31 PM     all      0.00      0.00     70.81      0.00      0.00     29.19
07:07:33 PM     all      0.00      0.00     70.89      0.00      0.00     29.11
07:07:35 PM     all      0.00      0.00     41.48      0.00      0.00     58.52
-------------------end-----------------------------------------
07:07:37 PM     all      0.00      0.00      0.50      0.00      0.00     99.50
07:07:39 PM     all      0.00      0.00      0.50      0.00      0.00     99.50

在核心級別(kernel)運行所使用 CPU 總時間的百分比突然提升了40%-70%。

相對來說，用戶級別的CPU 總時間百分比變化不大。這一點有點出乎意料。

輸出項說明：

4.2換頁情況

sar -B
06:59:29 PM  pgpgin/s pgpgout/s   fault/s  majflt/s  pgfree/s pgscank/s pgscand/s pgsteal/s    %vmeff

06:59:35 PM      0.00      0.00     15.50      0.00     53.00      0.00      0.00      0.00      0.00
06:59:37 PM      0.00      0.00     15.58      0.00     53.27      0.00      0.00      0.00      0.00
06:59:39 PM      0.00      0.00     15.58      0.00     53.27      0.00      0.00      0.00      0.00
-----start-----------
06:59:41 PM      0.00      0.00     16.76      0.00     61.62      0.00      0.00      0.00      0.00
06:59:43 PM      0.00      0.00    123.78      0.00    111.59      0.00      0.00      0.00      0.00
06:59:45 PM      0.00      0.00     20.25      0.00     92.64      0.00      0.00      0.00      0.00
06:59:47 PM      0.00     22.78     20.89      0.00     94.30      0.00      0.00      0.00      0.00
06:59:49 PM      0.00      0.00     24.84      0.00    105.73      0.00      0.00      0.00      0.00
06:59:51 PM      0.00      0.00     19.02      0.00     92.02      0.00      0.00      0.00      0.00
06:59:53 PM      0.00      0.00     19.50      0.00     93.08      0.00      0.00      0.00      0.00
06:59:55 PM      0.00      0.00     19.38      0.00     95.00      0.00      0.00      0.00      0.00
06:59:57 PM      0.00      0.00    128.12      0.00    123.75      0.00      0.00      0.00      0.00

由于缺少必要的查詢操作，換頁監控，感覺意義不大。

輸出項說明：

4.3上下文切換次數（提高了2個數量級）

[root@hadoop1 ~]# sar -w 2 100
Linux 2.6.32-358.el6.i686 (hadoop1)     08/07/2016      _i686_  (1 CPU)

06:57:10 PM    proc/s   cswch/s
06:57:12 PM      0.00  14627.04
06:57:14 PM      0.00  14884.81
06:57:16 PM      0.62  14411.11
06:57:18 PM      0.00   1530.41
06:57:20 PM      0.00    118.00
06:57:22 PM      0.00    121.61
06:57:24 PM      0.00    118.09

4.4隊列的長度

sar -q
06:10:01 PM   runq-sz  plist-sz   ldavg-1   ldavg-5  ldavg-15
06:20:01 PM         0       230      0.00      0.00      0.00
06:30:01 PM         0       230      0.00      0.00      0.00
06:40:01 PM         0       230      0.00      0.00      0.00
06:50:01 PM         0       230      0.00      0.00      0.00
07:00:01 PM         0       232      0.00      0.00      0.00
07:10:01 PM         0       230      0.00      0.00      0.00
Average:            0       228      0.00      0.00      0.00

基本上沒什么變化，可以說明瓶頸不再CPU上。

輸出項說明：

5.調整memcached的內存指標，測試性能

結論：發現一個奇怪問題。數據量到了40000時，內存大的反而效率低(多次測試，結果不太穩定，這種情況經常發生）。

個人真有點摸不著頭腦了，有清楚麻煩告知下。

我分別對比了換入換出指標，CPU利用率情況等，均沒有發現能引起注意的地方。難道是網絡問題？

本文由于缺少查詢操作，所以未考慮命中率，在以后調優演練時補上。

---------------------------

The End

memcached 正常使用了。接下來，借助memcached實現tomcat集群效果