胖波
胖波

Redis全教程

1、redis持久化

使得redis重启后能够恢复数据（应对缓存穿透、缓存雪崩）

RDB方式（快照 ）：根据指定的规则定时将内存中的数据存储到硬盘上

AOF方式：每次执行命令后将命令本身记录下来

两种方式可结合使用（更多时候），也可单独使用

 

1.1、RDB方式(快照)

redis会在以下几种情况下对数据进行快照：

  • 根据配置规则进行自动快照
  • 用户执行save或者bgsave命令
  • 执行flushall命令
  • 执行复制（replication）时

 

1.1.1、自动快照

用户在配置文件中自定义，有两个参数：时间窗口M（秒）和改动的键的个数N，每当时间M内被更改的键的个数大于N时，即符合自动快照条件

举例（redis.windows.conf文件中的）：

save 900 1    #15分钟内有一个或一个以上的键被更改则进行快照

save 300 10

save 600 10000

可以同时存在多个条件，之间是或的关系

执行自动快照时，redis采用的策略是异步快照

 

1.1.2、用户执行save或bgsave命令

save：同步备份，会阻塞所有来自客户端的请求

bgsave：异步备份，会立即返回OK,如果想知道是否备份成功，可以使用lastsave命令获取最近一次成功执行快照的时间

 

1.1.3、用户执行flushall命令

首先，flushall会清空所有的键

当定义自动快照条件时，无论是否触发，执行flushall都会备份

当没有定义自动快照条件时，执行flushall不会备份

 

1.1.4、复制

当设置了主从模式时，既没有定义自动快照条件，也没有手动执行save命令，也会生成RDB快照文件

 

1.1.5、快照原理

dir  ./    #快照文件路径

dbfilename  dump.rdb    #快照文件名

快照过程：

  1. redis使用fork函数复制一份当前进程（父进程）的副本（子进程）所以备份的是执行fork这一时刻的内存数据
  2. 父进程继续接收处理客户端请求，子进程开始讲内存中的数据写入磁盘临时文件
  3. 当子进程写完所有数据后会将临时文件替换旧的rdb文件

当只使用RDB方式实现持久化时，一旦redis异常退出，会丢失一些键，所以要结合AOF方式

 

1.2、AOF方式

AOF可以将redis执行的每一条写命令追加到磁盘文件上，显然会降低性能，AOF默认没有开启

appendonly  yes  #开启AOF

appendfilename "appendonly.aof"    #AOF文件名

dir  ./  #AOF文件路径

 

AOF的实现：

纯文本形式，保留的是redis通信协议的原始内容（REdis Serialization Protocol，RESP协议）

AOF文件中可能有很多冗余命令，比如:

set name zhangsan

set name lisi

此时第一条命令是冗余的，当冗余命令太多会导致aof文件太多，即使内存中的数据并没有多少

消除冗余命令（重写）：
auto-aof-rewrite-percentage  100  #目前aof文件大小超过上一次重写时的aof文件大小的100%时会再次重写，如果上一次没有重写过，则依据启动时的aof文件大小为准
auto-aof-rewrite-min-size  64mb  #重写aof文件的最小大小

 

手动重写：BGREWRITEAOF命令

重写的过程只和内存中的数据有关，和之前的aof文件无关，这和RDB相似，但两个文件格式完全不同

启动redis时会逐个将aof文件中的命令从磁盘加载到内存，速度比RDB文件慢

 

AOF会将命令记录到磁盘文件中，但由于操作系统有硬盘缓存，默认情况下每30秒将缓存真正写入到磁盘中，如果这30秒系统异常退出会导致数据丢失

# appendfsync always  #总是进行同步，最慢但最安全
appendfsync everysec  #折中方案，每秒进行一次同步
# appendfsync no  #完全交由操作系统，即每30秒，最快但最不安全

当RDB和AOF同时开启时，redis重启后会使用aof文件加载数据，因为aof方式丢失的数据更少

redis是否需要持久化？

为了最大提升性能，不需要任何持久化，如果需要备份，采用集群模式

 

2、redis单线程为什么这么快

  • 纯内存操作
  • 单线程操作，避免频繁上下文切换
  • 采用IO多路复用模型
  • 纯ANSI C语言编写

2.1、linux5种IO模型

  • 同步阻塞BIO
  • 同步非阻塞NIO
  • IO多路复用
  • 事件驱动
  • 异步非阻塞AIO

2.2、NIO和IO多路复用的对比

  • NIO实际就是多路复用IO
  • 在IO多路复用模型中，会有一个线程不断去轮询多个socket的状态，只有当socket真正有读写事件时，才真正调用实际的IO读写操作
  • 在Java NIO中，是通过selector.select()去查询每个通道是否有到达事件，如果没有事件，则一直阻塞在那里，因此这种方式会导致用户线程的阻塞
  • 多路复用IO比NIO的效率高的原因：在非阻塞IO中，不断地询问socket状态时通过用户线程去进行的，每调用一次就得在用户态和核心态切换一次，而在多路复用IO中，轮询每个socket状态是内核在进行的，这个效率要比用户线程要高的多

2.3、cpu状态切换

  • 用户态：运行应用程序
  • 核心态：运行操作系统程序，操作硬件

2.4、redis线程模型

在这里插入图片描述

Redis内部实现采用epoll+自己实现的简单的事件框架。 epoll中的读、写、关闭、连接都转化成了事件，然后利用epoll的多路复用特性， 绝不在io上浪费一点时间

简单来说，就是。我们的redis-client在操作的时候，会产生具有不同事件类型的socket。在服务端，有一段I/0多路复用程序，将其置入队列之中。然后，IO事件分派器，依次去队列中取，转发到不同的事件处理器中

 

2.4.1、IO多路复用的封装

Redis全教程_第1张图片

  • select是POSIX提供的， 一般的操作系统都有支撑
  • epoll 是LINUX系统内核提供支持的
  • evport是Solaris系统内核提供支持的
  • kqueue是Mac 系统提供支持的

 

2.4.2、文件事件分派器（Reactor）

Reactor 设计模式：事件驱动循环流程
Redis 服务采用 Reactor 的方式来实现文件事件处理器（每一个网络连接其实都对应一个文件描述符） 

Redis全教程_第2张图片

用户线程注册事件处理器之后可以继续执行做其他的工作（异步），而Reactor线程负责调用内核的select/epoll函数检查socket状态。当有socket被激活时，则通知相应的用户线程（或执行用户线程的回调函数），执行handle_event进行数据读取、处理的工作。由于select/epoll函数是阻塞的，因此多路IO复用模型也被称为异步阻塞IO模型。注意，这里的所说的阻塞是指select函数执行时线程被阻塞，而不是指socket

 

 

2、redis和Memecache的区别

2.1、存储方式

Memecache把数据全部存在内存之中，断电后会挂掉，数据不能超过内存大小。 Redis有部份存在硬盘上，redis可以持久化其数据


2.2、数据支持类型

memcached所有的值均是简单的字符串，redis作为其替代者，支持更为丰富的数据类型 ，提供list，set，zset，hash等数据结构的存储

 

2.3、使用底层模型不同

它们之间底层实现方式 以及与客户端之间通信的应用协议不一样。 Redis直接自己构建了VM 机制 ，因为一般的系统调用系统函数的话，会浪费一定的时间去移动和请求

 

2.4、value 值大小不同

Redis 最大可以达到 512M；memcache 只有 1mb

 

2.5、其它

redis的速度比memcached快很多
Redis支持数据的备份，即master-slave模式的数据备份。

 

3、热点数据和冷数据

热点数据缓存才有价值

冷数据：如果缓存还没起作用就失效了，就没有意义了

热点数据分两种，频繁修改的和不频繁修改的。一般来说频繁修改的数据不适合缓存，但如果读取这个数据对数据库压力大，那也应该用缓存

3.1、什么样的数据适合缓存

Redis全教程_第3张图片

 

 

4、redis-cli命令大全

