memcached演練(2) 訪問memcached服務

發布時間：2020-08-11 07:45:26 來源：網絡閱讀：977 作者：randy_shandong 欄目：大數據

通過上節《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,降低換入換出影響)

數據量	數據大小	耗時（ms）
1000	39.06KB	1191
10000	390.63KB	3155
20000	781.25KB	5142
30000	1.14MB	7057
40000	1.53MB	8611
50000	1.91MB	10611
100000	3.81MB	19594
500000	19.07MB	89549

通過分析得知，當數據量為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 總時間百分比變化不大。這一點有點出乎意料。

輸出項說明：

CPU	all 表示統計信息為所有 CPU 的平均值。
%user	顯示在用戶級別(application)運行使用 CPU 總時間的百分比。
%nice	顯示在用戶級別，用于nice操作，所占用 CPU 總時間的百分比。
%system	在核心級別(kernel)運行所使用 CPU 總時間的百分比。
%iowait	顯示用于等待I/O操作占用 CPU 總時間的百分比。
%steal	管理程序(hypervisor)為另一個虛擬進程提供服務而等待虛擬 CPU 的百分比。
%idle	顯示 CPU 空閑時間占用 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

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

輸出項說明：

pgpgin/s	每秒鐘從磁盤讀入的系統頁面的 KB 總數
pgpgout/s	每秒鐘向磁盤寫出的系統頁面的 KB 總數
fault/s	系統每秒產生的頁面失效(major + minor)數量
majflt/s	系統每秒產生的頁面失效(major)數量

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上。

輸出項說明：

runq-sz	運行隊列的長度（等待運行的進程數）
plist-sz	進程列表中進程（processes）和線程（threads）的數量
ldavg-1	最后1分鐘的系統平均負載（System load average）
ldavg-5	過去5分鐘的系統平均負載
ldavg-15	過去15分鐘的系統平均負載

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

數據量	數據量大小	64m 響應時間（ms）	128m 響應時間 (ms)	512m響應時間
1000	39.06KB	1191	761	753
10000	390.63KB	3155	3116	3168
20000	781.25KB	5142	4965	4978
30000	1.14MB	7057	6893	6829
40000	1.53MB	8611	8629	8725
50000	1.91MB	10611	10660	10334
100000	3.81MB	19594	19984	19760

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

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

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

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

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

The End

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

向AI問一下細節

中文字幕av专区_日韩电影在线播放_精品国产精品久久一区免费式_av在线免费观看网站

memcached演練(2) 訪問memcached服務

猜你喜歡

中文字幕av专区_日韩电影在线播放_精品国产精品久久一区免费式_av在线免费观看网站

memcached演練(2) 訪問memcached服務

猜你喜歡

最新資訊

相關推薦

相關標簽