这样的文件很适合用于进行备份： 比方说，你能够在近期的 24 小时内，每小时备份一次 RDB 文件。而且在每一个月的每一天，也备份一个 RDB 文件。

这样的话。即使遇上问题，也能够随时将数据集还原到不同的版本号。RDB 很适用于灾难恢复（disaster recovery）：它仅仅有一个文件，而且内容都很紧凑。能够（在加密后）将它传送到别的数据中心，或者亚马逊 S3 中。RDB 能够最大化 Redis 的性能：父进程在保存 RDB 文件时唯一要做的就是 fork 出一个子进程，然后这个子进程就会处理接下来的全部保存工作，父进程无须运行不论什么磁盘 I/O 操作。RDB 在恢复大数据集时的速度比 AOF 的恢复速度要快。

RDB 的缺点:
假设你须要尽量避免在server故障时丢失数据，那么 RDB 不适合你。 尽管 Redis 同意你设置不同的保存点（save point）来控制保存 RDB 文件的频率， 可是， 由于RDB 文件须要保存整个数据集的状态。 所以它并非一个轻松的操作。

因此你可能会至少 5 分钟才保存一次 RDB 文件。 在这样的情况下， 一旦发生问题停机， 你就可能会丢失好几分钟的数据。

每次保存 RDB 的时候，Redis 都要 fork() 出一个子进程，并由子进程来进行实际的持久化工作。

在数据集比較庞大时， fork() 可能会很耗时。造成server在某某毫秒内停止处理client； 假设数据集很巨大。而且 CPU 时间很紧张的话，那么这样的停止时间甚至可能会长达整整一秒。 尽管 AOF 重写也须要进行 fork() ，但无论 AOF 重写的运行间隔有多长，数据的耐久性都不会有不论什么损失。

AOF

AOF 的默认策略为每秒钟 fsync 一次，在这样的配置下，Redis 仍然能够保持良好的性能，而且就算发生问题停机，也最多仅仅会丢失一秒钟的数据（ fsync 会在后台线程运行。所以主线程能够继续努力地处理命令请求）。

AOF 文件是一个仅仅进行追加操作的日志文件（append only log）。 因此对 AOF 文件的写入不须要进行 seek ， 即使日志由于某些原因而包括了未写入完整的命令（比方写入时磁盘已满，写入中途停机。等等）， redis-check-aof 工具也能够轻易地修复这样的问题。

Redis 能够在 AOF 文件体积变得过大时，自己主动地在后台对 AOF 进行重写： 重写后的新 AOF 文件包括了恢复当前数据集所需的最小命令集合。 整个重写操作是绝对安全的，由于 Redis 在创建新 AOF 文件的过程中，会继续将命令追加到现有的 AOF 文件里面，即使重写过程中发生停机，现有的 AOF 文件也不会丢失。 而一旦新 AOF 文件创建完毕，Redis 就会从旧 AOF 文件切换到新 AOF 文件，并開始对新 AOF 文件进行追加操作。AOF 文件有序地保存了对数据库运行的全部写入操作， 这些写入操作以 Redis 协议的格式保存。 因此 AOF 文件的内容很easy被人读懂， 对文件进行分析（parse）也很轻松。 导出（export） AOF 文件也很easy： 举个样例。 假设你不小心运行了 FLUSHALL 命令， 但仅仅要 AOF 文件未被重写， 那么仅仅要停止server， 移除 AOF 文件末尾的 FLUSHALL 命令。 并重新启动 Redis 。 就能够将数据集恢复到 FLUSHALL 运行之前的状态。

AOF 的缺点:
对于同样的数据集来说。AOF 文件的体积通常要大于 RDB 文件的体积。

依据所使用的 fsync 策略。AOF 的速度可能会慢于 RDB 。

在普通情况下， 每秒 fsync 的性能依旧很高， 而关闭 fsync 能够让 AOF 的速度和 RDB 一样快。 即使在高负荷之下也是如此。 只是在处理巨大的写入加载时。RDB 能够提供更有保证的最大延迟时间（latency）。AOF 在过去以前发生过这样的 bug ： 由于个别命令的原因，导致 AOF 文件在又一次加载时，无法将数据集恢复成保存时的原样。

（举个样例，堵塞命令 BRPOPLPUSH 就以前引起过这样的 bug 。） 測试套件里为这样的情况增加了測试： 它们会自己主动生成随机的、复杂的数据集。 并通过又一次加载这些数据来确保一切正常。

尽管这样的 bug 在 AOF 文件里并不常见。 可是对照来说， RDB 差点儿是不可能出现这样的 bug 的。

RDB 和 AOF间的选择

object=queryFromCache();

if(object==null||queryFromCache throw any exception)
{
  object=queryFromDB();
}

