国外的网页模板中文显示乱码的解决方法

MemCached安装完成后，进行了压力测试，主要参考了MemCached的javaclient的 类com.danga.MemCached.test.MemCachedTest。它的类主要问题是没有一个总的处理能力的描述。我进行了改写，提供了get和put的总吞吐量的汇总。

测试环境如下，

服务器：RedHat9, 512内存，P4内存，跑2个MemCached实例，运行memcached-1.2.1

客户端：单独一台机器，和服务器在一个局域网，100M网络带宽，运行java_memcached-release_1.5.1, jdk5.0

测试代码：

 

java 代码

import com.danga.MemCached.MemCachedClient;   

import com.danga.MemCached.SockIOPool;   

  

public class TestMemCache {   

    static SockIOPool pool;   

  

    static int threads; // 运行的测试线程数   

  

    static int runs; // 每个线程运行的次数   

  

    static int size; // 设置到memcache中的数据包大小，单位k   

  

    static Integer myLock;// 锁定以下计数器   

  

    static long putTimes = 0; // put总时间，单位微秒   

  

    static long getTimes = 0; // get总时间，单位微秒   

  

    /**  

     * @param args  

     */  

    public static void main(String[] args) {   

        String[] serverlist = { "192.168.0.56:11211", "192.168.0.56:11212" };   

  

        // initialize the pool for memcache servers   

        pool = SockIOPool.getInstance();   

        pool.setServers(serverlist);   

  

        pool.setInitConn(5);   

        pool.setMinConn(5);   

        pool.setMaxConn(50);   

        pool.setMaintSleep(30);   

  

        pool.setNagle(false);   

        pool.initialize();   

  

        if (args.length < 3) {   

            System.out.println("用法：TestMemCache 启动线程数 每线程执行测试数量 测试数据大小(k)");   

            System.exit(1);   

        }   

  

        threads = Integer.parseInt(args[0]);   

        runs = Integer.parseInt(args[1]);   

        size = 100 * Integer.parseInt(args[2]);   

  

        myLock = new Integer(threads);   

  

        for (int i = 0; i < threads; i++) {   

            Thread thread = new WorkerThread();   

            thread.start();   

        }   

    }   

  

    private static class WorkerThread extends Thread {   

  

        // 构造函数   

        WorkerThread() {   

        }   

  

        public void run() {   

            // get client instance   

            MemCachedClient mc = new MemCachedClient();   

  

            mc.setCompressEnable(false);   

            mc.setCompressThreshold(0);   

  

            // get object to store   

            int[] obj = new int[size];   

            for (int i = 0; i < size; i++) {   

                obj[i] = i;   

            }   

  

            String[] keys = new String[runs];   

            for (int i = 0; i < runs; i++) {   

                keys[i] = "test_key" + i;   

            }   

  

            for (int i = 0; i < runs; i++) {   

                mc.delete(keys[i]);   

            }   

  

            long startTime = System.currentTimeMillis();   

            for (int i = 0; i < runs; i++) {   

                mc.set(keys[i], obj);   

            }   

            long time = System.currentTimeMillis() - startTime;   

  

            synchronized (myLock) {   

                putTimes += time;   

            }   

  

            startTime = System.currentTimeMillis();   

            for (int i = 0; i < runs; i++) {   

                mc.get(keys[i]);   

            }   

            time = System.currentTimeMillis() - startTime;   

  

            synchronized (myLock) {   

                getTimes += time;   

                myLock--;   

  

                if (myLock.equals(0)) {   

                    System.out.println("测试完成! 启动线程数:" + threads   

                            + ", 每线程执行测试数量: " + runs + ", 测试数据大小(byte):" + size);   

  

                    System.out.println("put处理时间:" + putTimes   

                            + "微秒，处理put速度: 每秒 " + runs * threads * 1000 / putTimes   

                            + " 次");   

                    System.out.println("get处理时间:" + getTimes   

                            + "微秒，处理get速度: 每秒 " + runs * threads * 1000 / getTimes   

                            + " 次");   

  

                    pool.shutDown();   

                }   

            }   

        }   

    }   

  

}   

 测试结果：

测试完成! 启动线程数:1, 每线程执行测试数量: 1000, 测试数据大小(byte):1024

put处理时间:2515微秒，处理put速度: 每秒 789 次

get处理时间:1266微秒，处理get速度: 每秒 789 次

测试完成! 启动线程数:2, 每线程执行测试数量: 1000, 测试数据大小(byte):1024

put处理时间:3595微秒，处理put速度: 每秒 1471 次

get处理时间:2734微秒，处理get速度: 每秒 1471 次

测试完成! 启动线程数:3, 每线程执行测试数量: 1000, 测试数据大小(byte):1024

put处理时间:6250微秒，处理put速度: 每秒 1846 次

get处理时间:4829微秒，处理get速度: 每秒 1846 次

测试完成! 启动线程数:4, 每线程执行测试数量: 1000, 测试数据大小(byte):1024

put处理时间:8673微秒，处理put速度: 每秒 2063 次

get处理时间:7858微秒，处理get速度: 每秒 2063 次

测试完成! 启动线程数:5, 每线程执行测试数量: 1000, 测试数据大小(byte):1024

put处理时间:10655微秒，处理put速度: 每秒 2352 次

get处理时间:10625微秒，处理get速度: 每秒 2352 次

测试完成! 启动线程数:6, 每线程执行测试数量: 1000, 测试数据大小(byte):1024

put处理时间:14702微秒，处理put速度: 每秒 2042 次

get处理时间:16844微秒，处理get速度: 每秒 2042 次

测试完成! 启动线程数:7, 每线程执行测试数量: 1000, 测试数据大小(byte):1024

put处理时间:18766微秒，处理put速度: 每秒 2502 次

get处理时间:20265微秒，处理get速度: 每秒 2502 次

测试完成! 启动线程数:8, 每线程执行测试数量: 1000, 测试数据大小(byte):1024

put处理时间:23828微秒，处理put速度: 每秒 2586 次

get处理时间:25062微秒，处理get速度: 每秒 2586 次

测试完成! 启动线程数:9, 每线程执行测试数量: 1000, 测试数据大小(byte):1024

put处理时间:29515微秒，处理put速度: 每秒 2654 次

get处理时间:31141微秒，处理get速度: 每秒 2654 次

测试完成! 启动线程数:10, 每线程执行测试数量: 1000, 测试数据大小(byte):1024

put处理时间:37780微秒，处理put速度: 每秒 2285 次

get处理时间:42876微秒，处理get速度: 每秒 2285 次

没有测试下去了，看来8~9个线程效率最高，服务端测试的时候，CPU一直使用率很低，最多到5%.

以上测试结果最多到了2500左右，但有位朋友的测试结果非常惊人，一个线程都超过了3300和4800的处理量，他的传输数据量小点，只有0.1k,我测试了下，用这个数据量，顶多也是到3000多的并发。他的测试结果请看如下网址：

 http://hi.baidu.com/jabber/blog/category/Memcached