qwqwqwqwqwqwqwq115

Redis 学习笔记

Redis 入门

b 站【狂神 Redis 视频】

安装 Redis

通过指定的配置文件 redis.conf 启动 redis 服务

使用 redis-cli 连接 6379 端口

测试 get、set、keys * 命令

关闭 redis

性能测试

redis-benchmark（官方自带的性能测试工具）

# 测试：100 个并发连接 100000 请求
redis-benchmark -h localhost -p 6379 -c 100 -n 100000

Redis 基础知识

Redis 默认有 16 个数据库

默认使用的是第 0 个

select 进行切换数据库

DBSIZE 查看数据库大小

flushdb 清空当前数据库

flushall 清空全部数据库

Redis 是单线程的（6.0 之后是多线程的）

Redis 是很快的，官方表示 Redis 是基于内存操作，CPU 不是 Redis 性能瓶颈，Redis 的瓶颈是机器内存和网络带宽，既然可以使用单线程来实现，就使用单线程了

Redis 是 C 写的，官方提供数据为 100000+ 的 QPS，不比同样使用 key-value 的 memecache 差

Redis 为什么单线程还这么快？

误区 1：高性能的服务器一定是多线程的

误区 2：多线程（CPU上下文切换：耗时的操作）一定比单线程效率高（速度：CPU > 内存 > 硬盘）

核心：Redis 是将所有的数据全部放在内存中的，所以使用单线程操作效率最高

五大数据类型

Redis-Key

127.0.0.1:6379> set name Jarvis
OK
127.0.0.1:6379> set age 3
OK
127.0.0.1:6379> exists name # 判断当前 key 是否存在
(integer) 1
127.0.0.1:6379> move name 1 # 将当前 key 从当前数据库移到 1 数据库
(integer) 1
127.0.0.1:6379> keys *
1) "age"
127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> keys *
1) "name"
127.0.0.1:6379[1]> move name 0
(integer) 1
127.0.0.1:6379[1]> select 0
OK
127.0.0.1:6379> keys *
1) "name"
2) "age"

127.0.0.1:6379> expire name 20 # 设置当前 key 20 秒后过期
(integer) 1
127.0.0.1:6379> ttl name # 查看倒计时还有几秒
(integer) 16
127.0.0.1:6379> ttl name
(integer) 8
127.0.0.1:6379> ttl name
(integer) 7
127.0.0.1:6379> get name
(nil)

127.0.0.1:6379> type name # 查看当前 key 的类型
string
127.0.0.1:6379> type age
string

String（字符串）

127.0.0.1:6379> set key1 v1
OK
127.0.0.1:6379> get key1
"v1"
127.0.0.1:6379> append key1 "hello" # 追加字符串，如果该键不存在，相当于 set key
(integer) 7
127.0.0.1:6379> get key1
"v1hello"
127.0.0.1:6379> strlen key1 # 获取字符串的长度
(integer) 7
127.0.0.1:6379> append key1 ",Jarvis"
(integer) 14
127.0.0.1:6379> get key1
"v1hello,Jarvis"
127.0.0.1:6379>

127.0.0.1:6379> set views 0
OK
127.0.0.1:6379> get views
"0"
127.0.0.1:6379> incr views # 相当于 views++ 自增1
(integer) 1
127.0.0.1:6379> incr views
(integer) 2
127.0.0.1:6379> get views
"2"
127.0.0.1:6379> type views
string
127.0.0.1:6379> decr views # 相当于 views-- 自减1
(integer) 1
127.0.0.1:6379> incrby views 10 # 相当于 views += 10
(integer) 11
127.0.0.1:6379> decrby views 10 # 相当于 views -= 10
(integer) 1
127.0.0.1:6379>

127.0.0.1:6379> set key1 "hello,Jarvis"
OK
127.0.0.1:6379> get key1
"hello,Jarvis"
127.0.0.1:6379> getrange key1 0 3 # 截取字符串 [0, 3]
"hell"
127.0.0.1:6379> getrange key1 0 -1 # 获取全部字符串
"hello,Jarvis"
127.0.0.1:6379>

127.0.0.1:6379> set key2 abcdefg
OK
127.0.0.1:6379> get key2
"abcdefg"
127.0.0.1:6379> setrange key2 1 xx # 替换指定位置开始的字符串
(integer) 7
127.0.0.1:6379> get key2
"axxdefg"

# setex(set with expire) 设置到期时间
# setnx(set if not exists) 如果不存在...（在分布式锁中会常用）
127.0.0.1:6379> setex key3 30 hello
OK
127.0.0.1:6379> ttl key3
(integer) 25
127.0.0.1:6379> setnx key4 redis
(integer) 1
127.0.0.1:6379> keys *
1) "key2"
2) "key1"
3) "key4"
127.0.0.1:6379> setnx key4 mongoDB
(integer) 0
127.0.0.1:6379> get key4
"redis"
127.0.0.1:6379>

127.0.0.1:6379> mset key1 v1 key2 v2 key3 v3 # 同时设置多个值
OK
127.0.0.1:6379> keys *
1) "key3"
2) "key2"
3) "key1"
127.0.0.1:6379> mget key1 key2 key3 # 同时获取多个值
1) "v1"
2) "v2"
3) "v3"
127.0.0.1:6379> msetnx key1 v1 key4 v4 # 原子性操作，要么都成功，要么都失败
(integer) 0
127.0.0.1:6379>

# 对象
127.0.0.1:6379> set user:1 {name:zhangsan,age:3} # 设置一个 user:1 对象，值为 json字符来保存对象
OK
127.0.0.1:6379> get user:1
"{name:zhangsan,age:3}"
127.0.0.1:6379> mset user:1:name zhangsan user:1:age 12
OK
127.0.0.1:6379> mget user:1:name user:1:age
1) "zhangsan"
2) "12"
127.0.0.1:6379>

127.0.0.1:6379> getset db redis
(nil)
127.0.0.1:6379> get db
"redis"
127.0.0.1:6379> getset db mongoDB
"redis"
127.0.0.1:6379> get db
"mongoDB"
127.0.0.1:6379>

String 类型使用场景（value 可以是数字）：

计数器

统计多单位的数量

粉丝数

对象缓存存储

List

基本的数据类型，列表

在 Redis 中，可以把 List 玩成栈、队列、阻塞队列

# l 和 r 是 left 和 right 的意思
# 双端队列
127.0.0.1:6379> lpush list one
(integer) 1
127.0.0.1:6379> lpush list two
(integer) 2
127.0.0.1:6379> lpush list three
(integer) 3
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> rpush list four
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
3) "one"
4) "four"
127.0.0.1:6379>

