Redission及BloomFilter总结

一、简介

BloomFilter是一种有状态数据结构，用来表征某元素是否曾来访过。但其结果是基于统计学的，亦即不保证严格的准确性。
其时间、空间效率都非常高，可以用在各种需要判断是否再次来访，同时容忍一定误差的场景下。
特性：

若来过：100%，会返回true；
未来过：小概率会返回true；

二、优点：

1.写入、查询效率都非常高，得益于元素在写入、查询的寻址过程，采用的都是n个hash函数，其时间复杂度是O(1).
2.另外，底层用于存储状态的是bitArray结构，非常省空间。

三、缺点：

1.对于两个不同元素，由于hash碰撞无法避免，且底层用的bit表示状态，所以通过n个hash函数计算后可能落在相同的slot上。所以结果只是一个概率性的表征，不保证百分百的准确。

四、核心：

1.BloomFilter主要由n个hash函数 + 容量为k的bitArray构成，hash函数用于计算来访元素的hash值，用bitArray上slot来存放元素是否来访过的状态。
2.初始化时：底层bitArray每个slot的value默认全为0。
3.插入过程：将元素e，经过n个不同的hash函数计算，散落到bitArray上的n（若不同hash函数的计算结果发生重复，可能小于n）个slot上，对应slot上的value设为1。
4.查询过程：将元素e，经过n个不同的hash函数计算，对应到bitArray上的slot，分别取出这些slot上的value，若全部value都为1，则返回true，否则返回false。

五、注意：

由于存在不同元素的hash值，会落到同一个slot的问题，slot的value又只是二元的。删、改时的定位结果不能实现严密的元素间隔离，可能会造成误杀。所以BloomFilter不支持删除、修改操作。

六、spring-boot-redisson实现

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.12</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.yang</groupId>
    <artifactId>spring-boot-redission</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-boot-redisson</name>
    <description>spring-boot-redisson</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--Redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <!--Redisson依赖-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.20.1</version>
        </dependency>

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>31.1-jre</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=redis
spring.redis.database=1

package com.yang.springbootredisson;

import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;
import lombok.AllArgsConstructor;
import lombok.Data;
import org.junit.jupiter.api.Test;
import org.redisson.api.*;
import org.redisson.api.map.event.EntryEvent;
import org.redisson.api.map.event.EntryExpiredListener;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
import java.nio.charset.Charset;
import java.time.LocalDateTime;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

@SpringBootTest
class SpringBootRedissonApplicationTests {

    @Resource
    private RedissonClient redissonClient;