4.1、模糊查询key

keys  pattern

支持glob风格通配符

redis不区分命令大小写

Redis全教程_第4张图片

4.2、判断键是否存在

exists  key

存在则返回1，不存在返回0

4.3、删除键

del  key1  key2 ...

返回值是删除的键的个数

del不支持模糊删除,但可以这样redis-cli del 'redis-cli keys "name*"'    删除所有以name开头的key（windows下貌似不好使）

4.4、获取键的类型

type  key

4.5、连接

#连接redis服务
redis-cli -h 127.0.0.1 -p 6379

4.6、切换数据库

select 0

4.7、查询当前数据库有多少key

dbsize
 

4.8、string

字符串类型是其它四种类型的基础，因为其它四种类型的值也是字符串，只不过字符串的形式不同而已

set  key  value

get  key

mset  key1  value1  key2  value2 ...

mget  key1 key2 ... 

incr  key  #如果字符串是数字类型，就递增

incrby key value  #增加指定的数值

decr  key

decrby  key value

incrbyfloat  key  value  #增加浮点数

append  key  value  #追加

strlen  key  #获取长度

 

4.9、键命名策略

user:1:friends  存储ID为1的用户好友列表

对于多个单词则用点号（.）分隔

 

4.10、hash

redis不支持类型嵌套，比如hash类型的字段只能是string，不能是list或其他类型

hset  key  field  value  #不存在则set，存在则更新

hsetnx  key  field  value  #不存在时，才set，原子操作

hget  key  field

hmset   key  field1  value1  field2  value2  ...

hmget   key  field1  field2  ...

hgetall  key  

hexists  key  field

hdel  key  field1  field2  ...

 

hkeys  key #获取所有属性

hvals  key  #获取所有值

hlen  key  #获取属性数量

 

4.11、list

lpush  key  value1  value2  ...

rpush  key  value1  value2  ...

lpop  key  #会删除元素

lpop  key

lpush结合lpop（或rpush结合rpop）可以做栈

lllen  key  #list长度，时间复杂度为O(1) ，因为读取的是现成的值，不像mysql select count(*)会全表扫描

lrange  key  start  end  #不会删除元素，包含两端元素，支持负索引

ltrim  key  start  end  #和lrange类型，但会删除元素

lrem  key  count  value  #删除前count个值为value的元素，count>0从左删除，count<0从右删除，count=0删除所有

 

lindex  key  index  #获取指定索引的元素

lset  key  index  value  #在指定索引处插入元素

linsert  key  before|after  pivot  value  #将value插入到pivot的前面或后面

rpoplpush  src  dst  #移除src队列最右边的元素，插入到dst队列的最左边，src和dst可以相同

 

4.12、set

sadd  key  value1  value2  ...  #添加元素

srem  key  value1  value2  ...  #删除元素

SMEMBERS  key  #获取所有元素

SISMEMBER  key  value  #判断元素是否存在

集合间运算

scard  key  #获取元素个数

spop  key  #随机删除一个元素

SRANDMEMBER   key  count  #随机获取count个元素，如果不传count则随机获取一个元素

 

4.13、zset

  • list是用链表实现的，数据访问越靠两端的元素越快，适合实现新鲜事、日志这类很少访问中间元素的应用
  • 而zet是通过skiplist实现的，即使读取中间部分的元素也很快

zadd  key  score1  value1  score2  value2  ...  #添加元素，如果元素已存在则覆盖之前的分数

zscore  key  value1  #获取元素的分数

zrange  key  start  end  withscores  #先从小到大排序，再返回start到end之间的元素，传入withscores会返回分数

zrevrange  key  start  end  withscores  #从大到小排序

ZINCRBY  key  score  value  #给元素加分

zrangebyscore  key  min  max withscores  limit  offset  count  #获取指定分数范围内的元素，min和max默认包含，(80表示不包含，-inf、+inf分别表示负无穷、正无穷

zrevrangebyscore  #从大到小排序，注意min和max也是反的

zcard  key  #获取元素数量

zcount  key  min  max  #获取指定分数范围内的元素个数

zrank  key  value  #获取元素排名

zrevrank  key  value  #从大到小排序，获取元素排名

 

 

5、redis键的过期策略

5.1、过期时间命令

expire  key  seconds  #单位是秒,pexpire命令可设置成毫秒

ttl  key  #查看键还有多久过期，pttl显示毫秒时间

persist  key  #清除过期时间设置，set|getset也可以清除过期时间

 

5.2、过期删除策略

5.2.1、定时删除策略（不采用）

用一个定时器来负责监视key,过期则自动删除，虽然内存及时释放，但是十分消耗CPU资源

在大并发请求下，CPU要将时间应用在处理请求，而不是删除key

 

5.2.2、定期删除+惰性删除策略（采用）

定期删除，redis默认每个100ms检查，是否有过期的key,有过期key则删除。需要说明的是，redis不是每个100ms将所有的key检查一次，而是随机抽取进行检查(如果每隔100ms,全部key进行检查，redis岂不是卡死)。因此，如果只采用定期删除策略，会导致很多key到时间没有删除。
于是，惰性删除派上用场。也就是说在你获取某个key的时候，redis会检查一下，这个key如果设置了过期时间那么是否过期了？如果过期了此时就会删除

如果定期删除没删除key。然后你也没即时去请求key，也就是说惰性删除也没生效。这样，redis的内存会越来越高。那么就应该采用内存淘汰机制

 

5.2.3、内存淘汰机制

maxmemory  100mb  #为0时代表没有内存限制

maxmemory-policy  noenviction

volatile-lru：从已设置过期时间的数据集（server.db[i].expires）中挑选最近最少使用的数据淘汰
volatile-ttl：从已设置过期时间的数据集（server.db[i].expires）中挑选将要过期的数据淘汰
volatile-random：从已设置过期时间的数据集（server.db[i].expires）中任意选择数据淘汰
allkeys-lru：从数据集（server.db[i].dict）中挑选最近最少使用的数据淘汰
allkeys-random：从数据集（server.db[i].dict）中任意选择数据淘汰
noenviction（驱逐）：禁止驱逐数据，新写入操作会报错

如果没有设置 expire 的key, 不满足先决条件(prerequisites); 那么 volatile-lru, volatile-random 和 volatile-ttl 策略的行为, 和 noeviction(不删除) 基本上一致

 

回收进程如何工作：

  • 一个客户端运行了新的命令，添加了新的数据。
  • Redi检查内存使用情况，如果大于maxmemory的限制, 则根据设定好的策略进行回收

redis使用的是近似LRU算法（并非真实的，因为真实LRU算法太耗内存）

maxmemory-samples  5  #LRU算法的采样数量，可以提升到10来让LRU算法更真实，但会消耗更多的CPU时间

 

 

6、缓存雪崩、缓存穿透、缓存击穿

6.1、缓存雪崩

可以简单理解为：原有缓存失效，新缓存未到期

例如：我们设置缓存时采用了相同的过期时间，在同一时刻出现大面积的缓存过期)，所有原本应该访问缓存的请求都去查询数据库了，而对数据库CPU和内存造成巨大压力，严重的会造成数据库宕机。从而形成一系列连锁反应，造成整个系统崩溃
 

解决办法：
1、大多数系统设计者考虑用加锁（ 最多的解决方案）或者队列的方式来保证不会有大量的线程对数据库一次性进行读写，从而避免缓存失效时大量的并发请求落到底层存储系统上

2、还有一个简单方案就是将缓存失效时间分散开

 

6.2、缓存穿透

缓存穿透是指用户查询数据，在数据库没有，自然在缓存中也不会有。这样就导致用户查询的时候，在缓存中找不到，每次都要去数据库再查询一遍，然后返回空（相当于进行了两次无用的查询）

这时的用户很可能是攻击者，攻击会导致数据库压力过大

 

解决方法：