127.0.0.1:6379> keys *
1) "list"
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
3) "one"
4) "four"
127.0.0.1:6379> lpop list 1 # 从左开始移除一个元素
1) "three"
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
3) "four"
127.0.0.1:6379> rpop list 2 # 从右开始移除两个元素
1) "four"
2) "one"
127.0.0.1:6379> lrange list 0 -1
1) "two"
127.0.0.1:6379>

127.0.0.1:6379> lrange list 0 -1
1) "one"
2) "two"
127.0.0.1:6379> lindex list 0 # 根据下标获取 list 中的值
"one"
127.0.0.1:6379> llen list # 获取 list 长度
(integer) 2
127.0.0.1:6379>

# count > 0: 从头往尾移除值为 value 的元素;
# count < 0: 从尾往头移除值为 value 的元素;
# count = 0: 移除所有值为 value 的元素
127.0.0.1:6379> lrange list 0 -1
1) "four"
2) "three"
3) "four"
4) "three"
5) "one"
6) "two"
127.0.0.1:6379> lrem list -1 four # 移除 1 个 four
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "four"
2) "three"
3) "three"
4) "one"
5) "two"
127.0.0.1:6379>

127.0.0.1:6379> lrange list 0 -1
1) "hello1"
2) "hello2"
3) "hello3"
4) "hello4"
127.0.0.1:6379> ltrim list 1 2 # 只留下标 1 - 2 中的值
OK
127.0.0.1:6379> lrange list 0 -1
1) "hello2"
2) "hello3"
127.0.0.1:6379>

127.0.0.1:6379> lrange list 0 -1
1) "hello1"
2) "hello2"
3) "hello3"
4) "hello4"
127.0.0.1:6379> rpoplpush list anotherList
"hello4"
127.0.0.1:6379> lrange anotherList 0 -1
1) "hello4"
127.0.0.1:6379>

127.0.0.1:6379> lset list 0 newHello1 # 把下标为 0 的值设置为 newHello1
OK
127.0.0.1:6379> lrange list 0 -1
1) "newHello1"
2) "hello2"
3) "hello3"
127.0.0.1:6379>

127.0.0.1:6379> linsert list before hello2 beforeHello2 # 在 hello2 前插入 beforeHello2
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "newHello1"
2) "beforeHello2"
3) "hello2"
4) "hello3"
127.0.0.1:6379>

可以用来实现消息队列（MQ）

Set

127.0.0.1:6379> sadd set hello # 添加元素
(integer) 1
127.0.0.1:6379> sadd set Jarvis
(integer) 1
127.0.0.1:6379> sadd set Hututu
(integer) 1
127.0.0.1:6379> smembers set # 查看指定 set 的所有元素
1) "hello"
2) "Hututu"
3) "Jarvis"
127.0.0.1:6379> sismember set hello # 判断某个元素是否在 set 中
(integer) 1
127.0.0.1:6379> sismember set zz
(integer) 0
127.0.0.1:6379> scard set # 获取 set 的大小
(integer) 3
127.0.0.1:6379> sadd set hello # set 中元素不能重复，这里添加失败
(integer) 0
127.0.0.1:6379> srem set hello # 移除 set 中某个元素
(integer) 1
127.0.0.1:6379> smembers set
1) "Hututu"
2) "Jarvis"
127.0.0.1:6379> sadd set hello
(integer) 1
127.0.0.1:6379> SMEMBERS set
1) "hello"
2) "Hututu"
3) "Jarvis"
127.0.0.1:6379> SRANDMEMBER set 1 # 随机挑选一个幸运元素
1) "hello"
127.0.0.1:6379> spop set 1 # 随机移除一个倒霉元素
1) "Hututu"
127.0.0.1:6379> SMEMBERS set
1) "hello"
2) "Jarvis"
127.0.0.1:6379> SMOVE set anotherset hello # 移动元素
(integer) 1
127.0.0.1:6379> SMEMBERS set
1) "Jarvis"
127.0.0.1:6379> SMEMBERS anotherset
1) "hello"
127.0.0.1:6379>

127.0.0.1:6379> SMEMBERS set1
1) "c"
2) "b"
3) "a"
127.0.0.1:6379> SMEMBERS set2
1) "c"
2) "d"
3) "b"
127.0.0.1:6379> SDIFF set1 set2 # 差集
1) "a"
127.0.0.1:6379> SINTER set1 set2 # 交集
1) "c"
2) "b"
127.0.0.1:6379> SUNION set1 set2 # 并集
1) "c"
2) "b"
3) "d"
4) "a"
127.0.0.1:6379>

应用场景：将所有关注的人放在一个 set 中，将其所有粉丝放入一个 set 中，共同关注（SINTER）

Hash

key-map

127.0.0.1:6379> hset hash1 field1 jarvis # set
(integer) 1
127.0.0.1:6379> hget hash1 field1
"jarvis"
127.0.0.1:6379> hmset hash1 field1 hello field2 world # set 多个
OK
127.0.0.1:6379> hmget hash1 field1 field2 # 获取多个
1) "hello"
2) "world"
127.0.0.1:6379> hgetall hash1 # 获取全部数据
1) "field1"
2) "hello"
3) "field2"
4) "world"
127.0.0.1:6379> hdel hash1 field1 # 删除指定 key-value
(integer) 1
127.0.0.1:6379> hgetall hash1
1) "field2"
2) "world"
127.0.0.1:6379> hlen hash1 # 获取 hash1 键值对数量
(integer) 1
127.0.0.1:6379> HEXISTS hash1 field2 # 判断 hash1 中 field2 是否存在
(integer) 1
127.0.0.1:6379> HEXISTS hash1 field1
(integer) 0
127.0.0.1:6379> HKEYS hash1 # 获取所有 key
1) "field2"
127.0.0.1:6379> HVALS hash1 # 获取所有 value
1) "world"
127.0.0.1:6379> hset hash1 field3 1
(integer) 1
127.0.0.1:6379> HGETALL hash1
1) "field2"
2) "world"
3) "field1"
4) "value1"
5) "field3"
6) "1"
127.0.0.1:6379> HINCRBY hash1 field3 1 # 增
(integer) 2
127.0.0.1:6379> HINCRBY hash1 field3 -3
(integer) -1
127.0.0.1:6379> HSETNX hash1 field1 new # 如果存在 set
(integer) 0
127.0.0.1:6379> HSETNX hash1 field4 new
(integer) 1
127.0.0.1:6379> HGETALL hash1
1) "field2"
2) "world"
3) "field1"
4) "value1"
5) "field3"
6) "-1"
7) "field4"
8) "new"
127.0.0.1:6379>

应用场景：Hash 更适合对象的存储，String 更适合字符串存储

Zset

有点像Treeset，有序集合

