redis相关知识积累

在学习redis时总结的问题

setbit的作用

参考自: https://www.zhihu.com/question/27672245 

作者：Andy
链接：https://www.zhihu.com/question/27672245/answer/123641959 
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

这个是SETBIT使用方法的简单说明

在redis中，存储的字符串都是以二级制的进行存在的。

举例：
设置一个　key-value  ，键的名字叫“andy” 值为字符'a'

我们知道 'a' 的ASCII码是  97。转换为二进制是：01100001。offset的学名叫做“偏移” 。二进制中的每一位就是offset值啦，比如在这里  offset 0 等于 ‘0’ ，offset 1等于'1' ,offset2等于'1',offset 6 等于'1' ，没错，offset是从左往右计数的，也就是从高位往低位。

我们通过SETBIT 命令将 andy中的 'a' 变成 'b' 应该怎么变呢？

也就是将 01100001 变成 01100010 （b的ASCII码是98），这个很简单啦，也就是将'a'中的offset 6从0变成1，将offset 7 从1变成0 。

大家可能也发现了，每次SETBIT完毕之后，有一个（integer） 0或者（integer）1的返回值，这个是在你进行SETBIT 之前，该offset位的比特值。

这个时候，我们再get andy 一下，看看结果：

果然，就从'a' 变成 'b'了。　

这就是redis 中　“SETBIT” 的基本用法。

BITCOUNT 就是统计字符串的二级制码中，有多少个'1'。 所以在这里，

BITCOUNT andy    得到的结果就是  3  啦。

以上。 

下面的内容参考自: http://www.cnblogs.com/happyPawpaw/p/3823277.html 

1，BitSet类
    大小可动态改变, 取值为true或false的位集合。用于表示一组布尔标志。   

此类实现了一个按需增长的位向量。位 set 的每个组件都有一个 boolean 值。用非负的整数将 BitSet 的位编入索引。可以对每个编入索引的位进行测试、设置或者清除。通过逻辑与、逻辑或和逻辑异或操作，可以使用一个 BitSet 修改另一个 BitSet 的内容。

默认情况下，set 中所有位的初始值都是 false。

  每个位 set 都有一个当前大小，也就是该位 set 当前所用空间的位数。注意，这个大小与位 set 的实现有关，所以它可能随实现的不同而更改。位 set 的长度与位 set 的逻辑长度有关，并且是与实现无关而定义的。

   除非另行说明，否则将 null 参数传递给 BitSet 中的任何方法都将导致 NullPointerException。 在没有外部同步的情况下，多个线程操作一个 BitSet 是不安全的。

2，构造函数: BitSet() or BitSet(int nbits)

3，方法：

public void set(int pos): 位置pos的字位设置为true。 
public void set(int bitIndex, boolean value) 将指定索引处的位设置为指定的值。 
public void clear(int pos): 位置pos的字位设置为false。
public void clear() : 将此 BitSet 中的所有位设置为 false。 
public int cardinality() 返回此 BitSet 中设置为 true 的位数。 
public boolean get(int pos): 返回位置是pos的字位值。 
public void and(BitSet other): other同该字位集进行与操作，结果作为该字位集的新值。 
public void or(BitSet other): other同该字位集进行或操作，结果作为该字位集的新值。 
public void xor(BitSet other): other同该字位集进行异或操作，结果作为该字位集的新值。
public void andNot(BitSet set) 清除此 BitSet 中所有的位,set - 用来屏蔽此 BitSet 的 BitSet
public int size(): 返回此 BitSet 表示位值时实际使用空间的位数。
public int length() 返回此 BitSet 的“逻辑大小”：BitSet 中最高设置位的索引加 1。 
public int hashCode(): 返回该集合Hash 码， 这个码同集合中的字位值有关。 
public boolean equals(Object other): 如果other中的字位同集合中的字位相同，返回true。 
public Object clone() 克隆此 BitSet，生成一个与之相等的新 BitSet。 
public String toString() 返回此位 set 的字符串表示形式。

例1：标明一个字符串中用了哪些字符