1、如果一个查询返回的数据为空（不管是数据不存在，还是系统故障），我们仍然把这个空结果进行缓存，但它的过期时间会很短，最长不超过五分钟。通过这个直接设置的默认值存放到缓存，这样第二次到缓冲中获取就有值了，而不会继续访问数据库，这种办法最简单粗暴

2、布隆过滤器 

参考博文

 

6.3、缓存击穿

缓存击穿实际上是缓存雪崩的一个特例

缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力

击穿与雪崩的区别在于击穿是对于某一特定的热点数据来说，而雪崩是全部数据

 

解决办法：

1、加锁

static Lock reenLock = new ReentrantLock();

    public List getData04() throws InterruptedException {
        List result = new ArrayList();
        // 从缓存读取数据
        result = getDataFromCache();
        if (result.isEmpty()) {
            if (reenLock.tryLock()) {
                try {
                    System.out.println("我拿到锁了,从DB获取数据库后写入缓存");
                    // 从数据库查询数据
                    result = getDataFromDB();
                    // 将查询到的数据写入缓存
                    setDataToCache(result);
                } finally {
                    reenLock.unlock();// 释放锁
                }

            } else {
                result = getDataFromCache();// 先查一下缓存
                if (result.isEmpty()) {
                    System.out.println("我没拿到锁,缓存也没数据,先小憩一下");
                    Thread.sleep(100);// 小憩一会儿
                    return getData04();// 重试
                }
            }
        }
        return result;
    }

2、定时任务主动刷新缓存

 

6.4、缓存预热


缓存预热就是系统上线后，将相关的缓存数据直接加载到缓存系统。这样就可以避免在用户请求的时候，先查询数据库，然后再将数据缓存的问题！用户直接查询事先被预热的缓存数据！

解决方法：
1、直接写个缓存刷新页面，上线时手工操作下
2、数据量不大，可以在项目启动的时候自动进行加载
3、定时刷新缓存

 

6.5、缓存降级

当访问量剧增、服务出现问题（如响应时间慢或不响应）或非核心服务影响到核心流程的性能时，仍然需要保证服务还是可用的，即使是有损服务。系统可以根据一些关键数据进行自动降级，也可以配置开关实现人工降级。

降级的最终目的是保证核心服务可用，即使是有损的。而且有些服务是无法降级的（如加入购物车、结算）。

在进行降级之前要对系统进行梳理，看看系统是不是可以丢卒保帅；从而梳理出哪些必须誓死保护，哪些可降级

 

 

7、Redis 常见性能问题和解决方案？

(1) Master 最好不要做任何持久化工作，如 RDB 内存快照和 AOF 日志文件
(2) 如果数据比较重要，某个 Slave 开启 AOF 备份数据，策略设置为每秒同步一次
(3) 为了主从复制的速度和连接的稳定性， Master 和 Slave 最好在同一个局域网内
(4) 尽量避免在压力很大的主库上增加从库
(5) 主从复制不要用图状结构，用单向链表结构更为稳定，即： Master <- Slave1 <- Slave2 <-Slave3…

 

8、为什么Redis的操作是原子性的，怎么保证原子性的？

对于Redis而言，命令的原子性指的是：一个操作的不可以再分，操作要么执行，要么不执行。
Redis的操作之所以是原子性的，是因为Redis是单线程的。
Redis本身提供的所有API（单个命令）都是原子操作，Redis中的事务其实是要保证批量操作的原子性。

多个命令在并发中也是原子性的吗？
不一定， 举例：1、将get和set改成单命令操作；2、incr

如何解决：使用Redis的事务，或者使用Redis+Lua的方式实现

 

9、redis分布式锁

9.1、分布式锁需要解锁的问题：

  • 互斥性：任意时刻只能有一个客户端拥有锁，不能同时多个客户端获取
  • 安全性：锁只能被持有该锁的用户删除，而不能被其他用户删除 （推荐学习：Redis视频教程）
  • 死锁：获取锁的客户端因为某些原因而宕机，而未能释放锁，其他客户端无法获取此锁，需要有机制来避免该类问题的发生
  • 容错：当部分节点宕机，客户端仍能获取锁或者释放锁


 

9.2、springboot整合redis并实现分布式锁实战

9.2.1、pom文件


		
			org.springframework.boot
			spring-boot-starter-data-redis

 

9.2.2、application.yml

spring:
  redis:
    host: localhost
    port: 6379
    timeout: 10000
    database: 0

 

9.2.3、RedisConfig

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;


@Configuration
public class RedisConfig {

    @Bean(name = "template")
    public RedisTemplate template(RedisConnectionFactory factory) {
        // 创建RedisTemplate对象
        RedisTemplate template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(factory);
        // 定义Jackson2JsonRedisSerializer序列化对象
        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.CREATOR, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会报异常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSeial.setObjectMapper(om);
        StringRedisSerializer stringSerial = new StringRedisSerializer();
        // redis key 序列化方式使用stringSerial
        template.setKeySerializer(stringSerial);
        // redis value 序列化方式使用jackson
        template.setValueSerializer(jacksonSeial);
        // redis hash key 序列化方式使用stringSerial
        template.setHashKeySerializer(stringSerial);
        // redis hash value 序列化方式使用jackson
        template.setHashValueSerializer(jacksonSeial);
        template.afterPropertiesSet();
        return template;
    }

    /*@Bean
    public CacheManager cacheManager(RedisTemplate template) {
        RedisCacheConfiguration defaultCacheConfiguration =
                RedisCacheConfiguration
                        .defaultCacheConfig()
                        // 设置key为String
                        .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(template.getStringSerializer()))
                        // 设置value 为自动转Json的Object
                        .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(template.getValueSerializer()))
                        // 不缓存null
                        .disableCachingNullValues()
                        // 缓存数据保存1小时
                        .entryTtl(Duration.ofDays(30));

        RedisCacheManager redisCacheManager =
                RedisCacheManager.RedisCacheManagerBuilder
                        // Redis 连接工厂
                        .fromConnectionFactory(template.getConnectionFactory())
                        // 缓存配置
                        .cacheDefaults(defaultCacheConfiguration)
                        // 配置同步修改或删除 put/evict
                        .transactionAware()
                        .build();
        return redisCacheManager;
    }

*/
} 
  
 
 
  
9.2.4、redis分布式锁同步类
 
  
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.types.Expiration;

public class ForRedisLock {
    private RedisTemplate redisTemplate;
    private int a;
    private static final String KEY = "redis_lock";

    public void add(){

        while(true){
            Boolean isGet = redisTemplate.execute(new RedisCallback() {
                @Override
                public Boolean doInRedis(RedisConnection conn) throws DataAccessException {
                    //解决死锁（某个线程获取到锁之后未能释放锁）的两种办法：
                    //1、设置过期时间，主动释放锁----conn的具有四个形参的set方法，同样具有setNX的作用
                    //2、使用setnx key "当前系统时间+锁持有的时间"和getset key "当前系统时间+锁持有的时间"组合的命令实现----conn的setNX方法

                    Boolean isGet = conn.set(KEY.getBytes(), "iamlock".getBytes(), Expiration.seconds(60), RedisStringCommands.SetOption.ifAbsent());
                    return isGet;
                }
            });
            if(isGet){
                a++;
                //解锁
                redisTemplate.delete(KEY);
                break;
            }
        }

    }

    public void addNoLock(){
        a++;
    }

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public RedisTemplate getRedisTemplate() {
        return redisTemplate;
    }

    public void setRedisTemplate(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
}

 
  
 
 
  
9.2.5、controller
 
  
import com.asiainfo.com.springboottest.util.ForRedisLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.types.Expiration;
import org.springframework.scheduling.annotation.Async;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
public class RedisLockController {

    @Autowired
    private RedisTemplate redisTemplate;
    private static final String KEY = "redis_lock";