127.0.0.1:6379> zadd zset 1 one # 添加一个值
(integer) 1
127.0.0.1:6379> zadd zset 2 two 3 three # 添加多个值
(integer) 2
127.0.0.1:6379> ZRANGE zset 0 -1
1) "one"
2) "two"
3) "three"
127.0.0.1:6379> ZADD salary 2500 x 5000 y 500 z
(integer) 3
127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf # 排序（从小到大）
1) "z"
2) "x"
3) "y"
127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf withscores
1) "z"
2) "500"
3) "x"
4) "2500"
5) "y"
6) "5000"
127.0.0.1:6379> ZRANGEBYSCORE salary -inf 2500 withscores # -∞ ~ 2500
1) "z"
2) "500"
3) "x"
4) "2500"
127.0.0.1:6379> ZREVRANGEBYSCORE salary +inf -inf withscores # 排序（从大到小）
1) "y"
2) "5000"
3) "x"
4) "2500"
5) "z"
6) "500"
127.0.0.1:6379> zrem salary x # 删除
(integer) 1
127.0.0.1:6379> ZRANGE salary 0 -1
1) "z"
2) "y"
127.0.0.1:6379> ZCARD salary # 获取 有序集合 大小
(integer) 2
127.0.0.1:6379> ZREVRANGE salary 0 -1 # 逆序获取
1) "y"
2) "z"
127.0.0.1:6379> ZRANGE zset 0 -1
1) "one"
2) "two"
3) "three"
127.0.0.1:6379> ZCOUNT zset 1 3 # 获取区间之间成员数量
(integer) 3

三种特殊数据类型

geospatial（地理位置）

# 添加地理位置（地球两极是无法添加的，一般下载城市数据，通过 Java 程序一次性导入）
127.0.0.1:6379> GEOADD china:city 116.40 39.90 beijing
(integer) 1
127.0.0.1:6379> GEOADD china:city 121.47 31.23 shanghai
(integer) 1
127.0.0.1:6379> GEOADD china:city 106.50 29.53 chongqing 114.05 22.52 shenzhen
(integer) 2
127.0.0.1:6379> GEOADD china:city 120.16 30.24 hangzhou 108.96 34.26 xian
(integer) 2
127.0.0.1:6379> GEOPOS china:city beijing chongqing # 获取 经度 和 维度
1) 1) "116.39999896287918091"
   2) "39.90000009167092543"
2) 1) "106.49999767541885376"
   2) "29.52999957900659211"
127.0.0.1:6379> GEODIST china:city beijing chongqing km # 查看直线距离（最后一个参数是 单位） 
"1464.0708"
127.0.0.1:6379> GEORADIUS china:city 110 30 1000 km # 查看指定范围内的城市
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
127.0.0.1:6379> GEORADIUS china:city 110 30 1000 km withdist withcoord count 1
1) 1) "chongqing"
   2) "341.9374"
   3) 1) "106.49999767541885376"
      2) "29.52999957900659211"
127.0.0.1:6379> GEORADIUSBYMEMBER china:city beijing 1000 km # 以北京为中心查询方圆1000km内的城市
1) "beijing"
2) "xian"
127.0.0.1:6379> GEOHASH china:city beijing chongqing # 将二维的经纬度转换为一维的字符串
1) "wx4fbxxfke0"
2) "wm5xzrybty0"
127.0.0.1:6379>

底层实现原理：zset

127.0.0.1:6379> ZRANGE china:city 0 -1 # 查看地图中全部元素
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
5) "shanghai"
6) "beijing"
127.0.0.1:6379> ZREM china:city beijing # 移除指定元素
(integer) 1
127.0.0.1:6379> ZRANGE china:city 0 -1
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
5) "shanghai"
127.0.0.1:6379>

hyperloglog

基数（不重复的元素）统计的算法

优点：占用内存是固定的，2^64 不同元素的基数，只需 12 KB 的内存

127.0.0.1:6379> PFADD key a b c d e f g h i j # 创建 key
(integer) 1
127.0.0.1:6379> PFCOUNT key # 统计 key 中基数数量
(integer) 10
127.0.0.1:6379> PFADD key2 i j z x c v b n m
(integer) 1
127.0.0.1:6379> PFCOUNT key2
(integer) 9
127.0.0.1:6379> PFMERGE key3 key key2 # 合并 key key2 放在 key3 中
OK
127.0.0.1:6379> PFCOUNT key3
(integer) 15
127.0.0.1:6379>

如果允许容错，可以使用 hyperloglog
如果不允许容错，就使用 set

bitmaps

位存储

两个状态的可以使用 bitmaps，非 0 即 1

# 记录周一到周日的打卡 （0：没打 1：打了）
127.0.0.1:6379> setbit sign 0 1
(integer) 0
127.0.0.1:6379> setbit sign 1 0
(integer) 0
127.0.0.1:6379> setbit sign 2 0
(integer) 0
127.0.0.1:6379> setbit sign 3 1
(integer) 0
127.0.0.1:6379> setbit sign 4 1
(integer) 0
127.0.0.1:6379> setbit sign 5 0
(integer) 0
127.0.0.1:6379> setbit sign 6 0
(integer) 0
127.0.0.1:6379> GETBIT sign 4 # 查看某天是否打卡
(integer) 1
127.0.0.1:6379> GETBIT sign 6
(integer) 0
127.0.0.1:6379> BITCOUNT sign # 计数打卡天数
(integer) 3
127.0.0.1:6379>

事务

Redis 事务本质：一组命令的集合
一个事务中所有命令都会被序列化，在事务执行过程中，命令会按照顺序执行
一次性、顺序性、排他性执行一系列命令

---------- 队列
set
set
set
----------

Redis 事务没有隔离级别的概念，所有的命令在事务中，并没有直接被执行，只有发起执行命令的时候才会去执行

Redis 单条命令是保证原子性的，但 Redis 事务不保证原子性

Redis 事务：

开启事务（multi）

命令入队

执行事务（exec）

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> get k2
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> EXEC
1) OK
2) OK
3) "v2"
4) OK
127.0.0.1:6379>

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> set k4 v4
QUEUED
127.0.0.1:6379(TX)> DISCARD # 放弃事务
OK
127.0.0.1:6379> get k4
(nil)
127.0.0.1:6379>

编译型异常（代码有问题，命令有错误）：事务中所有命令不会被执行

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> getset k3 # 错误的命令
(error) ERR wrong number of arguments for 'getset' command
127.0.0.1:6379(TX)> set k4 v4
QUEUED
127.0.0.1:6379(TX)> EXEC
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> get k4 # 所有命令都不会被执行
(nil)

运行时异常（1 / 0），如果事务队列中存在语法错误，执行命令的时候其他命令可以正常执行

127.0.0.1:6379> set k1 v1
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> INCR k1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> get k3
QUEUED
127.0.0.1:6379(TX)> EXEC
1) (error) ERR value is not an integer or out of range
2) OK
3) OK
4) "v3"
127.0.0.1:6379>