。bla...bla...bla...这里详细就要看业务了。

。。此时这台旧的master上的RDB文件和从slave位置被提升成master(new master）间的RDB文件的出入，是不是就会比較高啊。

。。

因此此时old master会试图和新的master进行RDB间的数据同步。而这个同步。。。是很要命的，假设你的用户并发量很大。在一瞬时内你的rdb增长的会很高。因此当两个redis nodes在同步RDB文件时就会直接把你的如今的new master（原来的slave）搞死进而搞死你的old master（原来的master），由于它是单线程的，大数据量在同步时它会ban掉不论什么的訪问请求。

2) 假设 slave-serve-stale data设置成  'no'  slave会返回"SYNC with master in progress"这样的错误信息。

但 INFO 和SLAVEOF命令除外。

。。那么你将会没有一个可用的redis节点进而把整个环境搞死。

• 开启THP的优势在于:

1.  降低page fault。一次page fault能够加载更大的内存块.。
2. 更小的页表。同样的内存大小，须要更少的页。
3. 由于页表更小，虚拟地址到物理地址的翻译也更快。    

• 劣势在于:

1. 降低分配内存效率。须要大块、连续内存块，内核线程会比較激进的进行compaction。解决内存碎片，加剧锁争用。
2. 降低IO吞吐。由于swapable huge page。在swap时须要切分成原有的4K的页。Oracle的測试数据显示会降低30%的IO吞吐。

• 对于redis而言。开启THP的优势：fork子进程的时间大幅降低。fork进程的主要开销是拷贝页表、fd列表等进程数据结构。

  由于页表大幅较小（2MB / 4KB = 512倍）,fork的耗时也会大幅降低。   

• 劣势在于: fork之后。父子进程间以copy-on-write方式共享地址空间。假设父进程有大量写操作，而且不具有locality，会有大量的页被写。并须要拷贝。同一时候。由于开启THP，每一个页2MB。会大幅增加内存拷贝。

• fork时间对照  开启THP后，fork大幅降低。
• 超时次数对照 开启THP后，超时次数明显增多。可是每次超时时间较短。

  而关闭THP后。仅仅有4次超时，原因是与fork在同一事件循环的请求受到fork的影响。  关闭THP影响的仅仅是零星几个请求，而开启后，尽管超时时间短了，可是影响面扩大了进而导致了整个Linux系统的不稳定。

echo never > /sys/kernel/mm/transparent_hugepage/enabled

Redis的maxmemory 0的问题

Redis配置文件里的这一行代表Redis会使用系统内存，你不该去限制Redis的内存开销如：JVM中的-xmx这个參数，而是要让Redis自己主动去使用系统的内存以获得最高的性能，因此我们会把这个值设成0即代表无限使用系统内存，系统内存有多少我们用多少。默认它启动后会消耗掉1个G的系统自有内存。

因此linux系统中有一个系统參数叫overcommit_memory，它代表的是内存分配策略，可选值为：0、1、2。

0， 表示内核将检查是否有足够的可用内存供应用进程使用；假设有足够的可用内存，内存申请同意；否则，内存申请失败，并把错误返回给应用进程。
1， 表示内核同意分配全部的物理内存。而无论当前的内存状态怎样。

2， 表示内核同意分配超过全部物理内存和交换空间总和的内存

所以我们结合我们的Redis使用以下的linux命令：

echo 1 > /proc/sys/vm/overcommit_memory

sysctl -p

Redis在Linux系统中Too many open files的问题

1. 一个Master能够有多个Slave。
2. Redis使用异步复制。从2.8開始。Slave会周期性（每秒一次）发起一个Ack确认复制流（replication stream）被处理进度。
3. 不仅主server能够有从server， 从server也能够有自己的从server， 多个从server之间能够构成一个图状结构。
4. 复制在Master端是非堵塞模式的。这意味着即便是多个Slave运行首次同步时。Master依旧能够提供查询服务。
5. 复制在Slave端也是非堵塞模式的：假设你在redis.conf做了设置，Slave在运行首次同步的时候仍能够使用旧数据集提供查询；你也能够配置为当Master与Slave失去联系时，让Slave返回client一个错误提示；
6. 当Slave要删掉旧的数据集，并又一次加载新版数据时，Slave会堵塞连接请求（一般发生在与Master断开重连后的恢复阶段）；
7. 复制功能能够单纯地用于数据冗余（data redundancy），也能够通过让多个从server处理仅仅读命令请求来提升扩展性（scalability）： 比方说。 繁重的 SORT 命令能够交给附属节点去运行。
8. 能够通过改动Master端的redis.config来避免在Master端运行持久化操作（Save），由Slave端来运行持久化。

make PREFIX=/usr/local/redis1 install
make PREFIX=/usr/local/redis2 install
make PREFIX=/usr/local/redis-sentinel install