    @RequestMapping("/lock")
    @Async
    public void lock(){
        ForRedisLock lock = new ForRedisLock();
        lock.setRedisTemplate(redisTemplate);

        //单机演示redis分布式锁时，将数值从0加到3000简直太慢了，线程不要超过3000，太大了直接运行不起来
        for (int i = 0; i < 3000; i++) {
            new Thread(()->{
                lock.add();
                //lock.addNoLock();
            }).start();
        }
        while(true){
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(lock.getA());
        }
    }
}



 
  
 
 
  
10、redis实现消息队列
 
  
10.1、普通消息队列
 
  
 利用list数据类型的LPUSH和RPOP命令，循环生产和消费
 
  
 
 
  
10.2、阻塞消息队列
 
  
利用BLPOP和BRPOP命令
 
  
BRPOP  key  timeout  #timeout为0表示永远阻塞
 
  
 
 
  
10.3、优先级队列
 
  
场景：小白新写了一篇博客，1000个用户订阅了小白，小白发表博客后，会将1000个用户加入队列中，发提醒邮件，此时有一个新用户订阅小白的博客，新用户会收到确认订阅的邮件，如果不排优先级的话，新用户收到订阅邮件会在发送1000个提醒邮件之后，这个时间太长了。从这个业务场景来看，提醒邮件没有确认邮件优先级高
 
  
BRPOP  key1  key2  ...  timeout  #支持多个键，最左边的键优先级最高
 
  
 
 
  
10.4、发布与订阅
 
  
消息不会持久化
 
  
SUBSCRIBE  channel1  channel2  ...
 
  
UNSUBSCRIBE  channel1  channel2  ...
 
  
PSUBSCRIBE    pattern  #支持glob风格通配符
 
  
PUNSUBSCRIBE     pattern 
 
  
 
 
  
publish  channel  message
 
  
 
 
  
订阅之后会收到三条消息，第一条消息的含义是消息类型：
 
  
     
   
  • subscribe
    •  
   
  • message
    •  
   
  • unsubscribe
    •  
  
 
  
 
 
  
11、管道技术pipeline
 
  
redis的使用瓶颈在于网络延迟，其次是cpu和内存
 
  
管道技术最显著的优势是提高了redis服务的性能
 
  
通过pipeline方式当有大批量的操作时候。我们可以节省很多原来浪费在网络延迟的时间。需要注意到是用pipeline方式打包命令发送，redis必须在处理完所有命令前先缓存起所有命令的处理结果。打包的命令越多，缓存消耗内存也越多。所以并是不是打包的命令越多越好。具体多少合适需要根据具体情况测试
 
  
 
 
  
11.1、redisTemplate实现管道
 
  
List objects = redisTemplate.executePipelined(new RedisCallback() {
            @Override
            public Object doInRedis(RedisConnection conn) throws DataAccessException {
                //openPipeline可以调用，也可以不调用，但是closePineline不能调用
                //RedisConnection是redis原生的连接，所以入参和出参都是byte[]类型
                conn.openPipeline();
                for (int i = 0; i < 10000; i++) {
                    conn.hSet("hash_pipeline".getBytes(), ("name" + i).getBytes(), "zhangsan".getBytes());
                }
                //这里必须返回null
                return null;
            }
        }); 
  
 
 
  
12、redis集群
 
  
集群的好处：
 
  
     
   
  • 避免单点故障
    •  
   
  • 单个redis的内存容易成为瓶颈，所以要进行数据分片
    •  
  
 
  
12.1、复制
 
  
12.1.1、主从复制
 
  
主库可以读写，从库只读（接收主库同步过来的数据）
 
  
如何配置：
 
  
     
   
  • 主库无需任何配置
    •  
   
  • 从库加上配置：slaveof  主库地址  主库端口号
    •  
   
  • 设置slave-read-only为no可以让从库也可以进行写操作，但是从库数据不会同步给其它库，会产品数据不一致问题
    •  
  
 
  
主从复制缺点：主库或从库如果崩溃了进行重启以及重启后的数据恢复，都是手工操作，比较麻烦，也容易出错，哨兵模式可以解决这个问题
 
  
INFO  replication  #查看状态
 
  
 
 
  
12.1.2、原理
 
  
     
   
  • 从库启动时，会向主库发送SYNC命令
    •  
   
  • 主库接收到SYNC后，会在后台进行快照，并将保存快照期间的命令缓存起来
    •  
   
  • 快照保存后，主库会将快照文件和缓存起来的命令发给从库
    •  
   
  • 从库进行复制初始化
    •  
   
  • 复制同步阶段：初始化后，主库每接收到一个命令，就会同步给从库
    •  
  
 
  
补充：
 
  
     
   
  • 增量复制：如果从库端口重连了，主库只需将断开期间的命令发给从库，不需要再进行一次复制初始化
    •  
   
  • 从库同步过程中，不是阻塞的，客户端能正常与从库通信，但通信的数据是同步完成前的，可以配置slave-serve-stale-data为no让从库同步完成前向客户端返回错误
    •  
   
  • 乐观复制策略：主库向从库同步命令是异步的，这样会产生数据不一致的时间窗口，但保证了主库的性能
    •  
   
  • 主从同步可以实现读写分离
    •  
   
  • 无硬盘复制：因为复制的时候主库会生成快照文件，而硬盘的速度是很慢的，所以可以直接发送给从库而不存储在硬盘上，设置repl-disable-tcp-nodelay为yes开启无硬盘复制
    •  
  
 
  
 
 
  
12.1.3、图结构
 
  
简单来说，从库也可以作为主库，同时拥有多个从库
 
  
 
 
  
12.1.4、从库持久化
 
  
首先，主库关闭持久化，从库开启持久化
 
  
如果从库崩溃，则重启后自动从主库同步数据，不会发生数据丢失
 
  
如果主库（一主多从）崩溃，情况比较复杂：
 
  
     
   
  1. 主库不可以重启，因为主库没有开启持久化，重启之后数据丢失，再同步给从库，导致从库也丢失数据，这样从库持久化就没有意义
    2.  
   
  2. 在从库执行slaveof  no  one命令将从库提升为主库
    3.  
   
  3. 配置slaveof，将主库降级为从库，并同步新的主库的数据
    4.  
  
 
  
 
 
  
12.2、哨兵
 
  
哨兵是一个独立的进程（redis-sentinel），用于监控主从库
 
  
多个哨兵之间也会互相监控
 
  
哨兵的作用：
 
  
     
   
  • 监控主从库是否正常运行
    •  
   
  • 主库出现故障时自动将从库转为主库
    •  
  
 
  
 
 
  
Redis全教程_第5张图片
 
  
 
 
  
 
 
  
 
 
  
12.3、集群
 
  
redis集群没有使用一致性hash,而是引入了哈希槽的概念，默认有16384个哈希槽，通过CRC16(key) mod 16384的值，决定将一个key放到哪个槽中，redis集群的每个节点均匀分配一部分hash槽
 
  
使用哈希槽的好处就在于可以方便的添加或移除节点：
 
  
     
   
  • 当需要增加节点时，只需要把其他节点的某些哈希槽挪到新节点就可以了
    •  
   
  • 当需要移除节点时，只需要把移除节点上的哈希槽挪到其他节点就行了
    •  
   
  • 新增或移除节点的时候不用先停掉所有的 redis 服务
    •  
  
 
  
 
 
  
12.4、redis分区分片原理
 
  
 
 
  
 
 
  
13、redis内部数据结构
 
  
redis底层有6种数据结构，分别是：
 
  
简单动态字符串(SDS)
 
  
     
   
  • 双向链表quicklist
    •  
   
  • 字典dict
    •  
   
  • 跳跃表skiplist
    •  
   
  • 整数集合intset
    •  
   
  • 压缩列表ziplist
    •  
  
 
  
用途：
 
  
     
   
  • sds是Redis 底层所使用的字符串表示，它被用在几乎所有的Redis 模块中
    •  
   
  • redis的一个database中所有key到value的映射，就是使用一个dict来维护的
    •  
   
  • list使用双向链表或压缩链表（同时满足两个条件：1、所有元素长度不能超过64字节；2、元素个数小于512个）
    •  
   