监控

悲观锁

认为什么时候都会出问题，无论做什么都加锁

乐观锁

认为什么时候都不会出问题，所以不会上锁，更新数据的时候判断在此期间是否有人修改过这个数据

Redis 监视测试

# 正常执行成功
127.0.0.1:6379> set money 100
OK
127.0.0.1:6379> set out 0
OK
127.0.0.1:6379> watch money # 监视 money
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> DECRBY money 20
QUEUED
127.0.0.1:6379(TX)> INCRBY out 20
QUEUED
127.0.0.1:6379(TX)> EXEC
1) (integer) 80
2) (integer) 20
127.0.0.1:6379>

# 客户端 1
# watch 可以当作 乐观锁
127.0.0.1:6379> watch money
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> DECRBY money 10
QUEUED
127.0.0.1:6379(TX)> INCRBY out 10
QUEUED
127.0.0.1:6379(TX)> EXEC
(nil)

# 客户端 2
127.0.0.1:6379> get money
"80"
127.0.0.1:6379> set money 1000 # 事务执行前改动数据
OK
127.0.0.1:6379>

# 失败后的操作
127.0.0.1:6379> watch money # 获取新的值，再次监视
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> DECRBY money 10
QUEUED
127.0.0.1:6379(TX)> INCRBY out 10
QUEUED
127.0.0.1:6379(TX)> EXEC
1) (integer) 990
2) (integer) 30
127.0.0.1:6379>

Jredis

导入依赖

    <dependencies>
        <dependency>
            <groupId>redis.clientsgroupId>
            <artifactId>jedisartifactId>
            <version>3.2.0version>
        dependency>

        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>fastjsonartifactId>
            <version>1.2.76version>
        dependency>
    dependencies>

编码测试

连接数据库

操作命令

断开连接

连接远程：

redis.conf 修改配置 daemonize yes

redis.conf 修改配置注释 bind 127.0.0.1

redis.conf 修改配置 protected-mode no

查看防火墙对 6379 端口有没有开放（命令：firewall-cmd --query-port=6379/tcp）

如果 no 开放 6379 端口：

firewall-cmd --zone=public --add-port=6379/tcp --permanent

firewall-cmd --reload

firewall-cmd --query-port=6379/tcp（再次查看是否开放）

如果 yes ， java 测试，PONG 就说明成功了

public class TestPing {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("120.79.178.225", 6379);
        System.out.println(jedis.ping());
    }
}

事务

正常执行事务

public class TestTX {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("120.79.178.225", 6379);
        System.out.println(jedis.ping());

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello", "world");
        jsonObject.put("name", "jarvis");
        String s = jsonObject.toJSONString();

        // 开启事务
        Transaction multi = jedis.multi();

        try {
            multi.set("user1", s);
            multi.set("user2", s);
            multi.exec();// 执行事务
        } catch (Exception e) {
            multi.discard();// 放弃事务
            e.printStackTrace();
        } finally {
            System.out.println(jedis.get("user1"));
            System.out.println(jedis.get("user2"));
            jedis.close();
        }
    }
}

事务执行失败（存在错误就放弃事务）

public class TestTX {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("120.79.178.225", 6379);
        System.out.println(jedis.ping());

        jedis.flushDB();

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello", "world");
        jsonObject.put("name", "jarvis");
        String s = jsonObject.toJSONString();

        // 开启事务
        Transaction multi = jedis.multi();

        try {
            multi.set("user1", s);
            multi.set("user2", s);
            int i = 1 / 0;
            multi.exec();// 执行事务
        } catch (Exception e) {
            multi.discard();// 放弃事务
            e.printStackTrace();
        } finally {
            System.out.println(jedis.get("user1"));
            System.out.println(jedis.get("user2"));
            jedis.close();
        }
    }
}

Spring Boot 整合

Spring Data 是和 Spring Boot 齐名的项目

在 Spring Boot 2.X 后，原来使用的 Jedis 被替换为了 Luttuce（2.4.X 两个都有）

Jedis：采用的直连，多个线程操作的话，是不安全的，如果想要避免，得使用 jedis pool 连接池，更像 BIO 模式

Lettuce：采用 netty ，实例可以在多个线程中进行共享，不存在线程不安全的情况，减少线程数量，更像 NIO 模式

测试

@SpringBootTest
class Redis02SpringbootApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        redisTemplate.opsForValue().set("name", "jarvis");
        System.out.println(redisTemplate.opsForValue().get("name"));
    }

}

对象（需要被序列化）

@Component
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    private String name;
    private int age;
}

@SpringBootTest
class Redis02SpringbootApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() throws JsonProcessingException {
        // 真实开发一般使用 JSON 传递对象
        User user = new User("Jarvis", 3);
//        String jsonUser = new ObjectMapper().writeValueAsString(user);
//        redisTemplate.opsForValue().set("user", jsonUser);
        redisTemplate.opsForValue().set("user", user);
        System.out.println(redisTemplate.opsForValue().get("user"));
    }
}

自定义 RedisTemplate

@Configuration
public class RedisConfig {

    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();

        template.setConnectionFactory(connectionFactory);
        //自定义Jackson序列化配置
        Jackson2JsonRedisSerializer jsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, DefaultTyping.NON_FINAL);
        jsonRedisSerializer.setObjectMapper(objectMapper);

        //key使用String的序列化方式
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        //hash的key也是用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        //value的key使用jackson的序列化方式
        template.setValueSerializer(jsonRedisSerializer);
        //hash的value也是用jackson的序列化方式
        template.setHashValueSerializer(jsonRedisSerializer);
        template.afterPropertiesSet();

        return template;

    }
}

使用自定义 RedisTemplate 后：

127.0.0.1:6379> keys *
1) "user"
127.0.0.1:6379> get user
"[\"com.jarvis.pojo.User\",{\"name\":\"Jarvis\",\"age\":3}]"
127.0.0.1:6379>

Redis 工具类

链接：https://www.cnblogs.com/zhzhlong/p/11434284.html

Redis.conf 详解

单位

包含（类似 Spring 中 import）

网络

# 注释掉，如果要远程连接
# bind 127.0.0.1
# yes 改为 no，如果要远程连接
protected-mode no
# 设置端口
port 6379

通用

# 以守护线程的方式运行 yes（默认 no）
daemonize yes

# 如果以守护线程的方式运行，就需要指定一个 pid 文件
pidfile /www/server/redis/redis.pid

# 日志
# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably)
# warning (only very important / critical messages are logged)
loglevel notice

# 日志文件
logfile "/www/server/redis/redis.log"

# 数据库数量（默认 16）
databases 16

# 是否总是显示 Redis 的 logo
always-show-logo yes

快照 SNAPSHOTTING

在规定时间内执行了多少次操作，就会持久化到文件 .rdb .aof