import java.util.BitSet;
public class WhichChars{
   private BitSet used = new BitSet();
   public WhichChars(String str){
      for(int i=0;i< str.length();i++)
        used.set(str.charAt(i));  // set bit for char
   }
    public String toString(){
         String desc="[";
         int size=used.size();
          for(int i=0;i< size;i++){
             if(used.get(i))
                 desc+=(char)i;
            }
             return desc+"]";
         }
    public static void main(String args[]){
        WhichChars w=new WhichChars("How do you do");
        System.out.println(w);
    }
   }

结果

运行：
C:\work>java WhichChars
[ Hdouwy]

4

java.util.BitSet可以按位存储。
计算机中一个字节（byte）占8位（bit），我们java中数据至少按字节存储的，
比如一个int占4个字节。
如果遇到大的数据量，这样必然会需要很大存储空间和内存。
如何减少数据占用存储空间和内存可以用算法解决。
java.util.BitSet就提供了这样的算法。
比如有一堆数字，需要存储，source=[3,5,6,9]
用int就需要4*4个字节。
java.util.BitSet可以存true/false。
如果用java.util.BitSet，则会少很多，其原理是：
1，先找出数据中最大值maxvalue=9
2，声明一个BitSet bs,它的size是maxvalue+1=10
3，遍历数据source，bs[source[i]]设置成true.
最后的值是：
(0为false;1为true)
bs [0,0,0,1,0,1,1,0,0,1]
                3,   5,6,       9

这样一个本来要int型需要占4字节共32位的数字现在只用了1位！
比例32:1  
这样就省下了很大空间。

例子：

package com;  
  
import java.util.BitSet;  
  
public class MainTestThree {  
  
    /**  
     * @param args  
     */  
    public static void main(String[] args) {  
        BitSet bm=new BitSet();  
        System.out.println(bm.isEmpty()+"--"+bm.size());  
        bm.set(0);  
        System.out.println(bm.isEmpty()+"--"+bm.size());  
        bm.set(1);  
        System.out.println(bm.isEmpty()+"--"+bm.size());  
        System.out.println(bm.get(65));  
        System.out.println(bm.isEmpty()+"--"+bm.size());  
        bm.set(65);  
        System.out.println(bm.isEmpty()+"--"+bm.size());  
    }  
  
}

结果

输出：
 true--64
false--64
false--64
false
false--64
false--128

例子2：

package com;  
  
import java.util.BitSet;  
  
public class MainTestFive {  
  
    /**  
     * @param args  
     */  
    public static void main(String[] args) {  
        int[] shu={2,42,5,6,6,18,33,15,25,31,28,37};  
        BitSet bm1=new BitSet(MainTestFive.getMaxValue(shu));  
        System.out.println("bm1.size()--"+bm1.size());  
          
        MainTestFive.putValueIntoBitSet(shu, bm1);  
        printBitSet(bm1);  
    }  
      