  • 一个Redis hash结构，采用压缩链表（同时满足两个条件：1、所有元素长度不能超过64字节；2、元素个数小于512个）或dict来存储
    •  
   
  • set采用intset（同时满足两个条件：1、所有元素都是整数；2、元素个数小于512个）或dict（就好比hashset是基于hashmap实现一样）实现
    •  
   
  • zset采用skiplist+dict或ziplist+ziplist（一个保存元素值，一个保存分数。同时满足两个条件：1、所有元素长度不能超过64字节；2、元素个数不能超过128个）
    •  
  
 
  
参考链接
 
  
 
 
  
14、redis经典实例
 
  
14.1、使用有序集合实现排行榜
 
  
     
   
  • 世界杯竞猜积分排行榜
    •  
   
  • 游戏等级排行榜
    •  
   
  • 标签引用次数排行榜
    •  
  
 
  
如果使用mysql数据库，则采用order by+limit获取前100名，如果数据量大，全表扫描肯定很慢
 
  
 
 
  
 
 
  
 
 
  
 
 
  

  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(NOSQL)

        

            

                
    
                    
  • nosql数据库技术与应用知识点
                        皆过客，揽星河
NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
                        
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
    
                    
    • 
                    
  • 非关系型数据库
                        天秤-white
nosql
                        
    一、为什么要用Nosql1.单机MySQL的时代。一个基本的网站访问量一般不会太大，单个数据库完全足够。那时候更多使用的静态网页html，服务器根本没有太大压力。这时候网站的瓶颈是什么？-数据量如果太大，一个机器放不下。-数据量太大需要建立数据的索引（B+Tree），一个服务器内存放不下。-访问量读写混合，一个服务器承受不了。2.memcached缓存+MySQL+垂直拆分（读写分离）。网站80%
    
                    
    • 
                    
  • [转载] NoSQL简介
                        weixin_30325793
大数据数据库运维
                        
    摘自“百度百科”。NoSQL，泛指非关系型的数据库。随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。虽然NoSQL流行语
    
                    
    • 
                    
  • Apache HBase基础（基本概述，物理架构，逻辑架构，数据管理，架构特点，HBase Shell）
                        May--J--Oldhu
HBaseHBaseshellhbase物理架构hbase逻辑架构hbase
                        
    NoSQL综述及ApacheHBase基础一.HBase1.HBase概述2.HBase发展历史3.HBase应用场景3.1增量数据-时间序列数据3.2信息交换-消息传递3.3内容服务-Web后端应用程序3.4HBase应用场景示例4.ApacheHBase生态圈5.HBase物理架构5.1HMaster5.2RegionServer5.3Region和Table6.HBase逻辑架构-Row7.
    
                    
    • 
                    
  • 主流行架构
                        rainbowcheng
架构架构
                        
    nexus，gitlab,svn,jenkins,sonar,docker，apollo，catteambition，axure，蓝湖，禅道,WCP；redis，kafka，es，zookeeper，dubbo，shardingjdbc，mysql，InfluxDB，Telegraf，Grafana，Nginx，xxl-job，Neo4j,NebulaGraph是一个高性能的,NOSQL图形数据库
    
                    
    • 
                    
  • MongoDB ：第五章：MongoDB 插入更新删除查询文档
                        2401_84558091
作者\/mongodb数据库
                        
    “_id”:ObjectId(“56064f89ade2f21f36b03136”),“title”:“MongoDB”,“description”:“MongoDB是一个Nosql数据库”,“by”:“菜鸟教程”,“url”:“http://www.runoob.com”,“tags”:[“mongodb”,“database”,“NoSQL”],“likes”:100}可以看到标题(title
    
                    
    • 
                    
  • Redis缓存机制(详解)
                        就是有缘人
redis缓存数据库
                        
    1.Redis是什么?*redis是*一个运行在内存上的key-value存储系统。是NoSQL数据库之一2.缓存穿透,缓存击穿,缓存雪崩/**缓存穿透*/它会先查询Redis,Redis没有会查询数据库,数据库也没有这就是缓存穿透业界主流解决方案:布隆过滤器布隆过滤器的使用步骤布隆过滤器的使用步骤:1.针对现有所有数据,生成布隆过滤器2.在业务逻辑层,判断Redis之前先检查这个id是否在布隆过
    
                    
    • 
                    
  • NoSQL之REDIS配置与优化
                        m0_73868728
nosqlredis数据库
                        
    一、Redis简介Redis（RemoteDictionaryServer）是一个开源的、使用C语言编写的NoSQL数据库，它基于内存运行并支持持久化，采用key-value的存储形式。Redis因其高性能、丰富的数据类型支持和原子性操作而广泛应用于缓存、实时分析系统、排行榜等多种场景。二、Redis的安装1.使用包管理器安装对于大多数Linux发行版，可以使用包管理器直接安装Redis。例如，在
    
                    
    • 
                    
  • hadoop 0.22.0 部署笔记
                        weixin_33701564
大数据java运维
                        
    为什么80%的码农都做不了架构师？>>>因为需要使用hbase，所以开始对hbase进行学习。hbase是部署在hadoop平台上的NOSql数据库，因此在部署hbase之前需要先部署hadoop。环境：redhat5、hadoop-0.22.0.tar.gz、jdk-6u13-linux-i586.zipip192.168.1.128hostname：localhost.localdomain（
    
                    
    • 
                    
  • NoSQL（非关系型数据库）之Redis
                        花狮66
nosqlredis数据库
                        
    目录一、关系型数据库与非关系型数据库1.1关系型数据库1.2非关系型数据库1.3区别1.3.1数据存储方式不同1.3.2扩展方式不同1.4非关系型数据库产生背景二、Redis简介2.1Redis概述2.2Redis优点2.3Redis为什么这么快？总结一数据流向二各自特点一、关系型数据库与非关系型数据库1.1关系型数据库关系型数据库是一个结构化的数据库，创建在关系模型(二维表格模型)基础上，一般面
    
                    
    • 
                    
  • 【Redis基础篇】详细讲解Redis
                        ‍小林同学学JAVA
redis数据库redis服务器nosql缓存数据库javaspringboot
                        
    这篇文章让你详细了解Redis的相关知识，有代码讲解以及图片剖析，让你更轻松掌握制作不易，感觉不错，请点赞收藏哟！！！目录1redis基础1.1定义1.2SQL和NOSQL不同点1.3特征1.4Redis通用命令1.5Redis数据结构介绍1.6Redis的java客户端2Jedis快速入门2.1操作步骤2.2Jedis连接池3SpringDataRedis3.1定义3.2优势3.3API3.4操
    
                    
    • 
                    
  • mongoDB 对一个做了索引的字段，要不要给默认值？
                        hongkid
mongodb数据库
                        
    引言在设计数据库模式时，如何处理字段的默认值是一个值得深入探讨的话题。对于MongoDB这样的NoSQL数据库来说，灵活性是其一大特点，但这同时也意味着开发者需要更加谨慎地考虑数据的一致性和完整性。本文将探讨在一个已创建索引的字段上，在插入文档时是否应该显式设置默认值的问题，并给出具体的建议。MongoDB中的索引与字段设置在MongoDB中，索引可以帮助提高查询性能，特别是在处理大规模数据集时。
    
                    
    • 
                    
  • 大型网站核心架构要素
                        贾欣晓
架构架构
                        
    文章目录1性能1.1性能优化1.2性能度量2可用性2.1可用性指标2.2可用性目标2.3可用性方案2.4可用性度量3伸缩性3.1伸缩性度量3.2伸缩性方案3.2.1应用服务器集群3.2.2缓存服务器集群3.2.3关系数据库集群3.2.4NoSQL数据库产品4扩展性4.1扩展性度量4.2扩展性方案4.2.1事件驱动架构4.2.2分布式服务5安全性5.1安全性度量6小结关于什么是架构，一种比较通俗的说
    
                    
    • 
                    