Redis 是内存数据库，没有持久化，数据就断电即失

# 如果 900s 内，如果至少有 1 个 key进行了修改，就进行持久化操作
save 900 1
# 如果 300s 内，如果至少有 10 个 key进行了修改，就进行持久化操作
save 300 10
# 如果 60s 内，如果至少有 10000 个 key进行了修改，就进行持久化操作
save 60 10000

# 持久化如果出错，是否要继续工作
stop-writes-on-bgsave-error yes
# 是否压缩 rdb 文件，需要消耗一定的 CPU
rdbcompression yes
# 保存 rdb 文件时校验
rdbchecksum yes
# rdb 文件保存的目录
dir /www/server/redis/

复制 REPLICATION（后面主从复制讲）

安全 SECURITY

# 设置密码 默认没密码
config set requirepass

CLIENTS

# 限制最大客户端数 10000
# maxclients 10000

MEMORY MANAGEMENT

# 设置最大的内存容量
# maxmemory 
# 内存到达上限以后的处理策略
# maxmemory-policy noeviction

APPEND ONLY MODE （aof 配置）

# 默认不开启 aof 模式（默认使用 rdb 持久化，大部分情况下，rdb 够用了）
appendonly no
# 持久化文件的名字
appendfilename "appendonly.aof"

# appendfsync always
appendfsync everysec # 每秒执行一次 sync ，可能会丢失这 1s 的数据
# appendfsync no

Redis 持久化

RDB（Redis DataBase）

# The filename where to dump the DB
dbfilename dump.rdb

AOF（Append Only File）

未完…

你可能感兴趣的:(Redis,redis)

