redis存储位置

① redis怎么存储

1. redis是一个性能非常优秀的内存数据库，通过key-value存储系统。

2. 和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hashs（哈希类型）。

3. 这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。

4. 与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

② redis 所有key 都在内存么

Redis 中的每一个数据库，都由一个 redisDb 的结构存储。
其中，redisDb.id 存储着 redis 数据库以整数表示的号码。
redisDb.dict 存储着该库所有的键值对数据。redisDb.expires 保存着每一个键的过期时间。

③ 怎么样使用Redis来存储和查询ip数据

今天朋友打了个电话，他们网站的业务要根据客户的ip地址快速定位客户的地理位置。网上已经有一大堆类似的ip地址库可以用，但问题是这些地址库的数据表结构大多如下所示
+--------------+------------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+--------------+------------------+------+-----+---------+----------------+
| ip_id | int(11) unsigned | NO | PRI | NULL | auto_increment |
| ip_country | varchar(50) | NO | | NULL | |
| ip_startip | bigint(11) | NO | MUL | NULL | |
| ip_endip | bigint(11) | NO | MUL | NULL | |
| country_code | varchar(2) | NO | | NULL | |
| zone_id | int(11) | NO | | 0 | |
+--------------+------------------+------+-----+---------+----------------+

最核心的部分是三个： ip_startip ， ip_endip 以及 ip_id 。其中 ip_id 是要查询的结果，当然也可以把 zone_id 和 ip_country 包括进去。这里就用 ip_id 来特指查询结果了。
面对这个表，没什么其它办法，查询语句只能是
SELECT * FROM who_ip WHERE ip_startip <= {ip} AND ip_endip >= {ip}

其中 {ip} 是要查询的ip地址，为了方便查询，在php中一般要用 ip2long函数把它转换为一个整数。现在问题来了，这个表有400万条数据，无论你怎么优化它的索引结构（实际上我觉得这没啥用），在以上查询语句中都要耗费2秒以上的时间，对于一个高频使用的接口，这显然是不可忍受的。
REDIS能不能解决这个问题。实际上这也是朋友最关心的问题，因为知道Redis有强大数据结构和超快的速度，那么能不能设计出适应这种查询场景的结构。
范围查询，首先想到的就是Redis里面的 Sorted Sets 结构，这也是redis中唯一可以指定范围( SCORE 值)查询的结构了，所以基本上希望都寄托在它身上了。
最简单粗暴的方法就是把 ip_startip 和 ip_endip 都转化为 Sorted Sets 里的 Score ，然后把 ip_id 定义为 Member 。这样我们的查询就很简单了，只需要用 ZRANGESCORE 查询出离ip最近SCORE对应的两个 ip_id 即可。然后再分析，如果这两个 ip_id 是相同的，那么说明这个ip在这个地址段，如果不同的话证明这个ip地址没有被任何地址段所定义，是一个未知的ip。
基本逻辑是没有问题的，但是最大的问题还是性能上的挑战。根据我的经验，一个SET 里面放10万条数据以上就已经很慢了，如果放到400万这种量级，我非常怀疑它跟mysql相比还有优势吗？
我设计的存储结构
我的解决方案是把这个地址库切分，每一片区最多保存65536个地址。也就是说如果一个ip地址段为 188.88.77.22 - 188.90.78.10 ，那么我们就把它切分为
188.88.77.22 - 188.88.77.255
188.89.0.0 - 188.89.255.255
188.90.0.0 - 189.90.78.10

也就是我们保证每一个ip地址段都被保存在 xxx.xxx.0.0 - xxx.xxx.255.255的一个区段中，这个区段的理论极限是保存65536个值，实际上要远小于这个数字。而这样的区段理论上也有65536个，这都是ip地址的设计所限，当然实际上也远小于这个值。
因此这样的设计基本上就能满足我们的性能需要了。以下是我用php写的数据切分程序
<?php

// redis 参数
define('REDIS_HOST', '127.0.0.1');
define('REDIS_PORT', 6379);
define('REDIS_DB', 10);

define('MYSQL_HOST', 'localhost');
define('MYSQL_PORT', 3306);
define('MYSQL_USER', 'root');
define('MYSQL_PASS', '123456');
define('MYSQL_DB', 'who_brand');

define('MYSQL_TABLE', 'who_ip');
define('MYSQL_COLUMN_START', 'ip_startip');
define('MYSQL_COLUMN_END', 'ip_endip');
define('MYSQL_COLUMN_ID', 'ip_id');
define('MYSQL_PAGESIZE', 1000);

mysql_connect(MYSQL_HOST . ':' . MYSQL_PORT, MYSQL_USER, MYSQL_PASS);
mysql_select_db(MYSQL_DB);

function add_ip($page, $offset, $value) {
static $redis;

if (!$redis) {
$redis = new Redis();
$redis->connect(REDIS_HOST, REDIS_PORT);
$redis->select(REDIS_DB);
}

$key = 'ip:' . $page;
$redis->zAdd($key, $offset, $value);
}