  • Redis总结
                        星空怎样

                        
    [toc]Redis是什么Redis是C语言开发的一个开源的高性能键值对(key-value)的内存数据库，可以用作数据库、缓存、消息中间件等。这是一种NoSQL的数据库。Redis作为一个内存数据库：性能优秀，数据在内存中，读写速度非常快，支持并发10WQPS。单进程单线程，是线程安全的，采用IO多了复用机制。丰富的数据类型，支持字符串(strings)、散列(hash)、列表(lists)、集
    
                    
    • 
                    
  • Hbase的简单使用示例
                        傲雪凌霜，松柏长青
后端大数据hbase数据库大数据
                        
    HBase是基于HadoopHDFS构建的分布式、列式存储的NoSQL数据库，适用于存储和检索超大规模的非结构化数据。它支持随机读写，并且能够处理PB级数据。HBase通常用于实时数据存取场景，与Hadoop生态紧密集成。使用HBase的Java示例前置条件HBase集群：确保HBase集群已经安装并启动。如果没有，你可以通过本地伪分布模式或Docker来运行HBase。Hadoop配置：HBas
    
                    
    • 
                    
  • Spring常用中间件
                        贺仙姑
spring中间件java
                        
    1.数据库中间件（1）MySQL:常用的关系型数据库，支持JDBC和JPA。（2）PostgreSQL:功能强大的开源关系型数据库，支持复杂查询。（3）MongoDB:NoSQL数据库，适合存储非结构化数据。（4）Redis:内存数据结构存储，常用于缓存和消息队列。2.消息队列（1）RabbitMQ:开源消息代理，支持多种消息协议，适合异步处理。（2）Kafka:分布式流处理平台，适合处理大规模数
    
                    
    • 
                    
  • Hive和Hbase的区别
                        傲雪凌霜，松柏长青
大数据后端hivehbasehadoop
                        
    Hive和HBase都是Hadoop生态系统中的重要组件，它们都能处理大规模数据，但各自有不同的适用场景和设计理念。以下是两者的主要区别：1.数据模型Hive：Hive类似于传统的关系型数据库(RDBMS)，以表格形式存储数据。它使用SQL-like语言HiveQL来查询和处理数据，数据通常是结构化或半结构化的。HBase：HBase是一个NoSQL数据库，基于Google的BigTable模型。
    
                    
    • 
                    
  • HBase
                        傲雪凌霜，松柏长青
大数据后端hbase数据库大数据
                        
    ApacheHBase是一个基于Hadoop分布式文件系统（HDFS）构建的分布式、面向列的NoSQL数据库，主要用于处理大规模、稀疏的表结构数据。HBase的设计灵感来自Google的Bigtable，能够在海量数据中提供快速的随机读写操作，适合需要低延迟和高吞吐量的应用场景。HBase核心概念表（Table）：HBase的数据存储在表中，与传统的关系型数据库不同，HBase的表是面向列族（Co
    
                    
    • 
                    
  • ES架构及原理
                        李澎昆
ESES
                        
    Elasticsearch是一个兼有搜索引擎和NoSQL数据库功能的开源系统，基于Java/Lucene构建，可以用于全文搜索，结构化搜索以及近实时分析。说明：Lucene：只是一个框架，要充分利用它的功能，需要使用JAVA，并且在程序中集成Lucene，学习成本高，Lucene确实非常复杂。Elasticsearch是面向文档型数据库，这意味着它存储的是整个对象或者文档，它不但会存储它们，还会为
    
                    
    • 
                    
  • 经验笔记：NoSQL数据库及其缓存方法实践
                        漆黑的莫莫
数据库笔记nosql缓存
                        
    NoSQL数据库及其缓存方法实践经验笔记随着大数据时代的到来，传统的关系型数据库在处理大规模数据时面临诸多挑战，如扩展性不足、性能瓶颈等问题。NoSQL数据库因其在可扩展性、灵活性和性能方面的优势，逐渐成为解决这些问题的有效方案之一。本文将探讨NoSQL数据库的基本概念，并分享NoSQL缓存方法的实践经验，特别关注Redis作为缓存的案例分析。一、NoSQL数据库简介NoSQL数据库是非关系型数据
    
                    
    • 
                    
  • Redis数据类型简介及使用场景
                        空青726
redis数据库缓存跳槽考研面试后端
                        
    Redis是一种开源的、基于内存的、数据结构存储的、可以用作数据库、缓存和消息队列的NoSQL系统。它提供了多种丰富的数据类型，每种数据类型都有其特定的使用场景和优点。在本文中，我们将详细介绍Redis支持的五种基本数据类型：字符串(String)、哈希(Hash)、列表(List)、集合(Set)和有序集合(Zset)，以及三种高级数据类型：HyperLogLog、Bitmap和Geo。1.字符
    
                    
    • 
                    
  • Hadoop组件
                        静听山水
Hadoophadoop
                        
    这张图片展示了Hadoop生态系统的一些主要组件。Hadoop是一个开源的大数据处理框架，由Apache基金会维护。以下是每个组件的简短介绍：HBase：一个分布式、面向列的NoSQL数据库，基于GoogleBigTable的设计理念构建。HBase提供了实时读写访问大量结构化和半结构化数据的能力，非常适合大规模数据存储。Pig：一种高级数据流语言和执行引擎，用于编写MapReduce任务。Pig
    
                    
    • 
                    
  • Redis概述
                        AC编程

                        
    一、为什么需要NoSQLHighperformance高并发读写HugeStorage海量数据的高效率存储和访问HighScalability&&HighAvailability高可拓展性和高可用性二、NoSQL数据库的四大分类键值（Key-Value）存储列存储文档数据库图形数据库三、四类NoSQL数据库比较键值（Key-Value）存储相关产品：Redis、Voldemort、TokyoCab
    
                    
    • 
                    
  • MongoDB | MongoDB 终端查询
                        进击的小白菜
数据库mongodb数据库
                        
    文章目录准备工作基本查询操作连接到MongoDB数据库切换数据库查询所有文档查询特定条件下的文档查询多个字段条件查询并限制结果数量排序结果跳过某些结果实际案例查询示例总结MongoDB是一个高性能、易扩展的文档型NoSQL数据库。本文档将指导你如何使用MongoDB的命令行工具mongoshell来查询存储在MongoDB数据库中的数据。准备工作安装MongoDB:如果你还没有安装MongoDB，
    
                    
    • 
                    
  • SpringBoot学习（3）Redis使用
                        星河漫漫l
springboot运维开发学习开发语言
                        
    SpringBoot对常用的数据库支持外，对Nosql数据库也进行了封装自动化。Redis介绍Redis是目前业界使用最广泛的内存数据存储。相比Memcached，Redis支持更丰富的数据结构，例如hashes,lists,sets等，同时支持数据持久化。除此之外，Redis还提供一些类数据库的特性，比如事务，HA，主从库。可以说Redis兼具了缓存系统和数据库的一些特性，因此有着丰富的应用场景
    
                    
    • 
                    
  • Spring Data：JPA与Querydsl
                        光图强
java
                        
    JPAJPA是java的一个规范，用于在java对象和数据库之间保存数据，充当面向对象领域模型和数据库之间的桥梁。它使用Hibernate、TopLink、IBatis等ORM框架实现持久性规范。SpringDataSpringData是Spring的一个子项目，用于简化数据库访问，支持NoSql数据和关系数据库。支持的NoSql数据库包括：Mongodb、redis、Hbase、Neo4j。Sp
    
                    
    • 
                    
  • 缓存读写策略 Cache Aside Pattern，开发必备
                        架构师修炼
缓存缓存java读写策略分布式
                        
    我们在前面讲到了当我们业务面临大量写并发的时候，将数据库开发成分布式存储系统，然后又介绍了NoSql数据库与关系型数据库互相配合，以用来更好的服务与我们的业务发展。但随着并发的持续增加，存储数据量的增多，数据库的磁盘IO逐渐成了系统的瓶颈，我们需要一种访问更快的组件来降低请求响应时间，提升整体系统性能，这时我们就会使用到缓存。至于缓存这个概念，这里就不去多说了，我相信大家都懂，也知道它的作用是为了
    
                    
    • 
                    