Redis和MySQL的数据一致性问题思考爱放火的安小妮 Redis MySQL 思考总结 redis mysql 数据库
Redis和MySQL的数据一致性问题思考最近有在反思自己工作。因为自己这边是面向业务的，而且是和商品数据相关的。所以我平时工作中涉及到的最多的就是MySQL和Redis的数据存储。像我们配置商品是把商品配置到MySQL，但是对外toC接口都是直接读取Redis的。所以自然而然就涉及到MySQL和Redis的数据一致性问题。下面就是聊聊我自己对于这个问题的一个思考吧。有问题或者有更好方案的朋友也希
docker怎么端口映射 Lance_mu docker 容器运维
1、默认固定的端口#Web服务器：WebApache或Nginx通常使用80端口HTTP：80HTTPS：443#数据库服务器MySQL：3306PostgreSQL：5432MongoDB：27017Redis：6379#邮件服务器SMTP：25POP3：110IMAP：143#其他服务SSH：22FTP：21DNS（域名解析）：53代理服务器Squid：3128版本控制系统Git：9418(S
Python | Redis工具类 -拟墨画扇- Python redis 数据库缓存 python
一、需求自动连接Redis数据库，通过连接池处理数据对输出结果进行Log打印并保存到文件二、代码Utils.redisUtils.py#!/usr/bin/envpython#-*-coding:utf-8-*-importredisfromUtils.loggerimportlog"""Redis数据格式(1)字符串|存储形式:key-value:str-存储二进制数据:可以存储任意类型的数据，
Redis分布式锁—SETNX+Lua脚本实现 Sahm5k java redis 分布式 lua
使用redis实现分布式锁，就是利用redis中的setnx，如果key不存在则进行set操作返回1，key已经存在则直接返回0。优点：设置expiretime过期时间，可以避免程序宕机长期持有锁不释放。redis作为一个中间服务，所有微服务都可见，满足分布式的需求。只需redis中原生setnx命令即可构建，实现简单。性能高效，redis数据在内存中。高可用，可以部署redis集群。加锁在red
【二】【设计模式】建造者模式妖精七七_ 设计模式设计模式建造者模式
建造者模式的引入//C10_1.cpp#include#include"SystemConfig.h"intmain(){SystemConfigconfig("mysql://127.0.0.1/","xiaomu","xiaomumemeda","redis://127.0.0.1/","xiaomuredis","xiaomuredispw","kafka://127.0.0.1","xia
Redis+Lua脚本实现分布式服务的限流 henry_2016 Redis 分布式 redis lua
背景限流的目的是通过对并发访问/请求进行限速或者一个时间窗口内的的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务。开始打算使用GuavaRateLimiter来实现限流，但RateLimiter是局限于单机中使用，然后打算使用Redis+Lua脚本实现限流。1提供调用的接口@Slf4j@RestController@RequestMapping("/rateLimter")publiccl
redis key中的“{}“是啥玩意不腾 redis 数据库
背景有一天,在代码中执行redis的rename命令的时候，突然返回了这个错误(error)CROSSSLOTKeysinrequestdon'thashtothesameslot这个错误的意思是：rename前的key和rename后的key不在同一个slot。我们知道，在redis集群中，有16384个Slot槽位，每个redis实例负责一部分槽。redis会根据key的hash计算出这个ke
浅学redis 撷思、 2024 数据库 redis
一、持久化1.为什么需要持久化？如果不将内存中的数据保存到磁盘，那么一旦服务器进程退出，服务器中数据也会消失，所以redis提供了持久化功能2.RDB（redisdatabase）redis配置中，默认使用RDB进行持久化。rdb保存的是dump.rdb文件。在指定时间间隔内，将内存中的数据快照写入磁盘，恢复时将快照文件存储到内存临时文件中，再次使用这个临时文件时，redis会单独创建(fork)
高可用系统有哪些设计原则没有女朋友的程序员架构师架构
1.降级主动降级：开关推送被动降级：超时降级异常降级失败率熔断保护多级降级2.限流nginx的limit模块gatewayredis+Lua业务层限流本地限流gua分布式限流sentinel3.弹性计算弹性伸缩—K8S+docker主链路压力过大的时候可以将非主链路的机器给主链路的应用用上4.流量切换多机房环境：DNS端域名切换入口Clien端流量调度虚IPHaProxyLVS负载均衡应用层Ngi
集群方式下的java Redis锁 lua脚本成长之旅后端 java
下面说一下集群方式redis下的原子锁带超时时间java代码如下：Listkeys=Collections.singletonList("test_key1");System.out.println("打印前：："+jedisCluster.get("test_key1"));//获取lua脚本这里你可以所以我是放在META-INF/scripts/redis/test.lua路径下，//获取到之
Redis 教程系列之Redis 数据备份与恢复(五) xiaoli8748_软件开发 redis 数据库缓存
RedisSAVE命令用于创建当前数据库的备份。语法redisSave命令基本语法如下：redis127.0.0.1:6379>SAVE实例redis127.0.0.1:6379>SAVEOK该命令将在redis安装目录中创建dump.rdb文件。恢复数据如果需要恢复数据，只需将备份文件(dump.rdb)移动到redis安装目录并启动服务即可。获取redis目录可以使用CONFIG命令，如下所示
Redis是如何避免“数组+链表”的过长问题龙大. Redis redis 散列表数据库
目录一、扩展和收缩二、使用高质量的哈希函数三、使用跳跃表（skiplist）或其他数据结构四、哈希表分片一、扩展和收缩Redis通过动态调整哈希表的大小来解决“数组+链表”的长度问题，这涉及到两个过程：扩展(Expand)和收缩(Shrink)。扩展:当哈希表的负载因子(loadfactor)超过一个阈值时，Redis会进行扩展操作。负载因子是哈希表已存储的元素数量与哈希表大小的比值。扩展操作包括
Redis基础命令集详解——新手入门必备 Jz_Stu Redis redis
Redis基础命令集详解——新手入门必备文章目录Redis基础命令集详解——新手入门必备前言一、Redis安装与连接二、Redis数据类型及基本命令1、String（字符串）2、List（列表）可模拟双向列表（左进右出|右进左出）和栈（左进左出|右进右出）3、Set（集合）4、Hash（哈希）5、SortedSet（有序集合）6、其他功能性命令三、事务与批量操作总结前言Redis（RemoteDi
阿里云数据库产品活动：RDS MySQL 9.9元抢购，千元代金券免费领阿里云最新优惠和活动汇总
近日，阿里云推出云数据库产品活动，RDSMySQL9.9元抢购，千元代金券免费领，爆款规格6.5折起不限量购买，活动涵盖了云数据库MySQL、云数据库Redis、云数据库SQLserver、云数据库PostgreSQL11等众多数据库类产品。活动直达：点此进入阿里云数据库产品活动云数据库RDSMySQL基础版：1核1G存储50GB，秒杀价9.90/年起；云数据库RDSMySQL基础版：1核2G50
春招面试高频题目总结小杰312 面试笔试面试 c++职场和发展学习
面试问题redis可以用于进程间通信吗？Why？How?--->延展一下有哪些进程间通信技术,优劣如何？有大量的插入sql语句，一条条的插入性能很差，如何通过事务进行优化？保证线程安全的策略有哪些？你知道哪些设计模式？有什么理解？单例、工厂方法、责任链、模板方法、策略模式都是基类抽象固定方法。子类提供具体实现。如何实现服务端与客户端的即时通讯？消息队列如何保证这个消息一定执行？不会丢失？持久化消息
面试复盘（北京某小公司）无所畏惧的man 面经面试职场和发展
北京某小公司一面复盘先和面试官做了自我介绍，然后他问了我的一些基本情况。然后开始问项目问：谈一谈项目中有哪些亮点？我用redis来做验证码的缓存，当用户登录时，刷新得到验证码，验证码会被放到redis当中，key为生成的随机字符串，value即为言验证码内容，在cookie当中也会存储这个字符串，当用户提交表单时，后端会取到cookie的值，然后从reids缓存中根据key取到验证码的值进行判断即
如何在Spring Boot应用中高效集成Spring Cache与Redis实现高性能缓存机制 yangqjiayou spring 缓存 spring boot
一、引言在现代Web应用程序开发中，缓存是一种常见的优化手段，能够显著提升系统性能，减轻数据库负载。SpringCache作为Spring框架内建的缓存抽象层，提供了一种简单易用的方式来统一处理缓存逻辑。而Redis作为一种高性能的内存键值存储系统，经常被选作SpringCache的后端存储。本文将通过一个真实的项目实例，详细介绍SpringCache的使用方法及其与Redis的集成过程。二、Sp
Redis命令之CLUSTER DELSLOTS 一条IT
CLUSTERDELSLOTSslot[slot...]起始版本：3.0.0时间复杂度：O(N)whereNisthetotalnumberofhashslotarguments在RedisCluster中，每个节点都会知道哪些主节点正在负责哪些特定的哈希槽DELSLOTS命令使一个特定的RedisCluster节点去忘记一个主节点正在负责的哈希槽，这些哈希槽通过参数指定。在已经接收到DELSLO
Go 简单设计和实现可扩展、高性能的泛型本地缓存程序员榕叔 go
相信大家对于缓存这个词都不陌生，但凡追求高性能的业务场景，一般都会使用缓存，它可以提高数据的检索速度，减少数据库的压力。缓存大体分为两类：本地缓存和分布式缓存（如Redis）。本地缓存适用于单机环境下，而分布式缓存适用于分布式环境下。在实际的业务场景中，这两种缓存方式常常被结合使用，以利用各自的优势，实现高性能的数据读取。本文将会探讨如何极简设计并实现一个可扩展、高性能的本地缓存。设计总览在设计一
Redis常见问题爱码的嘉 Redis redis 数据库缓存
1、什么是redis？Redis是C语言开发的一个开源的高性能键值对（key-value）的内存数据库，可以用作数据库、缓存、消息中间件等。它是一种NoSQL的数据库。性能优秀，数据在内存中，读写速度非常快，支持并发10WQPS。单进程单线程，是线程安全的，采用IO多路复用机制。丰富的数据类型，支持字符串、散列、列表、集合、有序集合等。支持数据持久化。可以将内存中数据保存在磁盘中，重启时加载。主从
认识redis Gitshile redis
认识redis认识redis1、什么是redis?2、redis能干什么3、Linux环境下的安装redis的基本操作命令redis的知识4、redis的五大基本类型Redis-keyString（字符串）List（列表）Set（集合）Hash（哈希）Zset（有序集合）5、redis三种特殊数据类型Hyperloglog(基数统计)什么是基数?优点方法Geospatial(地理位置)1.相关命令
Docker介绍与使用叶域 docker linux
Docker介绍与使用目录：一、Docker介绍1、Docker概述与安装2、Docker三要素二、Docker常用命令的使用1、镜像相关命令2、容器相关命令三、Docker实战之下载mysql、redis、zimg一、Docker介绍Docker是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的操作系统的机器上，也能实现虚拟化。1、Docke
Redis-发布与订阅凌睿马 Redis redis 数据库缓存
Redis的发布与订阅功能可以让客户端通过广播方式，将消息（message）同时发送给可能存在的多个客户端，并且发送消息的客户端不需要知道接收消息的客户端的具体信息。换句话说，发布消息的客户端与接收消息的客户端两者之间没有直接联系。1PUBLISH：向频道发送消息用户可以通过执行PUBLISH命令，将一条消息发送至给定频道：PUBLISHchannelmessage2SUBSCRIBE：订阅频道用
Redis 的数据类型及使用场景程序员JavaWind redis 数据库缓存
String最常规的set/get操作，Value可以是String也可以是数字。一般做一些复杂的计数功能的缓存。Hash这里Value存放的是结构化的对象，比较方便的就是操作其中的某个字段。我在做单点登录的时候，就是用这种数据结构存储用户信息，以CookieId作为Key，设置30分钟为缓存过期时间，能很好的模拟出类似Session的效果。List使用List的数据结构，可以做简单的消息队列的功
Redis缓存的一些知识点程序员JavaWind 缓存 redis 数据库
会导致Redis阻塞的情况：Redis产生阻塞的原因主要有内部和外部两个原因导致：内部原因如果Redis主机的CPU负载过高，也会导致系统崩溃；数据持久化占用资源过多；对Redis的API或指令使用不合理，导致Redis出现问题。外部原因外部原因主要是服务器的原因，例如服务器的CPU线程在切换过程中竞争过大，内存出现问题、网络问题等。有大量的key需要设置同一时间过期如何处理：如果有大量的key在
凌鲨微应用API大全凌鲨前端
@linksaas-minapp/api获取微应用信息exportinterfaceMinAppInfo{userId:string;//用户ID(未登录为空字符串)userDisplayName:string;crossHttp:boolean;//打开redis代理时会设置redisProxyToken?:string;redisProxyAddr?:string;//打开mongo代理时会设
22.4 docker 与海boy Java工程师(后端开发)docker 容器运维
22.4docker1.docker简介2.docker架构3.容器和仓库4.Docker安装:基于Linux5.docker容器生成与运行5.1docker换源5.2启动容器5.3dockersearch6.docker基于redis演示6.1run-i-t:终端运行redis容器(不推荐)6.2访问docker正在运行容器6.3-d:后台运行redis容器6.4停止容器
Redis 哨兵集群如何实现高可用？（2） fighting哥缓存 java 数据库 redis 缓存
目录7.slave配置的自动纠正8.slave->master选举算法9.quorum和majority10.configurationepoch11.configuration传播7.slave配置的自动纠正哨兵会负责自动纠正slave的一些配置，比如slave如果要成为潜在的master候选人，哨兵会确保slave复制现有master的数据;如果slave连接到了一个错误的master上，比如
Redis 订阅发布(Pub/Sub) 详解如何使用订阅发布交集是空集 redis 缓存运维数据库
Pub/Sub(发布订阅)Redis的发布订阅（Pub/Sub）是一种消息传递模式，它允许消息的发送者（发布者）将消息发送到通道，而订阅者则可以订阅一个或多个通道，并接收发布者发送到这些通道的消息。发布订阅模式在实时通信和消息传递系统中非常有用，它可以用于构建聊天应用、实时数据更新、事件通知等场景。以下是Redis发布订阅功能的主要特点和用法：通道（Channel）：发布订阅模式通过通道进行消息传
Docker——Redis部署梦想的边缘运维 redis docker
Redis通过Docker容器化部署流程1.创建容器dockerrun-d--nameredis--restart=always-p6379:6379redis:5.0.14-alpine备注：redis版本选取5.0.14版本，端口号默认为6379执行成功的结果：[root@node1~]#dockerrun-d--nameredis--restart=always-p6379:6379redi
二分查找排序算法周凡杨 java 二分查找排序算法折半
一：概念二分查找又称折半查找（折半搜索/ 二分搜索），优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步
java中的BigDecimal bijian1013 java BigDecimal
在项目开发过程中出现精度丢失问题，查资料用BigDecimal解决，并发现如下这篇BigDecimal的解决问题的思路和方法很值得学习，特转载。原文地址：http://blog.csdn.net/ugg/article/de
Shell echo命令详解 daizj echo shell
Shell echo命令 Shell 的 echo 指令与 PHP 的 echo 指令类似，都是用于字符串的输出。命令格式： echo string 您可以使用echo实现更复杂的输出格式控制。 1.显示普通字符串: echo "It is a test" 这里的双引号完全可以省略，以下命令与上面实例效果一致： echo Itis a test 2.显示转义
Oracle DBA 简单操作周凡杨 oracle dba sql
--执行次数多的SQL select sql_text,executions from ( select sql_text,executions from v$sqlarea order by executions desc ) where rownum<81; &nb
画图重绘朱辉辉33 游戏
我第一次接触重绘是编写五子棋小游戏的时候，因为游戏里的棋盘是用线绘制的，而这些东西并不在系统自带的重绘里，所以在移动窗体时，棋盘并不会重绘出来。所以我们要重写系统的重绘方法。在重写系统重绘方法时，我们要注意一定要调用父类的重绘方法，即加上super.paint(g)，因为如果不调用父类的重绘方式，重写后会把父类的重绘覆盖掉，而父类的重绘方法是绘制画布，这样就导致我们
线程之初体验西蜀石兰线程
一直觉得多线程是学Java的一个分水岭，懂多线程才算入门。之前看《编程思想》的多线程章节，看的云里雾里，知道线程类有哪几个方法，却依旧不知道线程到底是什么？书上都写线程是进程的模块，共享线程的资源，可是这跟多线程编程有毛线的关系，呜呜。。。线程其实也是用户自定义的任务，不要过多的强调线程的属性，而忽略了线程最基本的属性。你可以在线程类的run()方法中定义自己的任务，就跟正常的Ja
linux集群互相免登陆配置林鹤霄 linux
配置ssh免登陆 1、生成秘钥和公钥 ssh-keygen -t rsa 2、提示让你输入，什么都不输，三次回车之后会在~下面的.ssh文件夹中多出两个文件id_rsa 和 id_rsa.pub 其中id_rsa为秘钥，id_rsa.pub为公钥，使用公钥加密的数据只有私钥才能对这些数据解密 c
mysql : Lock wait timeout exceeded; try restarting transaction aigo mysql
原文：http://www.cnblogs.com/freeliver54/archive/2010/09/30/1839042.html 原因是你使用的InnoDB 表类型的时候, 默认参数:innodb_lock_wait_timeout设置锁等待的时间是50s, 因为有的锁等待超过了这个时间,所以抱错. 你可以把这个时间加长,或者优化存储
Socket编程基本的聊天实现。 alleni123 socket
public class Server { //用来存储所有连接上来的客户 private List<ServerThread> clients; public static void main(String[] args) { Server s = new Server(); s.startServer(9988); } publi
多线程监听器事件模式(一个简单的例子) 百合不是茶线程监听模式
多线程的事件监听器模式监听器时间模式经常与多线程使用,在多线程中如何知道我的线程正在执行那什么内容,可以通过时间监听器模式得到创建多线程的事件监听器模式思路: 1, 创建线程并启动,在创建线程的位置设置一个标记 2,创建队
spring InitializingBean接口 bijian1013 java spring
spring的事务的TransactionTemplate，其源码如下： public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations, InitializingBean{ ... } TransactionTemplate继承了DefaultT
Oracle中询表的权限被授予给了哪些用户 bijian1013 oracle 数据库权限
Oracle查询表将权限赋给了哪些用户的SQL，以备查用。 select t.table_name as "表名", t.grantee as "被授权的属组", t.owner as "对象所在的属组"
【Struts2五】Struts2 参数传值 bit1129 struts2
Struts2中参数传值的3种情况 1.请求参数绑定到Action的实例字段上 2.Action将值传递到转发的视图上 3.Action将值传递到重定向的视图上一、请求参数绑定到Action的实例字段上以及Action将值传递到转发的视图上 Struts可以自动将请求URL中的请求参数或者表单提交的参数绑定到Action定义的实例字段上，绑定的规则使用ognl表达式语言
【Kafka十四】关于auto.offset.reset[Q/A] bit1129 kafka
I got serveral questions about auto.offset.reset. This configuration parameter governs how consumer read the message from Kafka when there is no initial offset in ZooKeeper or
nginx gzip压缩配置 ronin47 nginx gzip 压缩范例
nginx gzip压缩配置更多 0 nginx gzip 配置随着nginx的发展，越来越多的网站使用nginx，因此nginx的优化变得越来越重要，今天我们来看看nginx的gzip压缩到底是怎么压缩的呢？ gzip(GNU-ZIP)是一种压缩技术。经过gzip压缩后页面大小可以变为原来的30%甚至更小，这样，用
java-13.输入一个单向链表，输出该链表中倒数第 k 个节点 bylijinnan java
two cursors. Make the first cursor go K steps first. /* * 第 13 题：题目：输入一个单向链表，输出该链表中倒数第 k 个节点 */ public void displayKthItemsBackWard(ListNode head,int k){ ListNode p1=head,p2=head;
Spring源码学习-JdbcTemplate queryForObject bylijinnan java spring
JdbcTemplate中有两个可能会混淆的queryForObject方法： 1. Object queryForObject(String sql, Object[] args, Class requiredType) 2. Object queryForObject(String sql, Object[] args, RowMapper rowMapper) 第1个方法是只查
[冰川时代]在冰川时代,我们需要什么样的技术? comsci 技术
看美国那边的气候情况....我有个感觉...是不是要进入小冰期了? 那么在小冰期里面...我们的户外活动肯定会出现很多问题...在室内呆着的情况会非常多...怎么在室内呆着而不发闷...怎么用最低的电力保证室内的温度.....这都需要技术手段... &nb
js 获取浏览器型号 cuityang js 浏览器
根据浏览器获取iphone和apk的下载地址 <!DOCTYPE html> <html> <head> <meta charset="utf-8" content="text/html"/> <meta name=
C# socks5详解转 dalan_123 socket C#
http://www.cnblogs.com/zhujiechang/archive/2008/10/21/1316308.html 这里主要讲的是用.NET实现基于Socket5下面的代理协议进行客户端的通讯，Socket4的实现是类似的，注意的事，这里不是讲用C#实现一个代理服务器，因为实现一个代理服务器需要实现很多协议，头大，而且现在市面上有很多现成的代理服务器用，性能又好，
运维 Centos问题汇总 dcj3sjt126com 云主机
一、sh 脚本不执行的原因 sh脚本不执行的原因只有2个 1.权限不够 2.sh脚本里路径没写完整。二、解决You have new mail in /var/spool/mail/root 修改/usr/share/logwatch/default.conf/logwatch.conf配置文件 MailTo = MailFrom 三、查询连接数
Yii防注入攻击笔记 dcj3sjt126com sql WEB安全 yii
网站表单有注入漏洞须对所有用户输入的内容进行个过滤和检查，可以使用正则表达式或者直接输入字符判断，大部分是只允许输入字母和数字的，其它字符度不允许；对于内容复杂表单的内容，应该对html和script的符号进行转义替换：尤其是<,>,',"",&这几个符号这里有个转义对照表： http://blog.csdn.net/xinzhu1990/articl
MongoDB简介[一] eksliang mongodb MongoDB简介
MongoDB简介转载请出自出处：http://eksliang.iteye.com/blog/2173288 1.1易于使用 MongoDB是一个面向文档的数据库，而不是关系型数据库。与关系型数据库相比，面向文档的数据库不再有行的概念，取而代之的是更为灵活的“文档”模型。另外，不
zookeeper windows 入门安装和测试 greemranqq zookeeper 安装分布式
一、序言以下是我对zookeeper 的一些理解： zookeeper 作为一个服务注册信息存储的管理工具，好吧，这样说得很抽象，我们举个“栗子”。栗子1号：假设我是一家KTV的老板，我同时拥有5家KTV，我肯定得时刻监视
Spring之使用事务缘由(2-注解实现) ihuning spring
Spring事务注解实现 1. 依赖包： 1.1 spring包： spring-beans-4.0.0.RELEASE.jar spring-context-4.0.0.
iOS App Launch Option 啸笑天 option
iOS 程序启动时总会调用application:didFinishLaunchingWithOptions:，其中第二个参数launchOptions为NSDictionary类型的对象，里面存储有此程序启动的原因。 launchOptions中的可能键值见UIApplication Class Reference的Launch Options Keys节。 1、若用户直接
jdk与jre的区别（_） macroli java jvm jdk
简单的说JDK是面向开发人员使用的SDK，它提供了Java的开发环境和运行环境。SDK是Software Development Kit 一般指软件开发包，可以包括函数库、编译程序等。 JDK就是Java Development Kit JRE是Java Runtime Enviroment是指Java的运行环境，是面向Java程序的使用者，而不是开发者。如果安装了JDK，会发同你
Updates were rejected because the tip of your current branch is behind qiaolevip 学习永无止境每天进步一点点众观千象 git
$ git push joe prod-2295-1 To [email protected]:joe.le/dr-frontend.git ! [rejected] prod-2295-1 -> prod-2295-1 (non-fast-forward) error: failed to push some refs to '[email protected]
[一起学Hive]之十四-Hive的元数据表结构详解 superlxw1234 hive hive元数据结构
关键字：Hive元数据、Hive元数据表结构之前在 “[一起学Hive]之一–Hive概述，Hive是什么”中介绍过，Hive自己维护了一套元数据，用户通过HQL查询时候，Hive首先需要结合元数据，将HQL翻译成MapReduce去执行。本文介绍一下Hive元数据中重要的一些表结构及用途，以Hive0.13为例。文章最后面，会以一个示例来全面了解一下，
Spring 3.2.14，4.1.7，4.2.RC2发布 wiselyman Spring 3
Spring 3.2.14、4.1.7及4.2.RC2于6月30日发布。其中Spring 3.2.1是一个维护版本(维护周期到2016-12-31截止)，后续会继续根据需求和bug发布维护版本。此时，Spring官方强烈建议升级Spring框架至4.1.7 或者将要发布的4.2 。其中Spring 4.1.7主要包含这些更新内容。