$page = 0;
do {
$offset = $page * MYSQL_PAGESIZE;
$count = 0;

$res = mysql_query('SELECT * FROM ' . MYSQL_TABLE . ' LIMIT ' . MYSQL_PAGESIZE . " OFFSET {$offset}");

while ($ip = mysql_fetch_assoc($res)) {
$start = $ip[MYSQL_COLUMN_START];
$end = $ip[MYSQL_COLUMN_END];
$value = $ip[MYSQL_COLUMN_ID];

$startOffset = $start % 65536;
$endOffset = $end % 65536;

$start -= $startOffset;
$end -= $endOffset;

$startPage = $start / 65536;
$endPage = $end / 65536;

for ($i = $startPage; $i <= $endPage; $i ++) {
if ($i == $startPage) {
add_ip($i, $startOffset, 's:' . $value);

if ($i != $endPage) {
add_ip($i, 65535, 'e:' . $value);
}
}

if ($i == $endPage) {
add_ip($i, $endOffset, 'e:' . $value);

if ($i != $startPage) {
add_ip($i, 0, 's:' . $value);
}
}

if ($i != $endPage && $i != $startPage) {
add_ip($i, 0, 's:' . $value);
add_ip($i, 65535, 'e:' . $value);
}
}

echo ($page * MYSQL_PAGESIZE + $count) . "\n";
$count ++;
}

$page ++;
} while ($count = MYSQL_PAGESIZE);

<?php

define('REDIS_HOST', '127.0.0.1');
define('REDIS_PORT', 6379);
define('REDIS_DB', 10);

$redis = new Redis();
$redis->connect(REDIS_HOST, REDIS_PORT);
$redis->select(REDIS_DB);

$ip = ip2long('173.255.218.70');
$offset = $ip % 65536;
$page = ($ip - $offset) / 65536;

// 取出小于等于它的最接近值
$start = $redis->zRevRangeByScore('ip:' . $page, 0, $offset, array(
'limit' => array(0, 1)
));

// 取出大于等于它的最接近值
$end = $redis->zRangeByScore('ip:' . $page, $offset, 65535, array(
'limit' => array(0, 1)
));

if (empty($start) || empty($end)) {
echo 'unknown';
exit;
}

$start = $start[0];
$end = $end[0];

list ($startOp, $startId) = explode(':', $start);
list ($endOp, $endId) = explode(':', $end);

if ($startId != $endId) {
echo 'unknown';
exit;
}

echo $startId;

④ Redis存储格式

redis目前提供四种数据类型：string,list,set及zset(sorted set)。
redis使用了两种文件格式：全量数据和增量请求。全量数据格式是把内存中的数据写入磁盘，便于下次读取文件进行加载；增量请求文件则是把内存中的数据序列化为操作请求，用于读取文件进行replay得到数据，序列化的操作包括SET、RPUSH、SADD、ZADD。redis的存储分为内存存储、磁盘存储和log文件三部分，配置文件中有三个参数对其进行配置。save seconds updates，save配置，指出在多长时间内，有多少次更新操作，就将数据同步到数据文件。这个可以多个条件配合，比如默认配置文件中的设置，就设置了三个条件。appendonly yes/no ，appendonly配置，指出是否在每次更新操作后进行日志记录，如果不开启，可能会在断电时导致一段时间内的数据丢失。因为redis本身同步数据文件是按上面的save条件来同步的，所以有的数据会在一段时间内只存在于内存中。appendfsync no/always/everysec ，appendfsync配置，no表示等操作系统进行数据缓存同步到磁盘，always表示每次更新操作后手动调用fsync()将数据写到磁盘，everysec表示每秒同步一次。

⑤ 如何查询redis的缓存文件路径

1、首先找到redis的安装目录，如下图测试环境目录，进入到/opt/install/redis-2.8.19/src，如下图所示。

⑥ redis的数据是存在内存里吗

Redis就是基于内存可持久化的key-value数据库。

1、性能问题，Hashmap存储大量数知据时需要不断扩容，Redis支持2的32次方个key，每个key或者value大小最大512M。

2、Hashmap是线程不安道全的，redis因为操作原子性不需要考虑这个。

3、Redis可持久化，Hashmap虽然也可以序列专化，但是Java的序列化因为安全问题说是要废除了，效率也没有Redis高，而且Redis有多属种持久化策略。

4、Redis可扩展可分布式部署。

(6)redis存储位置扩展阅读：

redis的存储分为内存存储、磁盘存储和log文件三部分，配置文件中有三个参数对其进行配置。

save seconds updates，save配置，指出在多长时间内，有多少次更新操作，就将数据同步到数据文件。这个可以多个条件配合，比如默认配置文件中的设置，就设置了三个条件。