  • NoSQL是非关系型数据库
                        潘志杰_34fd

                        
    NoSQL是非关系型数据库，NoSQL=NotOnlySQL。关系型数据库采用的结构化的数据，NoSQL采用的是键值对的方式存储数据。在处理非结构化/半结构化的大数据时；在水平方向上进行扩展时；随时应对动态增加的数据项时可以优先考虑使用NoSQL数据库。在考虑数据库的成熟度；支持；分析和商业智能；管理及专业性等问题时，应优先考虑关系型数据库。
    
                    
    • 
                    
  • 如何设计能扩展到1亿用户的系统
                        Go语言由浅入深

                        
    原文地址要设计一个支持数亿用户的系统并不容易。对于软件架构师来说，这是一个很大的挑战(不过今天读完这篇文章之后，就会变得容易了)下面是我在本文中讨论的一些主题。从简单开始：一体机（allinone）扩展的艺术：横向扩展和纵向扩展扩展关系数据库:主-从复制、主-主复制、联合、分片、去范式化和SQL调优。选择哪种数据库：NoSQL还是SQL？高级概念：缓存、CDN、geoDNS等。今天，我不想讨论高性
    
                    
    • 
                    
  • 探索企业级数据库新势力：Redis 基础与进阶
                        刘大帅ps
数据库redis缓存运维网络linux服务器
                        
    目录一.关系型数据库和NoSQL数据库1.1.数据库主要分为两大类：关系型数据库与NoSQL数据库1.2.为什么还要用NoSQL数据库呢？二.RemoteDictionaryServer简介2.1.什么是redis2.2.Redis特性2.3.单线程为何如此快?2.4.Redis应用场景三Redis的安装四.Redis的基本操作一.关系型数据库和NoSQL数据库1.1.数据库主要分为两大类：关系型
    
                    
    • 
                                
  • 项目中 枚举与注解的结合使用
                                    飞翔的马甲
javaenumannotation
                                    
    前言：版本兼容，一直是迭代开发头疼的事，最近新版本加上了支持新题型，如果新创建一份问卷包含了新题型，那旧版本客户端就不支持，如果新创建的问卷不包含新题型，那么新旧客户端都支持。这里面我们通过给问卷类型枚举增加自定义注解的方式完成。顺便巩固下枚举与注解。 
 
一、枚举 
1.在创建枚举类的时候，该类已继承java.lang.Enum类，所以自定义枚举类无法继承别的类，但可以实现接口。 
 
   
    
                                
    • 
                                
  • 【Scala十七】Scala核心十一：下划线_的用法
                                    bit1129
scala
                                    
    下划线_在Scala中广泛应用，_的基本含义是作为占位符使用。_在使用时是出问题非常多的地方，本文将不断完善_的使用场景以及所表达的含义 
  1. 在高阶函数中使用 
scala> val list = List(-3,8,7,9)
list: List[Int] = List(-3, 8, 7, 9)

scala> list.filter(_ > 7)
r
    
                                
    • 
                                
  • web缓存基础：术语、http报头和缓存策略
                                    dalan_123
Web
                                    
    对于很多人来说，去访问某一个站点，若是该站点能够提供智能化的内容缓存来提高用户体验，那么最终该站点的访问者将络绎不绝。缓存或者对之前的请求临时存储，是http协议实现中最核心的内容分发策略之一。分发路径中的组件均可以缓存内容来加速后续的请求，这是受控于对该内容所声明的缓存策略。接下来将讨web内容缓存策略的基本概念，具体包括如如何选择缓存策略以保证互联网范围内的缓存能够正确处理的您的内容，并谈论下
    
                                
    • 
                                
  • crontab 问题
                                    周凡杨
linuxcrontabunix
                                    
      
一：  0481-079   Reached   a   symbol   that   is   not   expected.   
   
背景：  
*/5   *   *   *   *  /usr/IBMIHS/rsync.sh  
    
                                
    • 
                                
  • 让tomcat支持2级域名共享session
                                    g21121
session
                                    
    tomcat默认情况下是不支持2级域名共享session的，所有有些情况下登陆后从主域名跳转到子域名会发生链接session不相同的情况，但是只需修改几处配置就可以了。 
打开tomcat下conf下context.xml文件 
找到Context标签,修改为如下内容 
如果你的域名是www.test.com 
<Context sessionCookiePath="/path&q
    
                                
    • 
                                
  • web报表工具FineReport常用函数的用法总结（数学和三角函数）
                                    老A不折腾
Webfinereport总结
                                    
      
ABS 
ABS(number):返回指定数字的绝对值。绝对值是指没有正负符号的数值。 
Number:需要求出绝对值的任意实数。 
示例: 
ABS(-1.5)等于1.5。 
ABS(0)等于0。 
ABS(2.5)等于2.5。 
  
ACOS 
ACOS(number):返回指定数值的反余弦值。反余弦值为一个角度，返回角度以弧度形式表示。 
Number:需要返回角
    
                                
    • 
                                
  • linux 启动java进程 sh文件
                                    墙头上一根草
linuxshelljar
                                    
    #!/bin/bash
#初始化服务器的进程PId变量
user_pid=0;
robot_pid=0;
loadlort_pid=0;
gateway_pid=0;

#########
#检查相关服务器是否启动成功
#说明：
#使用JDK自带的JPS命令及grep命令组合，准确查找pid
#jps 加 l 参数，表示显示java的完整包路径
#使用awk，分割出pid 
    
                                
    • 
                                
  • 我的spring学习笔记5-如何使用ApplicationContext替换BeanFactory
                                    aijuans
Spring 3 系列
                                    
    如何使用ApplicationContext替换BeanFactory？ 
 
package onlyfun.caterpillar.device;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import
    
                                
    • 
                                
  • Linux 内存使用方法详细解析
                                    annan211
linux内存Linux内存解析
                                    
    来源 http://blog.jobbole.com/45748/ 
 
 

我是一名程序员，那么我在这里以一个程序员的角度来讲解Linux内存的使用。

一提到内存管理，我们头脑中闪出的两个概念，就是虚拟内存，与物理内存。这两个概念主要来自于linux内核的支持。

Linux在内存管理上份为两级，一级是线性区，类似于00c73000-00c88000，对应于虚拟内存，它实际上不占用
    
                                
    • 
                                
  • 数据库的单表查询常用命令及使用方法(-)
                                    百合不是茶
oracle函数单表查询
                                    
      
  
创建数据库; 
      
--建表
create table bloguser(username varchar2(20),userage number(10),usersex char(2));

 
      创建bloguser表,里面有三个字段 
  
  
&nbs
    
                                
    • 
                                
  • 多线程基础知识
                                    bijian1013
java多线程threadjava多线程
                                    
    一．进程和线程 
进程就是一个在内存中独立运行的程序，有自己的地址空间。如正在运行的写字板程序就是一个进程。 
“多任务”：指操作系统能同时运行多个进程（程序）。如WINDOWS系统可以同时运行写字板程序、画图程序、WORD、Eclipse等。 
线程：是进程内部单一的一个顺序控制流。 
线程和进程 
a.       每个进程都有独立的
    
                                
    • 
                                
  • fastjson简单使用实例
                                    bijian1013
fastjson
                                    
    一.简介 
        阿里巴巴fastjson是一个Java语言编写的高性能功能完善的JSON库。它采用一种“假定有序快速匹配”的算法，把JSON Parse的性能提升到极致，是目前Java语言中最快的JSON库；包括“序列化”和“反序列化”两部分，它具备如下特征：     
    
                                
    • 
                                
  • 【RPC框架Burlap】Spring集成Burlap
                                    bit1129
spring
                                    