port 26379
daemonize yes
logfile "/var/log/redis/sentinel.log"
sentinel monitor master1 192.168.56.101 7001 1
sentinel down-after-milliseconds master1 1000
sentinel failover-timeout master1 5000
#sentinel can-failover master1 yes #remove from 2.8 and aboved version

• daemonize yes – 以后台进程模式运行
• port 26379 – 哨兵的端口号。该端口号默觉得26379，不得与不论什么redis node的端口号反复
• logfile “/var/log/redis/sentinel.log“ – log文件所在地
• sentinel monitor master1 192.168.56.101 7001 1 – （第一次配置时）哨兵对哪个master进行监測，此处的master1为一“别名”能够随意如sentinel-26379，然后哨兵会通过这个别名后的IP知道整个该master内的slave关系。因此你不用在此配置slave是什么而由哨兵自己去维护这个“链表”。

• sentinel monitor master1 192.168.56.101 7001 1 –  这边有一个“1”，这个“1”代表当新master产生时，同一时候进行“slaveof”到新master并进行同步复制的slave个数。在salve运行salveof与同步时，将会终止client请求。此值较大。意味着“集群”终止client请求的时间总和和较大。此值较小,意味着“集群”在故障转移期间，多个salve向client提供服务时仍然使用旧数据。我们这边仅仅想让一个slave来做此时的响应以取得较好的client体验。
  
  
• sentinel down-after-milliseconds master1 1000 – 假设master在多少秒内无反应哨兵会開始进行master-slave间的切换。使用“选举”机制
• sentinel failover-timeout master1 5000 – 假设在多少秒内没有把宕掉的那台master恢复，那哨兵觉得这是一次真正的宕机。而排除该宕掉的master作为节点选取时可用的node然后等待一定的设定值的毫秒数后再来探測该节点是否恢复，假设恢复就把它作为一台slave增加哨兵监測节点群并在下一次切换时为他分配一个“选取号”。
• #sentinel can-failover master1 yes #remove from 2.8 and aboved version – 该功能已经从2.6版以后去除，因此凝视掉，网上的教程不适合于redis-stable版

slaveof 192.168.56.101 7001

redis-cli -p 26379 -h 192.168.56.101

redis-cli -p 7001 -h 192.168.56.101

