redis相关知识积累
在学习redis时总结的问题html
setbit的做用java
参考自: https://www.zhihu.com/question/27672245 git
做者：Andy
连接：https://www.zhihu.com/question/27672245/answer/123641959
来源：知乎
著做权归做者全部。商业转载请联系做者得到受权，非商业转载请注明出处。
redis
这个是SETBIT使用方法的简单说明
算法
在redis中，存储的字符串都是以二级制的进行存在的。vim
举例：
设置一个 key-value ，键的名字叫“andy” 值为字符'a'
安全
咱们知道 'a' 的ASCII码是 97。转换为二进制是：01100001。offset的学名叫作“偏移” 。二进制中的每一位就是offset值啦，好比在这里 offset 0 等于 ‘0’ ，offset 1等于'1' ,offset2等于'1',offset 6 等于'1' ，没错，offset是从左往右计数的，也就是从高位往低位。bash
咱们经过SETBIT 命令将 andy中的 'a' 变成 'b' 应该怎么变呢？服务器
也就是将 01100001 变成 01100010 （b的ASCII码是98），这个很简单啦，也就是将'a'中的offset 6从0变成1，将offset 7 从1变成0 。app
你们可能也发现了，每次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<bs.size();i++){
bs.set(i, false);
}
}
//打印
public static void printBitSet(BitSet bs){
StringBuffer buf=new StringBuffer();
buf.append("[\n");
for(int i=0;i<bs.size();i++){
if(i<bs.size()-1){
buf.append(MainTestFive.getBitTo10(bs.get(i))+",");
}else{
buf.append(MainTestFive.getBitTo10(bs.get(i)));
}
if((i+1)%8==0&&i!=0){
buf.append("\n");
}
}
buf.append("]");
System.out.println(buf.toString());
}
//找出数据集合最大值
public static int getMaxValue(int[] zu){
int temp=0;
temp=zu[0];
for(int i=0;i<zu.length;i++){
if(temp<zu[i]){
temp=zu[i];
}
}
System.out.println("maxvalue:"+temp);
return temp;
}
//放值
public static void putValueIntoBitSet(int[] shu,BitSet bs){
for(int i=0;i<shu.length;i++){
bs.set(shu[i], true);
}
}
//true,false换成1,0为了好看
public static String getBitTo10(boolean flag){
String a="";
if(flag==true){
return "1";
}else{
return "0";
}
}
}
输出：
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。
三、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<String> set(String key, String value) {
getClient(key).set(key, value);
return getResponse(BuilderFactory.STRING);
}
public Response<String> 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<String> get(String key) {
getClient(key).get(key);
return getResponse(BuilderFactory.STRING);
}
public Response<byte[]> get(byte[] key) {
getClient(key).get(key);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
* */
Response<String> 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<String> real = new ArrayList<String>(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<List<Object>> 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<Object> tResult = t.exec();
// System.out.println("Fetched Bit: " + tResult.get(0));
}
redis启动的命令:
redis-server /etc/redis/6379.conf
redis进入命令行
redis-cli
redis单机配置master/slave
好比某台服务器上已经安装并启动了redis,假设配置文件位于: /etc/redis/6379.conf
要在该机上启动slave,须要
a. cp 6379.conf 6380.conf
b. vim 6380.conf,修改两个地方;,一个是slaveof 127.0.0.1 6379;第二个是port 6379 改成6380
c. 启动slave,redis-server /etc/redis/6380.conf
d. 看是否是启动正常
可见master/slave都启动了.
[root@localhost redis]# ps -ef | grep redis | grep server gitlab-+ 692 617 1 03:33 ? 00:03:02 /opt/gitlab/embedded/bin/redis-server 127.0.0.1:0 root 2698 1 0 03:36 ? 00:00:20 redis-server *:6379 root 30173 1 0 08:28 ? 00:00:00 redis-server *:6380
待续
- 1. redis知识积累
- 2. 知识积累
- 3. javascript相关积累
- 4. sklearn相关积累
- 5. MUI知识积累
- 6. Hive知识积累
- 7. 积累的知识
- 8. python 知识积累
- 9. Tomcat知识积累
- 10. SQL知识累积
- 更多相关文章...
- • XML 相关技术 - XML 教程
- • 与传输层有关的基本知识 - TCP/IP教程
- • NewSQL-TiDB相关
- • Java 8 Stream 教程
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. redis知识积累
- 2. 知识积累
- 3. javascript相关积累
- 4. sklearn相关积累
- 5. MUI知识积累
- 6. Hive知识积累
- 7. 积累的知识
- 8. python 知识积累
- 9. Tomcat知识积累
- 10. SQL知识累积