    Burlap和Hessian同属于codehaus的RPC调用框架，但是Burlap已经几年不更新，所以Spring在4.0里已经将Burlap的支持置为Deprecated,所以在选择RPC框架时，不应该考虑Burlap了。 
这篇文章还是记录下Burlap的用法吧，主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成 
 
    
                                
    • 
                                
  • 【Mahout一】基于Mahout 命令参数含义
                                    bit1129
Mahout
                                    
    1. mahout seqdirectory 
  
    $ mahout seqdirectory 
        --input (-i) input               Path to job input directory(原始文本文件).
        --output (-o) output             The directory pathna
    
                                
    • 
                                
  • linux使用flock文件锁解决脚本重复执行问题
                                    ronin47
linux lock　重复执行
                                    
    linux的crontab命令，可以定时执行操作，最小周期是每分钟执行一次。关于crontab实现每秒执行可参考我之前的文章《linux crontab 实现每秒执行》现在有个问题，如果设定了任务每分钟执行一次，但有可能一分钟内任务并没有执行完成，这时系统会再执行任务。导致两个相同的任务在执行。 
例如：       
<?         
// 
test
.php      
    
                                
    • 
                                
  • java-74-数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字
                                    bylijinnan
java
                                    
    

public class OcuppyMoreThanHalf {

	/**
	 * Q74 数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字
	 * two solutions:
	 * 1.O(n)
	 * see <beauty of coding>--每次删除两个不同的数字，不改变数组的特性
	 * 2.O(nlogn)
	 * 排序。中间
    
                                
    • 
                                
  • linux 系统相关命令
                                    candiio
linux
                                    
    系统参数 
cat /proc/cpuinfo  cpu相关参数 
cat /proc/meminfo 内存相关参数 
cat /proc/loadavg 负载情况 
性能参数 
1）top 
M：按内存使用排序 
P：按CPU占用排序 
1：显示各CPU的使用情况 
k：kill进程 
o：更多排序规则 
回车：刷新数据 
2）ulimit 
ulimit -a：显示本用户的系统限制参
    
                                
    • 
                                
  • [经营与资产]保持独立性和稳定性对于软件开发的重要意义
                                    comsci
软件开发
                                    
     
 
     一个软件的架构从诞生到成熟，中间要经过很多次的修正和改造 
 
      如果在这个过程中，外界的其它行业的资本不断的介入这种软件架构的升级过程中 
    
      那么软件开发者原有的设计思想和开发路线
    
                                
    • 
                                
  • 在CentOS5.5上编译OpenJDK6
                                    Cwind
linuxOpenJDK
                                    
    几番周折终于在自己的CentOS5.5上编译成功了OpenJDK6，将编译过程和遇到的问题作一简要记录，备查。  
0. OpenJDK介绍 
OpenJDK是Sun（现Oracle）公司发布的基于GPL许可的Java平台的实现。其优点： 
1、它的核心代码与同时期Sun（-> Oracle）的产品版基本上是一样的，血统纯正，不用担心性能问题，也基本上没什么兼容性问题；（代码上最主要的差异是
    
                                
    • 
                                
  • java乱码问题
                                    dashuaifu
java乱码问题js中文乱码
                                    
    swfupload上传文件参数值为中文传递到后台接收中文乱码               在js中用setPostParams（{"tag" : encodeURI( document.getElementByIdx_x("filetag").value，"utf-8")}）; 
然后在servlet中String t
    
                                
    • 
                                
  • cygwin很多命令显示command not found的解决办法
                                    dcj3sjt126com
cygwin
                                    
    cygwin很多命令显示command not found的解决办法 
  
修改cygwin.BAT文件如下 
@echo off 
D: 
set CYGWIN=tty notitle glob 
set PATH=%PATH%;d:\cygwin\bin;d:\cygwin\sbin;d:\cygwin\usr\bin;d:\cygwin\usr\sbin;d:\cygwin\us
    
                                
    • 
                                
  • [介绍]从 Yii 1.1 升级
                                    dcj3sjt126com
PHPyii2
                                    
    2.0 版框架是完全重写的，在 1.1 和 2.0 两个版本之间存在相当多差异。因此从 1.1 版升级并不像小版本间的跨越那么简单，通过本指南你将会了解两个版本间主要的不同之处。 
如果你之前没有用过 Yii 1.1，可以跳过本章，直接从"入门篇"开始读起。 
请注意，Yii 2.0 引入了很多本章并没有涉及到的新功能。强烈建议你通读整部权威指南来了解所有新特性。这样有可能会发
    
                                
    • 
                                
  • Linux SSH免登录配置总结
                                    eksliang
ssh-keygenLinux SSH免登录认证Linux SSH互信
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2187265 一、原理 
     我们使用ssh-keygen在ServerA上生成私钥跟公钥，将生成的公钥拷贝到远程机器ServerB上后,就可以使用ssh命令无需密码登录到另外一台机器ServerB上。 
     生成公钥与私钥有两种加密方式，第一种是
    
                                
    • 
                                
  • 手势滑动销毁Activity
                                    gundumw100
android
                                    
    老是效仿ios，做android的真悲催！ 
有需求：需要手势滑动销毁一个Activity 
怎么办尼？自己写？ 
不用~，网上先问一下百度。 
结果： 
http://blog.csdn.net/xiaanming/article/details/20934541 
 
 
首先将你需要的Activity继承SwipeBackActivity，它会在你的布局根目录新增一层SwipeBackLay
    
                                
    • 
                                
  • JavaScript变换表格边框颜色
                                    ini
JavaScripthtmlWebhtml5css
                                    
    效果查看：http://hovertree.com/texiao/js/2.htm代码如下，保存到HTML文件也可以查看效果： 
<html>
<head>
<meta charset="utf-8">
<title>表格边框变换颜色代码-何问起</title>
</head>
<body&
    
                                
    • 
                                
  • Kafka Rest : Confluent
                                    kane_xie
kafkaRESTconfluent
                                    
    最近拿到一个kafka rest的需求，但kafka暂时还没有提供rest api（应该是有在开发中，毕竟rest这么火），上网搜了一下，找到一个Confluent Platform，本文简单介绍一下安装。 
这里插一句，给大家推荐一个九尾搜索，原名叫谷粉SOSO，不想fanqiang谷歌的可以用这个。以前在外企用谷歌用习惯了，出来之后用度娘搜技术问题，那匹配度简直感人。 
 
 环境声明：Ubu
    
                                
    • 
                                
  • Calender不是单例
                                    men4661273
单例Calender
                                    
             在我们使用Calender的时候，使用过Calendar.getInstance()来获取一个日期类的对象，这种方式跟单例的获取方式一样，那么它到底是不是单例呢，如果是单例的话，一个对象修改内容之后，另外一个线程中的数据不久乱套了吗？从试验以及源码中可以得出，Calendar不是单例。 
测试： 
  Calendar c1 = 
    
                                
    • 
                                
  • 线程内存和主内存之间联系
                                    qifeifei
java thread
                                    
    1， java多线程共享主内存中变量的时候，一共会经过几个阶段，    
  lock:将主内存中的变量锁定，为一个线程所独占。 
  unclock:将lock加的锁定解除，此时其它的线程可以有机会访问此变量。 
  read:将主内存中的变量值读到工作内存当中。 
  load:将read读取的值保存到工作内存中的变量副本中。 
  
    
                                
    • 
                                
  • schedule和scheduleAtFixedRate
                                    tangqi609567707
javatimerschedule
                                    
    原文地址：http://blog.csdn.net/weidan1121/article/details/527307 
import java.util.Timer;import java.util.TimerTask;import java.util.Date; 
/** * @author vincent */public class TimerTest { 
 
    
                                
    • 
                                
  • erlang 部署
                                    wudixiaotie
erlang
                                    
    1.如果在启动节点的时候报这个错 ： 
{"init terminating in do_boot",{'cannot load',elf_format,get_files}} 
则需要在reltool.config中加入 
{app, hipe, [{incl_cond, exclude}]}, 
  
  
2.当generate时，遇到： 
ERROR
    
                                
    •