yvhkidt1221 2015-01-28 16:41 采纳率: 0%
浏览 8392

关于Redis数据库的java代码多线程读写性能问题,希望可以帮忙看看、、、

渣渣一枚、、由于项目关系,需要用到内存数据库来存key-value所以就开始研究redis这个数据库。现在已经把redis放在了CentOS的测试服务器上,然后通过网上的资料写了链接代码!
测试用了100个线程,每个线程插入10000条数据,结果竟然花了**200s**,

同事用memcached测试同样的数据只要了**20s**
而在linux中用redis自带的redis-benchmark查询性能
结果如下:

 ====== PING_INLINE ======
  100000 requests completed in 0.72 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

100.00% <= 0 milliseconds
139082.06 requests per second

====== PING_BULK ======
  100000 requests completed in 0.73 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

100.00% <= 0 milliseconds
136798.91 requests per second

====== SET ======
  100000 requests completed in 0.72 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

100.00% <= 0 milliseconds
139275.77 requests per second

====== GET ======
  100000 requests completed in 0.73 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

100.00% <= 0 milliseconds
137931.03 requests per second

====== INCR ======
  100000 requests completed in 0.71 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

100.00% <= 0 milliseconds
141643.06 requests per second

====== LPUSH ======
  100000 requests completed in 0.71 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

100.00% <= 0 milliseconds
141442.72 requests per second

====== LPOP ======
  100000 requests completed in 0.72 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

100.00% <= 0 milliseconds
139664.80 requests per second

====== SADD ======
  100000 requests completed in 0.71 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

100.00% <= 0 milliseconds
140845.08 requests per second

====== SPOP ======
  100000 requests completed in 0.71 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

100.00% <= 0 milliseconds
140252.45 requests per second

====== LPUSH (needed to benchmark LRANGE) ======
  100000 requests completed in 0.71 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

100.00% <= 0 milliseconds
141043.72 requests per second

====== LRANGE_100 (first 100 elements) ======
  100000 requests completed in 1.77 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

100.00% <= 0 milliseconds
56433.41 requests per second

====== LRANGE_300 (first 300 elements) ======
  100000 requests completed in 4.78 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

1.20% <= 1 milliseconds
99.60% <= 2 milliseconds
99.93% <= 3 milliseconds
100.00% <= 3 milliseconds
20938.02 requests per second

====== LRANGE_500 (first 450 elements) ======
  100000 requests completed in 6.78 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

0.02% <= 1 milliseconds
99.75% <= 2 milliseconds
99.96% <= 3 milliseconds
99.99% <= 4 milliseconds
100.00% <= 4 milliseconds
14749.26 requests per second

====== LRANGE_600 (first 600 elements) ======
  100000 requests completed in 8.76 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

0.02% <= 1 milliseconds
7.64% <= 2 milliseconds
99.67% <= 3 milliseconds
99.75% <= 4 milliseconds
99.83% <= 5 milliseconds
99.90% <= 6 milliseconds
99.96% <= 7 milliseconds
100.00% <= 8 milliseconds
100.00% <= 8 milliseconds
11416.83 requests per second

====== MSET (10 keys) ======
  100000 requests completed in 1.13 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

99.98% <= 1 milliseconds
100.00% <= 1 milliseconds
88573.96 requests per second

显示出来的set、get什么的都是10W/S的请求,
所以我的代码应该有问题,不然也不会出现200S的结果,应该是在多线程哪里出了问题,希望可以帮我看看、、

新人、、木有C币,希望大家帮我看看!

public class RedisClient {

    private Jedis jedis;//非切片额客户端连接
    private JedisPool jedisPool;//非切片连接池
    private ShardedJedis shardedJedis;//切片额客户端连接
    private ShardedJedisPool shardedJedisPool;//切片连接池

    private static long START_TIME;
    private static int TOTAL_COUNT =100;
    private static int END_COUNT;
    private static final int COUNT = 10000;

    public RedisClient() {
        initialPool();
        initialShardedPool();
        shardedJedis = shardedJedisPool.getResource();
        jedis = jedisPool.getResource();
    }

    /**
     * 初始化非切片池(非分布式)
     */
    private void initialPool() {
        // 池基本配置
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(128);
        config.setMinIdle(10);
        config.setMaxIdle(128);
        config.setMaxWaitMillis(30000l);
        config.setTestOnBorrow(false);

        jedisPool = new JedisPool(config, "192.168.1.110", 6379, 0);
    }

    /**
     * 初始化切片池(分布池)
     */
    private void initialShardedPool() {
        // 池基本配置
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(128);
        config.setMinIdle(10);
        config.setMaxIdle(128);
        config.setMaxWaitMillis(30000l);
        config.setTestOnBorrow(false);
        // slave链接
        List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
        shards.add(new JedisShardInfo("192.168.1.110", 6379, 0));

        // 构造池
        shardedJedisPool = new ShardedJedisPool(config, shards);
    }

    public void show() {
        HashOperate();

    }

    private void HashOperate() {
        System.out.println("======================hash==========================");
        //清空数据
        System.out.println(jedis.flushDB());
        System.out.println("=============增=============");
        Thread[] threads = new Thread[TOTAL_COUNT];
        for (int i = 0; i < TOTAL_COUNT; i++) {
            threads[i] = new TTestThread(i * COUNT, COUNT);
        }
        START_TIME = System.currentTimeMillis();
        for (int i = 0; i < TOTAL_COUNT; ++i) {
            threads[i].start();
        }
    }

    private class TTestThread extends Thread {
        private int mOffset;
        private int mCount;

        private Transaction tx;

        public TTestThread(int offset, int count) {
            mOffset = offset;
            mCount = count;
        }

        @Override
        public void run() {
            super.run();
            ShardedJedis shardedJedis = shardedJedisPool.getResource();
            try {
                for (int i = mOffset; i < mCount + mOffset; ++i) {
                    shardedJedis.hset("hashs", "key" + i, String.valueOf(i));
                }

            } finally {
                shardedJedisPool.returnResource(shardedJedis);
            }
            synchronized (TTestThread.class) {
                ++END_COUNT;
                if (END_COUNT == TOTAL_COUNT) {
                    System.out.println("time is " + (System.currentTimeMillis() - START_TIME));
                }
            }
        }
    }
}

  • 写回答

2条回答 默认 最新

  • danielinbiti 2015-01-28 17:25
    关注

    synchronized (TTestThread.class) { 这个同步锁在类上,范围有点大,差不多是顺序执行了。
    你需要同步的只是END_COUNT,只要锁这个共享变量就行了。或者锁个外部的函数方法。

    评论

报告相同问题?

悬赏问题

  • ¥15 求差集那个函数有问题,有无佬可以解决
  • ¥15 【提问】基于Invest的水源涵养
  • ¥20 微信网友居然可以通过vx号找到我绑的手机号
  • ¥15 寻一个支付宝扫码远程授权登录的软件助手app
  • ¥15 解riccati方程组
  • ¥15 display:none;样式在嵌套结构中的已设置了display样式的元素上不起作用?
  • ¥15 使用rabbitMQ 消息队列作为url源进行多线程爬取时,总有几个url没有处理的问题。
  • ¥15 Ubuntu在安装序列比对软件STAR时出现报错如何解决
  • ¥50 树莓派安卓APK系统签名
  • ¥65 汇编语言除法溢出问题