最后
无论是哪家公司,都很重视基础,大厂更加重视技术的深度和广度,面试是一个双向选择的过程,不要抱着畏惧的心态去面试,不利于自己的发挥。同时看中的应该不止薪资,还要看你是不是真的喜欢这家公司,是不是能真的得到锻炼。
针对以上面试技术点,我在这里也做一些分享,希望能更好的帮助到大家。
// 带有定时功能的线程池
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
ScheduledFuture<?> scheduleTask = scheduler.scheduleWithFixedDelay(() -> {
// 阻塞3秒钟
Object o = redisTemplate.opsForList().rightPop("list:topic", 3, TimeUnit.SECONDS);
if(o != null){
System.out.println(o);
}
System.out.println("消费者尝试获取消息");
System.out.println(Thread.currentThread().getName() + "111" + new Date());
}, 1, 1, TimeUnit.SECONDS);//1秒初始化之后执行一次,以后每1秒执行一次(频率可以适当调节)
2.提出问题
list如何解决消息重复读取问题?
虽然说list只能读取一次,但是谁都无法保证生产者因为某种原因 会不会重复的生产相同的消息。
所以,基于redis的list,消费者只能自己本身来实现消息的幂等。
解决方案请继续往下看。
实现消息幂等
消息队列要能给每一个消息提供全局唯一的 ID 号;另一方面,消费者程序要把已经处理过的消息的 ID 号记录下来。
当收到一条消息后,消费者程序就可以对比收到的消息 ID 和记录的已处理过的消息 ID,来判断当前收到的消息有没有经过处理。如果已经处理过,那么,消费者程序就不再进行处理了。这种处理特性也称为幂等性,幂等性就是指,对于同一条消息,消费者收到一次的处理结果和收到多次的处理结果是一致的。
所以,该设计与redis本身无关,需要生产者与消费者达成一致协议,每一条消息生成一个唯一ID,用来判断重复消费问题。
保证消息可靠性
设想这样一个场景:
消费者收到消息之后,还没有处理完毕,消费者宕机了怎么办?
如果是Rabbitmq、Kafka这种消息队列,是有ack机制的,但是redis的list是没有这种机制的,怎么处理?
List 类型提供了 BRPOPLPUSH 命令,这个命令的作用是让消费者程序从一个 List 中读取消息,同时,Redis 会把这个消息再插入到另一个 List(可以叫作备份 List)留存。这样一来,如果消费者程序读了消息但没能正常处理,等它重启后,就可以从备份 List 中重新读取消息并进行处理了。
// 带有定时功能的线程池
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
ScheduledFuture<?> scheduleTask = scheduler.scheduleWithFixedDelay(() -> {
// 阻塞3秒钟,并生成备份
Object o = redisTemplate.opsForList().rightPopAndLeftPush("list:topic", "list:topic:back", 3, TimeUnit.SECONDS);
if(o != null){
System.out.println(o);
}
System.out.println("消费者尝试获取消息");
System.out.println(Thread.currentThread().getName() + "111" + new Date());
}, 1, 1, TimeUnit.SECONDS);//1秒初始化之后执行一次,以后每1秒执行一次(频率可以适当调节)
但是以上要手动实现备份中哪些已经消费,哪些未被消费,实现起来还是比较麻烦的。。。
redis中有一种数据类型——stream,可以完美实现消息队列。
基于stream的消息队列解决方案(redis消息队列终极解决方案)
关于stream基本用法请移步:redis中stream数据结构使用详解——redis最适合做消息队列的数据结构
stream可以完美实现消息保序、自动生成消息唯一id、同时对消息的可靠性也有保障,提供了ack机制。
springboot使用stream实现消息队列
1.生产者不断生产消息
Random random = new Random();
Map<String, String> content = new HashMap<>();
content.put("id", "1");
content.put("name", "zhangsan");
content.put("age", String.valueOf(random.nextInt(1000)));
redisTemplate.opsForStream().add("stream:topic", content);
2.工具类
public String createGroup(String key, String group){
return redisTemplate.opsForStream().createGroup(key, group);
}
public String addMap(String key, Map<String, String> value){
return redisTemplate.opsForStream().add(key, value).getValue();
}
public String addRecord(Record<String, Object> record){
return redisTemplate.opsForStream().add(record).getValue();
}
public Long ack(String key, String group, String... recordIds){
return redisTemplate.opsForStream().acknowledge(key, group, recordIds);
}
public Long del(String key, String... recordIds){
return redisTemplate.opsForStream().delete(key, recordIds);
}
3.创建消费者1
此处为了简化,直接使用匿名内部类定义了个bean,实际开发时可以单独定义一个类。
/\*\*
\* 消费者A
\*/
@Bean
public StreamListener consumer1(RedisStreamUtil redisStreamUtil){
return new StreamListener<String, MapRecord<String, String, String>>() {
@Override
public void onMessage(MapRecord<String, String, String> message) {
String stream = message.getStream();
RecordId id = message.getId();
Map<String, String> map = message.getValue();
System.out.println("[自动ack] group:[group-a] consumerName:[{consumer1}] 接收到一个消息 stream:[{"+stream+"}],id:[{"+id+"}],value:[{"+map+"}]");
redisStreamUtil.ack(stream, "group-a", id.getValue());
redisStreamUtil.del(stream, id.getValue());
}
};
}
4.创建消费者2
/\*\*
\* 消费者B
\*/
@Bean
public StreamListener consumer2(RedisStreamUtil redisStreamUtil){
return new StreamListener<String, MapRecord<String, String, String>>() {
@Override
public void onMessage(MapRecord<String, String, String> message) {
String stream = message.getStream();
RecordId id = message.getId();
Map<String, String> map = message.getValue();
System.out.println("[不自动ack] group:[group-b] consumerName:[{consumer2}] 接收到一个消息 stream:[{"+stream+"}],id:[{"+id+"}],value:[{"+map+"}]");
redisStreamUtil.del(stream, id.getValue());
}
};
}
5.配置消费者组
此处也做了部分简化,实际开发可以适当调整
@Bean(initMethod = "start", destroyMethod = "stop")
public StreamMessageListenerContainer<String, MapRecord<String, String, String>> streamMessageListenerContainer(StreamListener consumer1, StreamListener consumer2) {
AtomicInteger index = new AtomicInteger(1);
int processors = Runtime.getRuntime().availableProcessors();
ThreadPoolExecutor executor = new ThreadPoolExecutor(processors, processors, 0, TimeUnit.SECONDS,
new LinkedBlockingDeque<>(), r -> {
Thread thread = new Thread(r);
thread.setName("async-stream-consumer-" + index.getAndIncrement());
thread.setDaemon(true);
return thread;
});
StreamMessageListenerContainer.StreamMessageListenerContainerOptions<String, MapRecord<String, String, String>> options =
StreamMessageListenerContainer.StreamMessageListenerContainerOptions
.builder()
// 一次最多获取多少条消息
.batchSize(3)
// 运行 Stream 的 poll task
.executor(executor)
// Stream 中没有消息时,阻塞多长时间,需要比 `spring.redis.timeout` 的时间小
.pollTimeout(Duration.ofSeconds(3))
// 获取消息的过程或获取到消息给具体的消息者处理的过程中,发生了异常的处理
//.errorHandler(new StreamErrorHandler())
.build();
StreamMessageListenerContainer<String, MapRecord<String, String, String>> streamMessageListenerContainer =
StreamMessageListenerContainer.create(redisTemplate.getConnectionFactory(), options);
// 独立消费
String streamKey = "stream:topic";
// 消费者也可以直接使用new的方式创建出来,但是此处为了简化,直接注入了
// 消费组A,自动ack
// 从消费组中没有分配给消费者的消息开始消费
streamMessageListenerContainer.receiveAutoAck(Consumer.from("group-a", "consumer-a"),
StreamOffset.create(streamKey, ReadOffset.lastConsumed()), consumer1);
// 消费组B,不自动ack
streamMessageListenerContainer.receive(Consumer.from("group-b", "consumer-a"),
StreamOffset.create(streamKey, ReadOffset.lastConsumed()), consumer2);
return streamMessageListenerContainer;
}
5.测试一下
(1)先手动创建出队列、消费者组
127.0.0.1:6379> xadd stream:topic * id 0 name test
"1663116545477-0"
127.0.0.1:6379> xgroup create stream:topic group-a 0-0
OK
127.0.0.1:6379> xgroup create stream:topic group-b 0-0
OK
(2)生产者发送多个消息
(3)消费者进行消费
[自动ack] group:[group-a] consumerName:[{consumer1}] 接收到一个消息 stream:[{stream:topic}],id:[{1663117003190-0}],value:[{{name=zhangsan, id=1, age=937}}]
[不自动ack] group:[group-b] consumerName:[{consumer2}] 接收到一个消息 stream:[{stream:topic}],id:[{1663117003190-0}],value:[{{name=zhangsan, id=1, age=937}}]
[自动ack] group:[group-a] consumerName:[{consumer1}] 接收到一个消息 stream:[{stream:topic}],id:[{1663117006145-0}],value:[{{name=zhangsan, id=1, age=97}}]
[不自动ack] group:[group-b] consumerName:[{consumer2}] 接收到一个消息 stream:[{stream:topic}],id:[{1663117006145-0}],value:[{{name=zhangsan, id=1, age=97}}]
[自动ack] group:[group-a] consumerName:[{consumer1}] 接收到一个消息 stream:[{stream:topic}],id:[{1663117007311-0}],value:[{{name=zhangsan, id=1, age=539}}]
[不自动ack] group:[group-b] consumerName:[{consumer2}] 接收到一个消息 stream:[{stream:topic}],id:[{1663117007311-0}],value:[{{name=zhangsan, id=1, age=539}}]
[自动ack] group:[group-a] consumerName:[{consumer1}] 接收到一个消息 stream:[{stream:topic}],id:[{1663117007934-0}],value:[{{name=zhangsan, id=1, age=905}}]
[不自动ack] group:[group-b] consumerName:[{consumer2}] 接收到一个消息 stream:[{stream:topic}],id:[{1663117007934-0}],value:[{{name=zhangsan, id=1, age=905}}]
5.未自动ack的消息,会放在pending队列中
127.0.0.1:6379> xpending stream:topic group-a - + 5
(empty array)
127.0.0.1:6379> xpending stream:topic group-b - + 5
1) 1) "1663117003190-0"
2) "consumer-a"
3) (integer) 54462
4) (integer) 1
2) 1) "1663117006145-0"
2) "consumer-a"
3) (integer) 51507
4) (integer) 1
3) 1) "1663117007311-0"
2) "consumer-a"
3) (integer) 50341
4) (integer) 1
4) 1) "1663117007934-0"
2) "consumer-a"
3) (integer) 49718
4) (integer) 1
在SpringBoot中重新消费Redis Stream中未ACK的消息
消费组从stream中获取到消息后,会分配给自己组中其中的一个消费者进行消费,消费者消费完毕,需要给消费组返回ACK,表示这条消息已经消费完毕了。
当消费者从消费组获取到消息的时候,会先把消息添加到自己的pending消息列表,当消费者给消费组返回ACK的时候,就会把这条消息从pending队列删除。(每个消费者都有自己的pending消息队列)
消费者可能没有及时的返回ACK。例如消费者消费完毕后,宕机,没有及时返回ACK,此时就会导致这条消息占用2倍的内存(stream中保存一份, 消费者的的pending消息列表中保存一份)
1.遍历消费者的pending列表,读取到未ACK的消息,直接进行ACK
遍历消费组的pending消息情况,再遍历每个消费者的pending消息id列表,再根据id,直接去stream读取这条消息,进行消费Ack。
import java.time.Duration;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.data.domain.Range;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.PendingMessages;
import org.springframework.data.redis.connection.stream.PendingMessagesSummary;
import org.springframework.data.redis.connection.stream.RecordId;
import org.springframework.data.redis.core.StreamOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;
import io.springboot.jwt.SpringBootJwtApplication;
@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringBootJwtApplication.class, webEnvironment = WebEnvironment.RANDOM_PORT)
public class RedisStreamTest {
private static final Logger LOGGER = LoggerFactory.getLogger(RedisStreamTest.class);
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Test
public void test() {
StreamOperations<String, String, String> streamOperations = this.stringRedisTemplate.opsForStream();
// 获取group-b中的pending消息信息,本质上就是执行XPENDING指令
PendingMessagesSummary pendingMessagesSummary = streamOperations.pending("stream:topic", "group-b");
// 所有pending消息的数量
long totalPendingMessages = pendingMessagesSummary.getTotalPendingMessages();
// 消费组名称
String groupName= pendingMessagesSummary.getGroupName();
// pending队列中的最小ID
String minMessageId = pendingMessagesSummary.minMessageId();
// pending队列中的最大ID
String maxMessageId = pendingMessagesSummary.maxMessageId();
LOGGER.info("消费组:{},一共有{}条pending消息,最大ID={},最小ID={}", groupName, totalPendingMessages, minMessageId, maxMessageId);
// 每个消费者的pending消息数量
Map<String, Long> pendingMessagesPerConsumer = pendingMessagesSummary.getPendingMessagesPerConsumer();
pendingMessagesPerConsumer.entrySet().forEach(entry -> {
// 消费者
String consumer = entry.getKey();
// 消费者的pending消息数量
long consumerTotalPendingMessages = entry.getValue();
LOGGER.info("消费者:{},一共有{}条pending消息", consumer, consumerTotalPendingMessages);
if (consumerTotalPendingMessages > 0) {
// 读取消费者pending队列的前10条记录,从ID=0的记录开始,一直到ID最大值
PendingMessages pendingMessages = streamOperations.pending("stream:topic", Consumer.from("group-b", consumer), Range.closed("0", "+"), 10);
// 遍历所有Opending消息的详情
pendingMessages.forEach(message -> {
// 消息的ID
RecordId recordId = message.getId();
// 消息从消费组中获取,到此刻的时间
Duration elapsedTimeSinceLastDelivery = message.getElapsedTimeSinceLastDelivery();
// 消息被获取的次数
long deliveryCount = message.getTotalDeliveryCount();
LOGGER.info("openg消息,id={}, elapsedTimeSinceLastDelivery={}, deliveryCount={}", recordId, elapsedTimeSinceLastDelivery, deliveryCount);
/\*\*
\* 演示手动消费的这个判断非常的针对,目的就是要读取消费者“consumer-a”pending消息中,ID=1605524665215-0的这条消息
\*/
if (consumer.equals("consumer1") && recordId.toString().equals("1605524665215-0")) {
// 通过streamOperations,直接读取这条pending消息,
List<MapRecord<String, String, String>> result = streamOperations.range("stream:topic", Range.rightOpen("1605524665215-0", "1605524665215-0"));
// 开始和结束都是同一个ID,所以结果只有一条
MapRecord<String, String, String> record = result.get(0);
// 这里执行日志输出,模拟的就是消费逻辑
LOGGER.info("消费了pending消息:id={}, value={}", record.getId(), record.getValue());
// 如果手动消费成功后,往消费组提交消息的ACK
Long retVal = streamOperations.acknowledge("group-b", record);
LOGGER.info("消息ack,一共ack了{}条", retVal);
}
});
}
});
}
}
最终的结果就是,消费者1的唯一一条pending消息被Ack了,这里有几个点要注意
遍历消费者pending列表时候,最小/大消息id,可以根据XPENDING指令中的结果来,我写0 - +,只是为了偷懒
遍历到消费者pending消息的时候,可以根据elapsedTimeSinceLastDelivery(idle time)和deliveryCount(delivery counter)做一些逻辑判断,elapsedTimeSinceLastDelivery越长,表示这条消息被消费了很久,都没Ack,deliveryCount表示重新投递N次后,都没被消费成功,可能是消费逻辑有问题,或者是Ack有问题。
2.通过XCLAIM改变消息的消费者
如果一个消费者,一直不能消费掉某条消息,或者说这个消费者因为某些消息,永远也不能上过线了,那么可以把这个消费者的pending消息,转移到其他的消费者pending列表中,重新消费
其实我们这里要做的事情,就是把“消费者2”的唯一1条pending消息“ 1605524657157-0”(message2),交给“消费者1”,重新进行消费。
import java.time.Duration;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.stream.ByteRecord;
import org.springframework.data.redis.connection.stream.RecordId;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;
import io.springboot.jwt.SpringBootJwtApplication;
@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringBootJwtApplication.class, webEnvironment = WebEnvironment.RANDOM_PORT)
public class RedisStreamTest {
private static final Logger LOGGER = LoggerFactory.getLogger(RedisStreamTest.class);
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Test
public void test() {
List<ByteRecord> retVal = this.stringRedisTemplate.execute(new RedisCallback<List<ByteRecord>>() {
@Override
public List<ByteRecord> doInRedis(RedisConnection connection) throws DataAccessException {
// XCLAIM 指令的实现方法
return connection.streamCommands().xClaim("stream:topic".getBytes(), "group-b", "consumer-a", Duration.ofSeconds(10), RecordId.of("1605524657157-0"));
}
# 总结
谈到面试,其实说白了就是刷题刷题刷题,天天作死的刷。。。。。
为了准备这个“金三银四”的春招,狂刷一个月的题,狂补超多的漏洞知识,像这次美团面试问的算法、数据库、Redis、设计模式等这些题目都是我刷到过的
**并且我也将自己刷的题全部整理成了PDF或者Word文档(含详细答案解析)**
![我的美团offer凉凉了?开发工程师(Java岗)三面结束等通知...](https://img-blog.csdnimg.cn/img_convert/44e4acc63d1db8ba174099327090c2e6.webp?x-oss-process=image/format,png)
66个Java面试知识点
**架构专题(MySQL,Java,Redis,线程,并发,设计模式,Nginx,Linux,框架,微服务等)+大厂面试题详解(百度,阿里,腾讯,华为,迅雷,网易,中兴,北京中软等)**
![我的美团offer凉凉了?开发工程师(Java岗)三面结束等通知...](https://img-blog.csdnimg.cn/img_convert/519e51b14944c2320d7a3ce2c0b91f1b.webp?x-oss-process=image/format,png)
**算法刷题(PDF)**
![我的美团offer凉凉了?开发工程师(Java岗)三面结束等通知...](https://img-blog.csdnimg.cn/img_convert/7aad0e0693c86a188a835df902654803.webp?x-oss-process=image/format,png)
> **本文已被[CODING开源项目:【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)收录**
**[需要这份系统化的资料的朋友,可以点击这里获取](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**
的
**并且我也将自己刷的题全部整理成了PDF或者Word文档(含详细答案解析)**
[外链图片转存中...(img-nkdiiWPE-1715467708283)]
66个Java面试知识点
**架构专题(MySQL,Java,Redis,线程,并发,设计模式,Nginx,Linux,框架,微服务等)+大厂面试题详解(百度,阿里,腾讯,华为,迅雷,网易,中兴,北京中软等)**
[外链图片转存中...(img-qagEUJZP-1715467708283)]
**算法刷题(PDF)**
[外链图片转存中...(img-eHzlf0uC-1715467708284)]
> **本文已被[CODING开源项目:【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)收录**
**[需要这份系统化的资料的朋友,可以点击这里获取](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**