    //初始全部为false，这个你可以不用，因为默认都是false  
    public static void initBitSet(BitSet bs){  
        for(int i=0;i 
  
 
  
输出：
 
  
maxvalue:42
bm1.size()--64
[
0,0,1,0,0,1,1,0,
0,0,0,0,0,0,0,1,
0,0,1,0,0,0,0,0,
0,1,0,0,1,0,0,1,
0,1,0,0,0,1,0,0,
0,0,1,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0
]
 
  
这样便完成了存值和取值。
注意它会对重复的数字过滤，就是说，一个数字出现过超过2次的它都记成1。
出现的次数这个信息就丢了。
 
  
下面是对一些方法的学习
 
  
    @Test
    public void jedisTest() {
    	System.out.println("**************************");
        Jedis jedis = jedis();

        jedis.lpush("meineprivateliste", UUID.randomUUID().toString()); //向key meineprivateliste中存放一个字符串
        System.out.println(jedis.lrange("meineprivateliste", 0, -1)); //第一个是key，第二个是起始位置，第三个是结束位置，jedis.llen获取长度 -1表示取得所有 

        /*
         * 参与自: http://blog.csdn.net/liyantianmin/article/details/51613772 
		  事务是保证事务内的所有命令是原子操作，一般配合watch使用，事务的执行结果和pipeline一样都是采用异步的方式获取结果，multi.exec()提交事务，
		  如果执行成功，其返回的结果和pipeline一样是所有命令的返回值，如果事务里面有两个命令那么事务的exec返回值会把两个命令的返回值组合在一起返回。如果事务被取消返回null。
		3、watch
		一般是和事务一起使用，当对某个key进行watch后如果其他的客户端对这个key进行了更改，那么本次事务会被取消，事务的exec会返回null。jedis.watch(key)都会返回OK
		https://my.oschina.net/sphl520/blog/312514
		我们调用jedis.watch(…)方法来监控key，如果调用后key值发生变化，则整个事务会执行失败。另外，事务中某个操作失败，并不会回滚其他操作。这一点需要注意。还有，我们可以使用discard()方法来取消事务。
         * */
        jedis.watch("foo");
        Transaction t = jedis.multi();
        /*
         * set是PipelineBase里的方法
         * Transaction extends MultiKeyPipelineBase,MultiKeyPipelineBase又extends PipelineBase
         *   
			  public Response set(String key, String value) {
			    getClient(key).set(key, value);
			    return getResponse(BuilderFactory.STRING);
			  }
			
			  public Response set(byte[] key, byte[] value) {
			    getClient(key).set(key, value);
			    return getResponse(BuilderFactory.STRING);
			  }
         * */
        t.set("foo", "bar");
        /*
         * get是PipelineBase里的方法
         * Transaction extends MultiKeyPipelineBase,MultiKeyPipelineBase又extends PipelineBase
         *   
		  public Response get(String key) {
		    getClient(key).get(key);
		    return getResponse(BuilderFactory.STRING);
		  }
		
		  public Response get(byte[] key) {
		    getClient(key).get(key);
		    return getResponse(BuilderFactory.BYTE_ARRAY);
		  }
         * */    
        Response resp = t.get("foo");
        t.exec();
        /*
        public T get() {
		    // if response has dependency response and dependency is not built,
		    // build it first and no more!!
		    if (dependency != null && dependency.set && !dependency.built) {
		      dependency.build();
		    }
		    if (!set) {
		      throw new JedisDataException(
		          "Please close pipeline or multi block before calling this method.");
		    }
		    if (!built) {
		      build();
		    }
		    if (exception != null) {
		      throw exception;
		    }
		    return response;
		 }
         * */
        System.out.println(resp.get());

        /*
         * http://www.blogjava.net/masfay/archive/2012/07/03/382080.html
         * 开启事务，当server端收到multi指令
         * 会将该client的命令放入一个队列，然后依次执行，知道(应该是直到)收到exec指令
         * */
        t = jedis.multi();
        int[] positions = new int[]{1, 2, 3};
        for (int position : positions)
            t.getbit("bla", position);
        for (Object obj : t.exec()) {
            System.out.println("Bit : " + (Boolean) obj);
        }

        jedis.set("meinint", Integer.toString(3));
        /*
         *源自http://www.redis.cn/commands/incr.html 
         * 对存储在指定key的数值执行原子的加1操作。
如果指定的key不存在，那么在执行incr操作之前，会先将它的值设定为0。
如果指定的key中存储的值不是字符串类型（fix：）或者存储的字符串类型不能表示为一个整数，
那么执行这个命令时服务器会返回一个错误(eq:(error) ERR value is not an integer or out of range)。
这个操作仅限于64位的有符号整型数据。
注意: 由于redis并没有一个明确的类型来表示整型数据，所以这个操作是一个字符串操作。
执行这个操作的时候，key对应存储的字符串被解析为10进制的64位有符号整型数据。
事实上，Redis 内部采用整数形式（Integer representation）来存储对应的整数值，所以对该类字符串值实际上是用整数保存，也就不存在存储整数的字符串表示（String representation）所带来的额外消耗。
         * */
        jedis.incr("meinint");
        int meinint = Integer.valueOf(jedis.get("meinint"));
        System.out.println("Integer: " + meinint);
        
        /*
         * 
设置或者清空key的value(字符串)在offset处的bit值。
那个位置的bit要么被设置，要么被清空，这个由value（只能是0或者1）来决定。
当key不存在的时候，就创建一个新的字符串value。要确保这个字符串大到在offset处有bit值。参数offset需要大于等于0，并且小于232(限制bitmap大小为512)。当key对应的字符串增大的时候，新增的部分bit值都是设置为0。
警告：当set最后一个bit(offset等于232-1)并且key还没有一个字符串value或者其value是个比较小的字符串时，Redis需要立即分配所有内存，这有可能会导致服务阻塞一会。在一台2010MacBook Pro上，offset为232-1（分配512MB）需要～300ms，offset为230-1(分配128MB)需要～80ms，offset为228-1（分配32MB）需要～30ms，offset为226-1（分配8MB）需要8ms。注意，一旦第一次内存分配完，后面对同一个key调用SETBIT就不会预先得到内存分配。        
         * */
        jedis.setbit("testbits", 100, true);
        System.out.println("***********************");
        System.out.println("wtf"+jedis.get("testbits"));
        System.out.println(Arrays.toString(jedis.get(SafeEncoder.encode("testbits"))));

        jedis.watch("test");
        if (!jedis.exists("test")) {
            Transaction ta = jedis.multi();
            ta.setbit("test", 100000, false);
            ta.exec();
        }

        Transaction ta = jedis.multi();
        ta.setbit("test", 10, true);
        ta.exec();

        ta = jedis.multi();
        for (int i = 0; i <= 10; i++) {
            ta.getbit("test", i);
        }
        ta.exec();
        //System.out.println(ta.exec());

        jedis.del("perftest");
        long begin = System.nanoTime();
        long bits = 10000000l;
        jedis.setbit("perftest", bits, true);
        System.out.println(jedis.get("perftest"));
        long end = System.nanoTime();
        //System.out.println("Fetch " + bits + " bits: " + (end - begin) / 1000000 + " ms");

        Pipeline p = jedis.pipelined();
        p.multi();
        p.set("muh", "mh");
        p.exec();
        p.sync();
        System.out.println(jedis.get("muh"));

        int size = 10000;
        jedis.setbit("testblob", size, true);
        begin = System.currentTimeMillis();
        for (int i = 0; i < 10; i++) {
            t = jedis.multi();
            jedis.watch("testblob");
            for (int j = 0; j < size / 10; j++) {
                t.setbit("testblob", j, true);
            }
            t.exec();
        }
        end = System.currentTimeMillis();
        //System.out.print("Set " + size + " bits in big TAs: ");
        MemoryBFTest.printStat(begin, end, size);

        ArrayList real = new ArrayList(size);
        for (int i = 0; i < size; i++) {
            real.add("Ich bin die OID " + i);
        }
        //System.out.print("Set " + size + " bits in small TAs: ");
        long start_add = System.currentTimeMillis();
        for (int i = 0; i < size / 10; i++) {
            jedis.watch("testblob");
            t = jedis.multi();
            //falsePositiveProbability = jedis.pipelined();
            for (int j = 0; j < 10; j++) {
                t.setbit("testblob", (int) (Math.random() * size), true);
            }
            t.exec();
            //falsePositiveProbability.sync();
        }
        long end_add = System.currentTimeMillis();
        MemoryBFTest.printStat(start_add, end_add, size);


        //Pipelining bug if watch is after multi
        Pipeline pipe = jedis.pipelined();
        pipe.watch("myKey");
        pipe.multi();
        pipe.set("myKey", "myVal");
        Response> result = pipe.exec();
        pipe.sync();
        for (Object o : result.get())
            System.out.println(o);

        int ops = 1000;
        begin = System.currentTimeMillis();
        for (int i = 0; i < ops; i++) {
            jedis.set("fastset" + i, "val");
        }
        end = System.currentTimeMillis();
        //System.out.print(ops + " set operations: ");
        MemoryBFTest.printStat(begin, end, ops);

        jedis.watch("bits");
        jedis.setbit("bits", 100, true);
        Jedis newJedis = jedis();
        t = newJedis.multi();
        t.getbit("bits", 100);
        List