appendonly yes/no ，appendonly配置，指出是否在每次更新操作后进行日志记录，如果不开启，可能会在断电时导致一段时间内的数据丢失。因为redis本身同步数据文件是按上面的save条件来同步的，所以有的数据会在一段时间内只存在于内存中。

⑦ redis多个数据库 内存怎么分配的

1、redis 中的每一个数据库，都由一个 redisDb 的结构存储。其中，redisDb.id 存储着 redis 数据库以整数表示的号码。redisDb.dict 存储着该库所有的键值对数据。redisDb.expires 保存着每一个键的过期时间。

2、当redis 服务器初始化时，会预先分配 16 个数据库（该数量可以通过配置文件配置），所有数据库保存到结构 redisServer 的一个成员 redisServer.db 数组中。当我们选择数据库 select number 时，程序直接通过 redisServer.db[number] 来切换数据库。有时候当程序需要知道自己是在哪个数据库时，直接读取 redisDb.id 即可。

3、既然我们知道一个数据库的所有键值都存储在redisDb.dict中，那么我们要知道如果找到key的位置，就有必要了解一下dict 的结构了：

typedef struct dict {

// 特定于类型的处理函数
dictType *type;

// 类型处理函数的私有数据
void *privdata;

// 哈希表（2个）
dictht ht[2];

// 记录 rehash 进度的标志，值为-1 表示 rehash 未进行
int rehashidx;

// 当前正在运作的安全迭代器数量
int iterators;
} dict;
由上述的结构可以看出，redis 的字典使用哈希表作为其底层实现。dict 类型使用的两个指向哈希表的指针，其中 0 号哈希表（ht[0]）主要用于存储数据库的所有键值，而1号哈希表主要用于程序对 0 号哈希表进行 rehash 时使用，rehash 一般是在添加新值时会触发，这里不做过多的赘述。所以redis 中查找一个key，其实就是对进行该dict 结构中的 ht[0] 进行查找操作。

4、既然是哈希，那么我们知道就会有哈希碰撞，那么当多个键哈希之后为同一个值怎么办呢？redis采取链表的方式来存储多个哈希碰撞的键。也就是说，当根据key的哈希值找到该列表后，如果列表的长度大于1，那么我们需要遍历该链表来找到我们所查找的key。当然，一般情况下链表长度都为是1，所以时间复杂度可看作o(1)。

二、当redis 拿到一个key 时，如果找到该key的位置。

了解了上述知识之后，我们就可以来分析redis如果在内存找到一个key了。

1、当拿到一个key后， redis 先判断当前库的0号哈希表是否为空，即：if (dict->ht[0].size == 0)。如果为true直接返回NULL。

2、判断该0号哈希表是否需要rehash，因为如果在进行rehash，那么两个表中者有可能存储该key。如果正在进行rehash，将调用一次_dictRehashStep方法，_dictRehashStep 用于对数据库字典、以及哈希键的字典进行被动 rehash，这里不作赘述。

3、计算哈希表，根据当前字典与key进行哈希值的计算。

4、根据哈希值与当前字典计算哈希表的索引值。

5、根据索引值在哈希表中取出链表，遍历该链表找到key的位置。一般情况，该链表长度为1。

6、当 ht[0] 查找完了之后，再进行了次rehash判断，如果未在rehashing，则直接结束，否则对ht[1]重复345步骤。

到此我们就找到了key在内存中的位置了。

⑧ redis存储几个g的数据

首先看到 Redis 官方的说法是：‘A String value can be at max 512 Megabytes in length.’。过大的 key 和 value 有两个问题：Redis 是一个内存数据库，如果容量过大的 key 和 value 首先会导致服务器中的内存碎片。这会影响 Redis 的内存分配的效率，进一步导致内存的使用率下降。容量过大的 key 和 value 还有这样几个影响：a. 这些过大的数据需要更多的时间去传输数据b. 过大的数据传输可能会导致其他的请求超时如果 A 的响应数据过大，它可能会吃掉其他请求的超时时间。如下图例子，如果 A 的响应数据过大，它会吃掉其他请求的超时时间

⑨ 什么是Redis

redis 就是一个数据库，不过与传统数据库不同的是 redis 的数据是存在内存和部分文件中的，所以读写速度非常快，因此 redis 被广泛应用于缓存方向。另外，redis 也经常用来做分布式锁。redis 提供了多种数据类型来支持不同的业务场景。除此之外，redis 支持事务 、持久化、LUA脚本、LRU驱动事件、多种集群方案。

⑩ Redis是将数据储存进内存吗

Redis就是基于内存可持久化的key-value数据库。

1. 性能问题，Hashmap存储大量数据时需要不断扩容，Redis支持2的32次方个key，每个key或者value大小最大512M；

2. Hashmap是线程不安全的，redis因为操作原子性不需要考虑这个；

3. Redis可持久化，Hashmap虽然也可以序列化，但是Java的序列化因为安全问题说是要废除了，效率也没有Redis高，而且Redis有多种持久化策略；
   

4. Redis可扩展可分布式部署