• 模拟代码
• 模拟并发測试工具

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>webpoc</groupId>
	<artifactId>webpoc</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<java.version>1.8</java.version>
		<jetty.version>9.3.3.v20150827</jetty.version>
		<slf4j.version>1.7.7</slf4j.version>
		<spring.version>4.2.1.RELEASE</spring.version>
		<spring.session.version>1.0.2.RELEASE</spring.session.version>
		<javax.servlet-api.version>2.5</javax.servlet-api.version>
		<activemq_version>5.8.0</activemq_version>
		<poi_version>3.8</poi_version>
	</properties>
	<dependencies>
		<!-- poi start -->
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi</artifactId>
			<version>${poi_version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi-ooxml-schemas</artifactId>
			<version>${poi_version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi-scratchpad</artifactId>
			<version>${poi_version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi-ooxml</artifactId>
			<version>${poi_version}</version>
		</dependency>
		<!-- poi end -->
		<!-- active mq start -->
		<dependency>
			<groupId>org.apache.activemq</groupId>
			<artifactId>activemq-all</artifactId>
			<version>5.8.0</version>
		</dependency>

		<dependency>
			<groupId>org.apache.activemq</groupId>
			<artifactId>activemq-pool</artifactId>
			<version>${activemq_version}</version>
		</dependency>

		<dependency>
			<groupId>org.apache.xbean</groupId>
			<artifactId>xbean-spring</artifactId>
			<version>3.16</version>
		</dependency>
		<!-- active mq end -->

		<!-- servlet start -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>${javax.servlet-api.version}</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet.jsp</groupId>
			<artifactId>jsp-api</artifactId>
			<version>2.1</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>
		<!-- servlet end -->

		<!-- redis start -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.7.2</version>
		</dependency>
		<dependency>
			<groupId>org.redisson</groupId>
			<artifactId>redisson</artifactId>
			<version>1.0.2</version>
		</dependency>
		<!-- redis end -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>jcl-over-slf4j</artifactId>
			<version>${slf4j.version}</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>${slf4j.version}</version>
		</dependency>

		<!-- spring conf start -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			<version>1.6.2.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
			<exclusions>
				<exclusion>
					<groupId>commons-logging</groupId>
					<artifactId>commons-logging</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jms</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework.session</groupId>
			<artifactId>spring-session</artifactId>
			<version>${spring.session.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<!-- spring conf end -->
	</dependencies>
	<build>
		<sourceDirectory>src</sourceDirectory>
		<plugins>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.1</version>
				<configuration>
					<source>1.7</source>
					<target>1.7</target>
				</configuration>
			</plugin>
			<plugin>
				<artifactId>maven-war-plugin</artifactId>
				<version>2.4</version>
				<configuration>
					<warSourceDirectory>WebContent</warSourceDirectory>
					<failOnMissingWebXml>false</failOnMissingWebXml>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

applicationContext.xml文件

<?
xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="  
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

	<context:property-placeholder location="classpath:/spring/redis.properties" />
	<context:component-scan base-package="org.sky.redis">
	</context:component-scan>

	<bean 
		class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
		<constructor-arg index="0" ref="redisSentinelConfiguration" />
		<constructor-arg index="1" ref="jedisPoolConfig" />
	</bean>

	<bean >
		<property name="maxTotal" value="${redis.maxTotal}" />
		<property name="maxIdle" value="${redis.maxIdle}" />
		<property name="maxWaitMillis" value="${redis.maxWait}" />
		<property name="testOnBorrow" value="${redis.testOnBorrow}" />
		<property name="testOnReturn" value="${redis.testOnReturn}" />
	</bean>
	<bean 
		class="org.springframework.data.redis.connection.RedisSentinelConfiguration">
		<property name="master">
			<bean class="org.springframework.data.redis.connection.RedisNode">
				<property name="name" value="master1" />
			</bean>
		</property>
		<property name="sentinels">
			<set>
				<bean class="org.springframework.data.redis.connection.RedisNode">
					<constructor-arg name="host" value="192.168.56.101" />
					<constructor-arg name="port" value="26379" />
				</bean>
			</set>
		</property>
	</bean>

	<bean >
		<property name="connectionFactory" ref="jedisConnectionFactory" />
	</bean>

	<!--将session放入redis -->
	<bean 
		class="org.springframework.session.data.redis.config.annotation.web.http.RedisHttpSessionConfiguration">
		<property name="maxInactiveIntervalInSeconds" value="1800" />
	</bean>
	<bean  />
</beans> 

<property name="master">
			<bean class="org.springframework.data.redis.connection.RedisNode">
				<property name="name" value="master1" />
			</bean>
</property>

# Redis settings

redis.host.ip=192.168.56.101
redis.host.port=7001
  

redis.maxTotal=1000  
redis.maxIdle=100
redis.maxWait=2000
redis.testOnBorrow=false
redis.testOnReturn=true

redis.sentinel.addr=192.168.56.101:26379

SentinelController.java文件

package sample;

import java.util.HashMap;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.redis.core.BoundHashOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RequestMapping;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisSentinelPool;
import util.CountCreater;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

/**
 * Created by xin on 15/1/7.
 */
@Controller
public class SentinelController {
	private final Logger logger = LoggerFactory.getLogger(this.getClass());
	@Autowired
	private StringRedisTemplate redisTemplate;

	@RequestMapping("/sentinelTest")
	public String sentinelTest(final Model model,
			final HttpServletRequest request, final String action) {
		return "sentinelTest";
	}

	@ExceptionHandler(value = { java.lang.Exception.class })
	@RequestMapping("/setValueToRedis")
	public String setValueToRedis(final Model model,
			final HttpServletRequest request, final String action)
			throws Exception {
		CountCreater.setCount();
		String key = String.valueOf(CountCreater.getCount());
		Map mapValue = new HashMap();
		for (int i = 0; i < 1000; i++) {
			mapValue.put(String.valueOf(i), String.valueOf(i));
		}
		try {
			BoundHashOperations<String, String, String> boundHashOperations = redisTemplate
					.boundHashOps(key);
			boundHashOperations.putAll(mapValue);
			logger.info("put key into redis");
		} catch (Exception e) {
			logger.error(e.getMessage(), e);
			throw new Exception(e);
		}

		return "sentinelTest";
	}

}

sentinelTest.jsp文件

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; UTF-8">
<title>test sentinel r/w</title>
</head>
<body>

</body>
</html>

測试代码运行

• master-7001
• slave-7002

jedispool to master at 192.168.56.101:7002，7002已经变成master了。

。

。7001上的服务不可用已经被我们位于26379端口的哨兵探測到了，它已经把7002变成master了。

。。7001恢复后从原来的old master成了new slave了。

• TPS值
• summary report
• 表格查看结果
• 树形查看结果

• 通过TPS我们能够发觉有蓝色的线，这代表“出错率”，这个出错率应该是7002在“崩”掉后，7001从slave升级成master时redis对client无法及时响应时抛出的HTTP 500即service unavailable的错。

• 通过Summary Report我们能够看到在主从切换的那一刻我们的fail rate为千分之0.5，这个fail rate是全然能够在接受范围内的，一般错误率在千分之中的一个就已经很好了。