3.redis高并发

   jedis操作redis的话，本质采用了socket模式，io读写（同步阻塞），当任务多的时候，会阻塞，造成获取不到连接资源，产生异常信息，如上一篇http://blog.csdn.net/yeyincai/article/details/50782432文章里面，当并发大的时候就会报异常信息。在研究java操作memcached的时候，进行并发测试，发现redis的qps比不过memcached，当时很疑惑，按照官方的说法redis要比memcached性能更好，但是测试的结果却大跌眼睛，后来研究发现。memcached的客户端采用了nio去读写操作，这样在高并发情况下，性能是由于redis，看来是jedis拖了redis的后退。后来研究出来了用nio操作redis。

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 
 * @author yeyc
 *
 */
public class redisNioConcurrent {
    private Selector selector;

    public void init(String ip, int port) {
        try {
            
            // 获得一个Socket通道
            SocketChannel channel = SocketChannel.open();
            // 获得一个通道管理器
            selector = Selector.open();
            // 设置通道为非阻塞
            channel.configureBlocking(false);
            channel.connect(new InetSocketAddress(ip, port));
            // 将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_CONNECT事件。
            channel.register(selector, SelectionKey.OP_CONNECT);
            selector.select();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private SocketChannel getSocketChannel() {
        try {
            SelectionKey key = selector.selectedKeys().iterator().next();

            if (key.isConnectable()) {
                SocketChannel channel = (SocketChannel) key.channel();
                // 如果正在连接，则完成连接
                if (channel.isConnectionPending()) {
                    channel.finishConnect();
                }
                // 设置成非阻塞
                channel.configureBlocking(false);
                return channel;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public void set(String key, String value) {
        SocketChannel chnnel = getSocketChannel();
        if(chnnel!=null){
            try {
                StringBuilder sb = new StringBuilder();
                sb.append("*3\r\n");//包含三个参数
                sb.append("$3\r\n");//第一个参数的长度
                sb.append("SET\r\n");//第一个参数的值
                sb.append("$"+key.length()+"\r\n");//第二个参数的长度
                sb.append(key+"\r\n");//第二个参数的值
                sb.append("$"+value.length()+"\r\n");//第三个参数的长度
                sb.append(value+"\r\n");//第三个参数的值
                chnnel.write(ByteBuffer.wrap(sb.toString().getBytes(Charset.forName("UTF-8"))));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    

    public static void main(String[] args) throws IOException, InterruptedException {
        final AtomicLong counter = new AtomicLong(0);
        final AtomicBoolean stopFlag = new AtomicBoolean(false);
        final int threadCount = 1000;
        
        final redisNioConcurrent redisNio = new redisNioConcurrent();
        redisNio.init("192.168.1.68",6379 );

        

        for (int i = 0; i < threadCount; i++) {
            final String sss = i + "";
            new Thread(new Runnable() {
                @Override
                public void run() {
                    while (!stopFlag.get()) {
                        redisNio.set(sss, "sdfhkasjhfkasjdhfkjasdhkasdhashdkaskj");
                        counter.incrementAndGet();
                    }
                }
            }).start();

        }



        Runtime.getRuntime().addShutdownHook(new Thread() {
            public void run() {
                System.err.println("*** stop client ***");
                stopFlag.set(true);
            }
        });

        long startTime = System.currentTimeMillis();
        while (!stopFlag.get()) {
            Thread.sleep(1000);

            final long count = counter.get();
            long currentTime = System.currentTimeMillis();
            long qps = count * 1000 / (currentTime - startTime);
            System.out.println("qps=" + qps);

            if ((currentTime - startTime) / 1000 > 10) {
                counter.set(0);
                startTime = currentTime;
                System.out.println("reset counter");
            }
        }

        
    }

}

经过测试采用nio操作redis，qps可以达到28万，而采用jedis的话5万左右，性能相差好几倍，这样如果用nio封装的话，那么在高并发的情况下就适用了，但是这个对编程水平要求很高，不然会很多坑。