    /**
     * 1.分布式锁-排队等待（阻塞、无超时机制）
     */
    @Test
    public void block() {
        RLock rlock = this.redissonClient.getLock("lock_0");  // 获取非公平锁
        // RLock rlock = this.redissonClient.getFairLock("lock_0");  // 获取公平锁
        rlock.lock();
        try {
            System.out.println(LocalDateTime.now() + Thread.currentThread().getName());
            TimeUnit.SECONDS.sleep(50L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (Objects.nonNull(rlock) && rlock.isHeldByCurrentThread()) {
                rlock.unlock();
            }
        }
    }

    /**
     * 2.分布式锁-立即返回
     */
    @Test
    public void returnImmediately() {
        RLock rlock = this.redissonClient.getLock("lock_0");
        if (rlock.tryLock()) {
            try {
                System.out.println(LocalDateTime.now() + Thread.currentThread().getName());
                TimeUnit.SECONDS.sleep(2L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                if (Objects.nonNull(rlock) && rlock.isHeldByCurrentThread()) {
                    rlock.unlock();
                }
            }
        } else {
            System.err.println("拿锁失败");
        }
    }

    /**
     * 3.分布式锁-超时后返回（推荐用法，防止死锁）
     */
    @Test
    public void returnAfterTimeOut() {
        RLock rlock = this.redissonClient.getLock("lock_0");
        try {
            if (rlock.tryLock(5, 10, TimeUnit.SECONDS)) {  //拿锁的超时时间为5s，持有锁后超过10s将强制释放（防止死锁）
                try {
                    System.out.println(LocalDateTime.now() + Thread.currentThread().getName());
                    TimeUnit.SECONDS.sleep(2L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    if (Objects.nonNull(rlock) && rlock.isHeldByCurrentThread()) {
                        rlock.unlock();
                    }
                }
            } else {
                System.err.println("拿锁失败");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 1.向Redis创建一个限流器（随项目启动初始化）
     */
    @Test
    public void initRateLimiter() {
        RRateLimiter rRateLimiter = this.redissonClient.getRateLimiter("myRateLimiter");
        rRateLimiter.trySetRate(RateType.PER_CLIENT, 5, 10, RateIntervalUnit.SECONDS);  // 每10s，发放5个token
    }

    /**
     * 2.使用限流器
     */
    @Test
    public void useRateLimiter() {
        RRateLimiter rRateLimiter = this.redissonClient.getRateLimiter("myRateLimiter");
        if (rRateLimiter.tryAcquire(2, 4, TimeUnit.SECONDS)) {  //尝试获取token，等待2s即放弃；假设持有token，4s强制释放，避免死锁
            System.out.println("拿到了token");
        } else {
            System.err.println("未拿到token");
        }

    }

    @Test
    public void mapTest() {
        RMapCache<Object, Object> myMapCache = this.redissonClient.getMapCache("myMapCache");
        myMapCache.addListener((EntryExpiredListener<String, EntryEvent>) entryEvent -> {

        });
    }

    /**
     * Redisson-BloomFilter
     */
    @Test
    public void bloomFilterTest() {
        RBloomFilter<User> myBloomFilter = this.redissonClient.getBloomFilter("1myBloomFilter");
        myBloomFilter.tryInit(2048L, 0.01D); //初始化bitArray容量、设置能容忍的误差概率
        myBloomFilter.add(new User(1L, "1"));
        myBloomFilter.add(new User(2L, "2"));
        myBloomFilter.add(new User(3L, "3"));
        myBloomFilter.add(new User(4L, "4"));
        // myBloomFilter.add(new User(5L, "5"));
        System.err.println(myBloomFilter.contains(new User(2L, "2")));  // true
        System.err.println(myBloomFilter.contains(new User(5L, "5")));  // false
    }

}

@Data
@AllArgsConstructor
class User {

    private Long id;

    private String name;

}

七、Guava实现

/**
 * Guava-BloomFilter
 * 1.funnel：漏斗，Guava内置了【byteArrayFunnel、unencodedCharsFunnel、stringFunnel、integerFunnel、sequentialFunnel、longFunnel】几个静态方法，方便使用。
 * 2.BloomFilter中的数组空间大小、hash函数的个数都由参数expectedInsertions 、fdd共同确定。
 */
@Test
public void guavaBloomFilterTest() {
    BloomFilter<CharSequence> bloomFilter = BloomFilter.create(Funnels.stringFunnel(Charset.defaultCharset()), 1000);
    BloomFilter<CharSequence> bloomFilter0 = BloomFilter.create(Funnels.stringFunnel(Charset.defaultCharset()), 1000, 0.01D);
    BloomFilter<CharSequence> bloomFilter1 = BloomFilter.create(Funnels.stringFunnel(Charset.defaultCharset()), 2000L);
    BloomFilter<CharSequence> bloomFilter2 = BloomFilter.create(Funnels.stringFunnel(Charset.defaultCharset()), 2000L, 0.02D);

    bloomFilter.put("1");
    bloomFilter.put("2");
    bloomFilter.put("3");
    bloomFilter.put("4");

    System.err.println(bloomFilter.mightContain("1"));  // true
    System.err.println(bloomFilter.mightContain("5"));  // false
}

posted @ 2023-07-03 15:10 JaxYoun 阅读(148) 评论(0) 收藏举报

刷新页面返回顶部

JaxYoun

莫春者，春服既成，冠者五六人，童子六七人，浴乎沂，风乎舞雩，咏而归。

Redission及BloomFilter总结

一、简介

二、优点：

三、缺点：

四、核心：

五、注意：

六、spring-boot-redisson实现

七、Guava实现

公告

JaxYoun

莫春者，春服既成， 冠者五六人，童子六七人， 浴乎沂，风乎舞雩，咏而归。

Redission及BloomFilter总结

一、简介

二、优点：

三、缺点：

四、核心：

五、注意：

六、spring-boot-redisson实现

七、Guava实现

公告

莫春者，春服既成，冠者五六人，童子六七人，浴乎沂，风乎舞雩，咏而归。