我要评论redis bitmap是一种高效的位操作数据结构，它将字符串看作是由二进制位组成的数组。在redis中，一个bitmap最大可存储2^32个位，约512mb，而操作单个位的时间复杂度为o(1)。这种结构在处理海量数据的布尔型状态时尤其高效，能在极小的内存占用下完成高性能的统计与分析任务。
一、redis bitmap基础
1.1 基本概念
bitmap本质上是一个位数组，数组的每个元素只能是0或1。在redis中，bitmap是基于string类型实现的，一个字符串的每个字节(8位)可以表示8个不同位，从而实现了位数组的功能。
1.2 核心命令
redis提供了一系列操作bitmap的命令：
- setbit key offset value：设置key在offset处的位值
- getbit key offset：获取key在offset处的位值
- bitcount key [start end] ：统计指定范围内1的数量
- bitpos key bit [start end] ：返回第一个被设置为bit值的位的位置
- bitop operation destkey key [key ...] ：对多个bitmap执行位操作(and, or, xor, not)
- bitfield key [get type offset] [set type offset value] ：原子操作多个位域
二、应用场景1：用户签到系统
2.1 场景描述
在许多应用中，需要记录用户每天是否签到，并支持查询用户连续签到天数、当月签到总天数等统计功能。传统的方案可能使用关系型数据库存储每日签到记录，但这种方式既耗费存储空间，查询效率也低。
2.2 bitmap解决方案
使用bitmap，我们可以用一个位表示一天的签到状态，一个月只需30-31位，非常节省空间。
2.3 实现示例
import redis.clients.jedis.jedis;
import java.time.localdate;
import java.time.format.datetimeformatter;
public class signinsystem {
private jedis jedis;
private static final datetimeformatter month_formatter = datetimeformatter.ofpattern("yyyymm");
public signinsystem(string host, int port) {
this.jedis = new jedis(host, port);
}
// 用户签到
public void signin(long userid, localdate date) {
string signkey = getsignkey(userid, date);
int dayofmonth = date.getdayofmonth() - 1; // redis bitmap是0-based
jedis.setbit(signkey, dayofmonth, true);
}
// 检查用户是否签到
public boolean hassignedin(long userid, localdate date) {
string signkey = getsignkey(userid, date);
int dayofmonth = date.getdayofmonth() - 1;
return jedis.getbit(signkey, dayofmonth);
}
// 获取用户当月签到次数
public long getmonthlysigncount(long userid, localdate date) {
string signkey = getsignkey(userid, date);
return jedis.bitcount(signkey);
}
// 获取用户当月首次签到日期
public int getfirstsigninday(long userid, localdate date) {
string signkey = getsignkey(userid, date);
long pos = jedis.bitpos(signkey, true);
return pos == -1 ? -1 : (int) pos + 1; // 转换回自然日
}
// 获取用户当月连续签到天数
public int getconsecutivesigndays(long userid, localdate date) {
string signkey = getsignkey(userid, date);
int dayofmonth = date.getdayofmonth() - 1;
int count = 0;
// 从当天开始向前查找连续签到的天数
for (int i = dayofmonth; i >= 0; i--) {
if (jedis.getbit(signkey, i)) {
count++;
} else {
break;
}
}
return count;
}
// 构建签到key
private string getsignkey(long userid, localdate date) {
return "user:sign:" + userid + ":" + date.format(month_formatter);
}
}
2.4 性能与空间分析
- 空间占用：每个用户每月仅需4字节(1个整型)就能存储所有签到记录
- 时间复杂度：单次签到/查询操作为o(1)
- 优势：极低的存储成本，高效的统计能力
三、应用场景2：在线用户统计
3.1 场景描述
大型系统需要实时统计在线用户数，及分析用户活跃情况，如日活跃用户数(dau)、月活跃用户数(mau)等关键指标。传统方案可能使用set或hash结构，但面对海量用户时会消耗大量内存。
3.2 bitmap解决方案
使用bitmap，用户id可以直接映射为位偏移量，每个用户只占用1位。一千万用户只需约1.2mb内存。
3.3 实现示例
import redis.clients.jedis.jedis;
import java.time.localdate;
import java.time.format.datetimeformatter;
public class useractivitytracker {
private jedis jedis;
private static final datetimeformatter date_formatter = datetimeformatter.ofpattern("yyyymmdd");
public useractivitytracker(string host, int port) {
this.jedis = new jedis(host, port);
}
// 记录用户活跃
public void trackuseractivity(long userid, localdate date) {
string key = getactivitykey(date);
jedis.setbit(key, userid, true);
}
// 获取日活跃用户数(dau)
public long getdailyactiveusers(localdate date) {
string key = getactivitykey(date);
return jedis.bitcount(key);
}
// 获取月活跃用户数(mau)
public long getmonthlyactiveusers(int year, int month) {
localdate startdate = localdate.of(year, month, 1);
localdate enddate = startdate.plusmonths(1).minusdays(1);
// 创建临时结果键
string destkey = "temp:mau:" + year + month;
// 收集整月的所有日期的活跃用户
for (localdate date = startdate; !date.isafter(enddate); date = date.plusdays(1)) {
string daykey = getactivitykey(date);
// 使用or操作合并日活跃数据
jedis.bitop("or", destkey, destkey, daykey);
}
// 计算总活跃用户数
long mau = jedis.bitcount(destkey);
// 清理临时键
jedis.del(destkey);
return mau;
}
// 判断两天的活跃用户重合度 (留存率相关)
public long getactiveuseroverlap(localdate date1, localdate date2) {
string key1 = getactivitykey(date1);
string key2 = getactivitykey(date2);
string destkey = "temp:overlap:" + date1.format(date_formatter) + ":" + date2.format(date_formatter);
// 使用and操作找出两天都活跃的用户
jedis.bitop("and", destkey, key1, key2);
long overlap = jedis.bitcount(destkey);
// 清理临时键
jedis.del(destkey);
return overlap;
}
// 获取活跃用户key
private string getactivitykey(localdate date) {
return "user:active:" + date.format(date_formatter);
}
}
3.4 拓展：次日留存率计算
public double getretentionrate(localdate date) {
localdate nextdate = date.plusdays(1);
// 当天活跃用户数
long todayactive = getdailyactiveusers(date);
if (todayactive == 0) return 0.0;
// 计算当天活跃用户中第二天仍活跃的用户数
long overlap = getactiveuseroverlap(date, nextdate);
// 计算留存率
return (double) overlap / todayactive;
}
四、应用场景3：布隆过滤器实现
4.1 场景描述
布隆过滤器是一种空间效率高的概率性数据结构，用于判断元素是否存在于集合中。它在大数据、缓存穿透防护、垃圾邮件过滤等场景中广泛应用。布隆过滤器可能存在误判，但它能以极小的内存代价完成高效的查询。
4.2 bitmap解决方案
使用redis的bitmap可以轻松实现布隆过滤器，通过多个哈希函数将元素映射到位数组的不同位置。
4.3 实现示例
import redis.clients.jedis.jedis;
import java.nio.charset.standardcharsets;
import java.security.messagedigest;
import java.security.nosuchalgorithmexception;
import java.util.arraylist;
import java.util.list;
public class redisbloomfilter {
private jedis jedis;
private string key;
private int hashfunctions;
private long size;
/**
* 创建布隆过滤器
* @param host redis主机
* @param port redis端口
* @param key 过滤器键名
* @param size 位数组大小
* @param hashfunctions 哈希函数数量
*/
public redisbloomfilter(string host, int port, string key, long size, int hashfunctions) {
this.jedis = new jedis(host, port);
this.key = key;
this.size = size;
this.hashfunctions = hashfunctions;
}
/**
* 添加元素到布隆过滤器
*/
public void add(string value) {
for (long position : gethashpositions(value)) {
jedis.setbit(key, position, true);
}
}
/**
* 判断元素是否可能存在于过滤器中
* @return true表示可能存在，false表示一定不存在
*/
public boolean mightcontain(string value) {
for (long position : gethashpositions(value)) {
if (!jedis.getbit(key, position)) {
return false;
}
}
return true;
}
/**
* 计算元素在布隆过滤器中的多个位置
*/
private list<long> gethashpositions(string value) {
list<long> positions = new arraylist<>(hashfunctions);
try {
messagedigest md = messagedigest.getinstance("md5");
byte[] bytes = md.digest(value.getbytes(standardcharsets.utf_8));
// 使用同一个md5值生成多个哈希位置
for (int i = 0; i < hashfunctions; i++) {
long hashvalue = 0;
for (int j = i * 4; j < i * 4 + 4; j++) {
hashvalue <<= 8;
int index = j % bytes.length;
hashvalue |= (bytes[index] & 0xff);
}
positions.add(math.abs(hashvalue % size));
}
} catch (nosuchalgorithmexception e) {
throw new runtimeexception("md5 algorithm not found", e);
}
return positions;
}
/**
* 重置过滤器
*/
public void clear() {
jedis.del(key);
}
}
4.4 应用实例：缓存穿透防护
public class cacheservice {
private redisbloomfilter bloomfilter;
private jedis jedis;
public cacheservice(string host, int port) {
this.jedis = new jedis(host, port);
// 创建布隆过滤器，大小为1000万位，使用7个哈希函数
this.bloomfilter = new redisbloomfilter(host, port, "cache:bloom:filter", 10_000_000, 7);
// 初始化过滤器，添加所有有效的id
initbloomfilter();
}
private void initbloomfilter() {
// 模拟从数据库加载所有有效id并添加到布隆过滤器
list<string> allvalidids = getallidsfromdatabase();
for (string id : allvalidids) {
bloomfilter.add(id);
}
}
public string getdatabyid(string id) {
// 首先检查id是否可能存在
if (!bloomfilter.mightcontain(id)) {
return null; // id一定不存在，直接返回
}
// 尝试从缓存获取
string cachekey = "cache:data:" + id;
string data = jedis.get(cachekey);
if (data != null) {
return data; // 缓存命中
}
// 缓存未命中，从数据库获取
data = getfromdatabase(id);
if (data != null) {
// 存入缓存
jedis.setex(cachekey, 3600, data);
return data;
}
// id不存在于数据库（布隆过滤器误判的情况）
return null;
}
// 模拟从数据库获取数据
private string getfromdatabase(string id) {
// 实际项目中会查询数据库
return null; // 模拟数据不存在
}
// 模拟从数据库获取所有id
private list<string> getallidsfromdatabase() {
// 实际项目中会查询数据库获取所有有效id
return new arraylist<>();
}
}
五、应用场景4：用户行为分析与推荐系统
5.1 场景描述
在推荐系统中，需要分析用户对不同物品（如文章、商品）的行为偏好，包括浏览、收藏、点赞等。这些数据用于构建用户画像和内容推荐算法的输入。传统方案可能使用关系型数据库或文档数据库存储这些行为记录，但在大规模场景下会面临存储和查询效率问题。
5.2 bitmap解决方案
使用bitmap可以高效存储用户对物品的偏好状态。例如，使用不同的bitmap记录用户是否浏览、收藏、购买某商品。
5.3 实现示例
import redis.clients.jedis.jedis;
import java.util.arraylist;
import java.util.hashset;
import java.util.list;
import java.util.set;
public class userbehavioranalyzer {
private jedis jedis;
// 行为类型常量
private static final string view = "view";
private static final string like = "like";
private static final string collect = "collect";
private static final string purchase = "purchase";
public userbehavioranalyzer(string host, int port) {
this.jedis = new jedis(host, port);
}
/**
* 记录用户对物品的行为
* @param userid 用户id
* @param itemid 物品id
* @param behaviortype 行为类型
*/
public void recordbehavior(long userid, long itemid, string behaviortype) {
string key = getbehaviorkey(userid, behaviortype);
jedis.setbit(key, itemid, true);
}
/**
* 检查用户是否对物品有过特定行为
*/
public boolean hasbehavior(long userid, long itemid, string behaviortype) {
string key = getbehaviorkey(userid, behaviortype);
return jedis.getbit(key, itemid);
}
/**
* 获取用户对特定行为的物品总数
*/
public long getbehaviorcount(long userid, string behaviortype) {
string key = getbehaviorkey(userid, behaviortype);
return jedis.bitcount(key);
}
/**
* 获取有特定行为的用户总数
*/
public long getusercountwithbehavior(long itemid, string behaviortype) {
// 这个实现需要遍历所有用户，实际应用中可能需要其他方式优化
// 这里仅作示例，实际项目应考虑性能影响
int usercount = 0;
// 假设用户id范围是1-10000
for (long userid = 1; userid <= 10000; userid++) {
if (hasbehavior(userid, itemid, behaviortype)) {
usercount++;
}
}
return usercount;
}
/**
* 计算用户之间的行为相似度（用于协同过滤推荐）
* @return 返回两个用户共同行为的物品数量
*/
public long calculateusersimilarity(long userid1, long userid2, string behaviortype) {
string key1 = getbehaviorkey(userid1, behaviortype);
string key2 = getbehaviorkey(userid2, behaviortype);
string destkey = "temp:similarity:" + userid1 + ":" + userid2 + ":" + behaviortype;
// 使用and操作找出共同行为
jedis.bitop("and", destkey, key1, key2);
long similarity = jedis.bitcount(destkey);
// 清理临时键
jedis.del(destkey);
return similarity;
}
/**
* 基于用户行为生成物品推荐
* @return 推荐物品id列表
*/
public list<long> getrecommendations(long userid, int limit) {
list<long> recommendations = new arraylist<>();
set<long> alreadyviewed = new hashset<>();
// 获取用户已浏览物品
string viewkey = getbehaviorkey(userid, view);
for (long i = 0; i < 10000; i++) { // 假设物品id范围
if (jedis.getbit(viewkey, i)) {
alreadyviewed.add(i);
}
}
// 找出具有相似行为的用户
list<long> similarusers = findsimilarusers(userid);
// 从相似用户的浏览记录中推荐物品
for (long similaruserid : similarusers) {
string otherviewkey = getbehaviorkey(similaruserid, view);
for (long i = 0; i < 10000; i++) { // 假设物品id范围
if (recommendations.size() >= limit) {
break;
}
// 只推荐用户未浏览过的物品
if (jedis.getbit(otherviewkey, i) && !alreadyviewed.contains(i)) {
recommendations.add(i);
alreadyviewed.add(i); // 避免重复推荐
}
}
}
return recommendations;
}
// 查找相似用户
private list<long> findsimilarusers(long userid) {
// 实际应用中可能需要更复杂的算法
// 这里仅作示例
list<long> similarusers = new arraylist<>();
// 假设用户id范围是1-10000
for (long otheruserid = 1; otheruserid <= 10000; otheruserid++) {
if (userid == otheruserid) continue;
long similarityscore = calculateusersimilarity(userid, otheruserid, view);
if (similarityscore > 5) { // 相似度阈值
similarusers.add(otheruserid);
}
if (similarusers.size() >= 10) {
break; // 限制相似用户数量
}
}
return similarusers;
}
// 获取行为key
private string getbehaviorkey(long userid, string behaviortype) {
return "user:" + userid + ":" + behaviortype;
}
}
六、应用场景5：ip地址统计与黑名单系统
6.1 场景描述
在网络安全和流量分析场景中，需要统计访问ip地址、识别异常ip、实现ip黑白名单功能。传统方案可能使用hash或set存储ip地址，但在大规模场景下内存消耗巨大。
6.2 bitmap解决方案
利用bitmap可以将ip地址映射为位偏移量，极大节省内存。ipv4地址共有2^32个（约43亿），使用bitmap只需512mb内存即可表示所有可能的ip地址。
6.3 实现示例
import redis.clients.jedis.jedis;
import java.net.inetaddress;
import java.net.unknownhostexception;
public class ipaddresstracker {
private jedis jedis;
public ipaddresstracker(string host, int port) {
this.jedis = new jedis(host, port);
}
/**
* 将ip地址添加到黑名单
*/
public void addtoblacklist(string ipaddress) {
long ipvalue = iptolong(ipaddress);
jedis.setbit("ip:blacklist", ipvalue, true);
}
/**
* 检查ip是否在黑名单中
*/
public boolean isblacklisted(string ipaddress) {
long ipvalue = iptolong(ipaddress);
return jedis.getbit("ip:blacklist", ipvalue);
}
/**
* 记录ip访问
*/
public void trackipvisit(string ipaddress) {
long ipvalue = iptolong(ipaddress);
jedis.setbit("ip:visited", ipvalue, true);
}
/**
* 获取不同ip访问总数
*/
public long getuniqueipcount() {
return jedis.bitcount("ip:visited");
}
/**
* 记录特定日期的ip访问
*/
public void trackipvisitbydate(string ipaddress, string date) {
long ipvalue = iptolong(ipaddress);
jedis.setbit("ip:visited:" + date, ipvalue, true);
}
/**
* 获取特定日期的不同ip访问数
*/
public long getuniqueipcountbydate(string date) {
return jedis.bitcount("ip:visited:" + date);
}
/**
* 获取连续多天都活跃的ip数量
*/
public long getactiveipsfordays(string[] dates) {
if (dates.length == 0) return 0;
string destkey = "temp:active:ips";
// 复制第一天的数据
jedis.bitop("and", destkey, "ip:visited:" + dates[0]);
// 对所有日期执行and操作
for (int i = 1; i < dates.length; i++) {
jedis.bitop("and", destkey, destkey, "ip:visited:" + dates[i]);
}
long count = jedis.bitcount(destkey);
jedis.del(destkey);
return count;
}
/**
* ip地址转为长整型
*/
private long iptolong(string ipaddress) {
try {
byte[] bytes = inetaddress.getbyname(ipaddress).getaddress();
long result = 0;
for (byte b : bytes) {
result = result << 8 | (b & 0xff);
}
return result;
} catch (unknownhostexception e) {
throw new illegalargumentexception("invalid ip address: " + ipaddress, e);
}
}
/**
* 长整型转为ip地址
*/
private string longtoip(long ip) {
return ((ip >> 24) & 0xff) + "." +
((ip >> 16) & 0xff) + "." +
((ip >> 8) & 0xff) + "." +
(ip & 0xff);
}
}
6.4 应用实例：ddos攻击防护
public class ddosprotection {
private ipaddresstracker iptracker;
private jedis jedis;
private string currentdatekey;
public ddosprotection(string host, int port) {
this.jedis = new jedis(host, port);
this.iptracker = new ipaddresstracker(host, port);
updatedatekey();
}
// 更新日期key
private void updatedatekey() {
string date = java.time.localdate.now().tostring();
this.currentdatekey = "ip:access:count:" + date;
}
/**
* 记录ip访问并检查是否超过阈值
* @return true表示ip应被阻止
*/
public boolean shouldblockip(string ipaddress, int accesslimit) {
// 先检查是否已在黑名单
if (iptracker.isblacklisted(ipaddress)) {
return true;
}
// 记录访问
long ipvalue = iptolong(ipaddress);
string accesskey = currentdatekey + ":" + ipaddress;
// 记录访问次数并检查
long accesscount = jedis.incr(accesskey);
// 设置24小时过期
if (accesscount == 1) {
jedis.expire(accesskey, 86400);
}
// 检查是否超过访问限制
if (accesscount > accesslimit) {
// 添加到黑名单
iptracker.addtoblacklist(ipaddress);
return true;
}
return false;
}
/**
* ip地址转为长整型
*/
private long iptolong(string ipaddress) {
try {
byte[] bytes = java.net.inetaddress.getbyname(ipaddress).getaddress();
long result = 0;
for (byte b : bytes) {
result = result << 8 | (b & 0xff);
}
return result;
} catch (java.net.unknownhostexception e) {
throw new illegalargumentexception("invalid ip address: " + ipaddress, e);
}
}
}
七、性能优化与最佳实践
bitmap在redis中高效强大，但使用时需注意以下几点
7.1 内存占用
- 精确计算：每8个bit占用1个字节，2^32位需要512mb
- 自动扩展：redis会根据设置的最大位偏移量自动扩展字符串
- 稀疏位图优化：对于非常稀疏的情况，可以考虑使用hash结构代替
7.2 操作效率
- 单点操作：getbit/setbit的时间复杂度为o(1)
- 范围操作：bitcount/bitpos在大范围时消耗较大，可以限定范围
- 位运算：bitop的性能与操作数长度成正比，应避免对超大的bitmap执行位运算
7.3 使用限制
- 偏移量上限：最大支持2^32-1的偏移量
- 原子性保证：所有位操作都是原子的，适合并发场景
- 持久化考虑：大量bitmap操作会增加aof文件大小和rdb快照时间
7.4 最佳实践
- 合理设计键名：使用一致的命名规则，便于管理
- 定期清理：为临时bitmap设置过期时间
- 批量操作：使用bitfield命令批量处理位操作
- 缓存结果：对于频繁计算的位统计结果，可以缓存
- 监控内存：大量bitmap可能导致内存激增，应监控内存使用
八、总结
在实际应用中，bitmap最大的优势是极低的内存消耗和o(1)的操作复杂度，非常适合处理大规模集合的成员关系问题。通过合理设计键结构和操作逻辑，bitmap可以解决传统方案难以应对的海量数据统计与分析挑战。
以上就是redis中5种bitmap应用场景及实现介绍的详细内容，更多关于redis实现bitmap的资料请关注代码网其它相关文章！
发表评论