redisrabbitmq秒殺

⑴ redis隊列和消息隊列的區別

redis
消息推來送（基於分布式源
pub/sub）多用於實時性較高的消息推送，並不保證可靠。
其他的mq和kafka保證可靠但有一些延遲（非實時系統沒有保證延遲）。
redis-pub/sub斷電就清空，而使用redis-list作為消息推送雖然有持久化，但是又太弱智，也並非完全可靠不會丟。

⑵ redis消息隊列先進先出需要注意什麼

通常使用一個list來實現隊列操作，這樣有一個小限制，所以的任務統一都是專先進先出，如果想優先屬處理某個任務就不太好處理了，這就需要讓隊列有優先順序的概念，我們就可以優先處理高級別的任務，實現方式有以下幾種方式：
1）單一列表實現：隊列正常的操作是 左進右出（lpush,rpop）為了先處理高優先順序任務，在遇到高級別任務時，可以直接插隊，直接放入隊列頭部（rpush），這樣，從隊列頭部（右側）獲取任務時，取到的就是高優先順序的任務（rpop），最簡單，但實際應用比較局限。
2）使用兩個隊列，一個普通隊列，一個高級隊列，針對任務的級別放入不同的隊列，獲取任務時也很簡單，redis的BRPOP命令可以按順序從多個隊列中取值，BRPOP會按照給出的 key 順序查看，並在找到的第一個非空 list 的尾部彈出一個元素，redis> BRPOP list1 list2 0，推薦用法，實際應用最為合適。
list1 做為高優先順序任務隊列 list2 做為普通任務隊列
這樣就實現了先處理高優先順序任務，當沒有高優先順序任務時，就去獲取普通任務。

⑶ redis消息隊列怎樣處理失敗狀態

1. redis中保存的是數組(序列化)，絕對不要保存SQL,保存SQL的方法很蛋疼 保存數組是為了資料庫回安全答(萬一sql語句有錯誤，任務就直接失敗了)，靈活度和兼容性

2.伺服器後台作一個shell腳本，死循環，不斷從隊列中取數據，進行處理．如次反復，如果沒有數據，也立即嘗試取數據－－－不要擔心性能問題，後台單並發請求，不會造成性能問題

3.因為隊列中保存的是數組，不存在這個問題

⑷ 消息隊列為什麼用redis實現

redis只是提供一個高性能的、原子操作的分布式隊列實現。具體的業務還專是得需要你自己定製屬。
你的需求實際上是一個變形的生產者-消費者實現。對於此類需求，主要是將請求和實際的處理過程解耦，一般都是採取非同步的方式來通知請求方，這跟用不用redis其實沒有多大的關系。一般的實現方法是你需要將用戶的請求封裝成一個Task，然後將這個Task再push到redis隊列，然後後端的worker.php完全可以多進程、多線程的並發處理Task並將處理結果回調給請求方。這里唯一麻煩點的就是這個Task的設計，需要能夠包含請求信息(請求內容，請求方標識等等).

⑸ suricata+mysql+redis+rabbitmq 需要多少內存

具體的業務還是得需要你自己定製。
你的需求實際上是一個變形的生產者-消費回者實現。答對於此類需求，主要是將請求和實際的處理過程解耦，一般都是採取非同步的方式來通知請求方，這跟用不用redis其實沒有多大的關系。一般的實現方法是你需要將用戶的請求封裝成一個Task，然後將這個Task再push到redis隊列，然後後端的worker.php完全可以多進程、多線程的並發處理Task並將處理結果回調給請求方。這里唯一麻煩點的就是這個Task的設計，需要能夠包含請求信息(請求內容，請求方標識等等).

⑹ flume怎麼取redis消息隊列數據

如果說是消息隊復列制，flume需要redis組件，或則自己開發flume獲取redis消息。
對於官網提供的內容：
http://flume.apache.org/FlumeUserGuide.html

如果說是存在磁碟上的，flume應該都是可以的。

⑺ redis消息隊列有沒有

基於Redis消息隊列-實現簡訊服務化
1.Redis實現消息隊列原理
常用的消息隊列有RabbitMQ,ActiveMQ，個人覺得這種消息隊列太大太重，本文介紹下基於Redis的輕量級消息隊列服務。
一般來說，消息隊列有兩種模式，一種是發布者訂閱模式，另外一種是生產者和消費者模式。Redis的消息隊列，也是基於這2種原理的實現。
發布者和訂閱者模式：發布者發送消息到隊列，每個訂閱者都能收到一樣的消息。
生產者和消費者模式：生產者將消息放入隊列，多個消費者共同監聽，誰先搶到資源，誰就從隊列中取走消息去處理。注意，每個消息只能最多被一個消費者接收。
2.Redis消息隊列使用場景
在我們的項目中，使用消息隊列來實現簡訊的服務化，任何需要發送簡訊的模塊，都可以直接調用簡訊服務來完成簡訊的發送。比如用戶系統登錄注冊簡訊，訂單系統的下單成功的簡訊等。
3.SpringMVC中實現Redis消息隊列
因為我們簡訊只需要發送一次，所以我們使用的是消息隊列的生產者和消費者模式。
3.1引入Maven依賴
引入Redis相應的maven依賴，這里需要spring-data-redis和jedis
//pom.xml <dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.6.0.RELEASE</version>
</dependency>

<!-- jedis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.5.1</version>
</dependency>12345678910111213

3.2配置redis生成者消費者模式
//applicationContext-redis.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:mvc="http://www.springframework.org/schema/mvc"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:cache="http://www.springframework.org/schema/cache"
xmlns:redis="http://www.springframework.org/schema/redis"
xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-34.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-4.0.xsd
http://www.springframework.org/schema/redis http://www.springframework.org/schema/redis/spring-redis-1.0.xsd">
<description>spring-data-redis配置</description>

<bean id="redisConnectionFactory"
class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
<property name="hostName" value="${redis.host}"></property>
<property name="port" value="${redis.port}"></property>
<property name="usePool" value="true"></property>
</bean>

<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
<property name="connectionFactory" ref="redisConnectionFactory"></property>
</bean>

<bean id="jdkSerializer"
class="org.springframework.data.redis.serializer." />

<bean id="smsMessageListener"
class="org.springframework.data.redis.listener.adapter.MessageListenerAdapter">
<property name="delegate" ref="smsMessageDelegateListener" />
<property name="serializer" ref="jdkSerializer" />
</bean>

<bean id="sendMessage" class="com.djt.common.cache.redis.queue.SendMessage">
<property name="redisTemplate" ref="redisTemplate"/>
</bean>

<redis:listener-container>
<redis:listener ref="smsMessageListener" method="handleMessage"
serializer="jdkSerializer" topic="sms_queue_web_online" />
</redis:listener-container>

<!-- jedis -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxIdle" value="300" /> <!-- 最大能夠保持idel狀態的對象數 -->
<property name="maxTotal" value="60000" /> <!-- 最大分配的對象數 -->
<property name="testOnBorrow" value="true" /> <!-- 當調用borrow Object方法時，是否進行有效性檢查 -->
</bean>

<bean id="jedisPool" class="redis.clients.jedis.JedisPool">
<constructor-arg index="0" ref="jedisPoolConfig" />
<constructor-arg index="1" value="${redis.host}" />
<constructor-arg index="2" value="${redis.port}" type="int" />
</bean></beans>

主要的配置說明：
1.序列化：一般我們向Redis發送一個消息定義的Java對象，這個對象需要序列化。這里使用：
<bean id="jdkSerializer" class="org.springframework.data.redis.serializer." />1

2.發送者：
<bean id="sendMessage" class="com.djt.common.cache.redis.queue.SendMessage">
<property name="redisTemplate" ref="redisTemplate"/>
</bean>123

3.監聽者：
<bean id="smsMessageListener"
class="org.springframework.data.redis.listener.adapter.MessageListenerAdapter">
<property name="delegate" ref="smsMessageDelegateListener" />
<property name="serializer" ref="jdkSerializer" />
</bean>
<redis:listener-container>
<redis:listener ref="smsMessageListener" method="handleMessage"
serializer="jdkSerializer" topic="sms_queue_web_online" />
</redis:listener-container>123456789

smsMessageListener：消息監聽器
redis:listener-container：定義消息監聽，method：監聽消息執行的方法，serializer：序列化，topic：監聽主題（可以理解為隊列名稱）
3.3代碼實現
1.定義簡訊消息對象SmsMessageVo
public class SmsMessageVo implements Serializable {
//id
private Integer smsId; //手機號
private String mobile; //類型，1：驗證碼 2：訂單通知
private Byte type; //簡訊創建時間
private Date createDate; //簡訊消息處理時間
private Date processTime; //簡訊狀態，1：未發送 2：發送成功 3：發送失敗
private Byte status; //簡訊內容
private String content; //省略setter和getter方法
...

2.定義消息隊列發送對象SendMessage
//SendMessage.javapublic class SendMessage { private RedisTemplate<String, Object> redisTemplate; public RedisTemplate<String, Object> getRedisTemplate() { return redisTemplate;
} public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) { this.redisTemplate = redisTemplate;
} public void sendMessage(String channel, Serializable message) {
redisTemplate.convertAndSend(channel, message);
}
}

3.發送消息
String smsContent = templateToContent(template.getContent(),
regMsgCode);
SmsMessageVo smsMessageVo = new SmsMessageVo();
smsMessageVo.setMobile(mobile);
smsMessageVo.setType((byte) SmsType.VERIFICATION.getType());
smsMessageVo.setChannelId(1);
smsMessageVo.setContent(smsContent);
smsMessageVo.setCreateDate(new Date());
smsMessageVo.setStatus((byte) SmsSendStatus.TO_SEND.getType());
smsMessageVo.setTemplateId(1);

//先把待發送的簡訊存入資料庫
SmsQueue smsQueue = new SmsQueue();
BeanUtils.Properties(smsQueue, smsMessageVo);
smsQueueService.addSmsQueue(smsQueue);

//非同步發送簡訊到redis隊列
sendMessage.sendMessage(Constants.REDIS_QUEUE_SMS_WEB, smsMessageVo);
//Constants.REDIS_QUEUE_SMS_WEB = "sms_queue_web_online",和applicationContext-redis中topic配置一樣

4.監聽消息
//SmsMessageDelegateListener.java@Component("smsMessageDelegateListener")public class SmsMessageDelegateListener {

@Autowired
private SmsQueueService smsQueueService; //監聽Redis消息
public void handleMessage(Serializable message){ if(message instanceof SmsMessageVo){
SmsMessageVo messageVo = (SmsMessageVo) message; //發送簡訊
SmsSender smsSender = SmsSenderFactory.buildEMaySender();
smsSender.setMobile(messageVo.getMobile());
smsSender.setContent(messageVo.getContent()); boolean sendSucc = false; //判斷簡訊類型
//驗證碼簡訊
if(messageVo.getType() == (byte)SmsType.VERIFICATION.getType()){
sendSucc = smsSender.send();
} if(!sendSucc){ return;
} // 非同步更新簡訊表狀態為發送成功
final Integer smsId = messageVo.getSmsId();
Executor executor = Executors.newSingleThreadExecutor();
executor.execute(new Runnable() { public void run() {
SmsQueue smsQueue = new SmsQueue();
smsQueue.setSmsId(smsId);
smsQueue.setStatus((byte)SmsSendStatus.SEND.getType());
smsQueue.setProcessTime(new Date());
smsQueueService.updateSmsQueue(smsQueue);
}
});

}
}
}04142434445

4.總結
下面使用一張流程圖，來總結Redis消息隊列和簡訊服務。

⑻ net redis 和rabbitmq 有什麼區別

RabbitMQ
RabbitMQ是實現AMQP（高級消息隊列協議）的消息中間件的一種，最初起源於金融系統，用於在分布式系統中存儲轉發消息，在易用性、擴展性、高可用性等方面表現不俗。消息中間件主要用於組件之間的解耦，消息的發送者無需知道消息使用者的存在，反之亦然。
Redis
是一個Key-Value的NoSQL資料庫，開發維護很活躍，雖然它是一個Key-Value資料庫存儲系統，但它本身支持MQ功能，所以完全可以當做一個輕量級的隊列服務來使用。
具體對比
可靠消費
Redis：沒有相應的機制保證消息的消費，當消費者消費失敗的時候，消息體丟失，需要手動處理
RabbitMQ：具有消息消費確認，即使消費者消費失敗，也會自動使消息體返回原隊列，同時可全程持久化，保證消息體被正確消費
可靠發布
Reids：不提供，需自行實現
RabbitMQ：具有發布確認功能，保證消息被發布到伺服器
高可用
Redis：採用主從模式，讀寫分離，但是故障轉移還沒有非常完善的官方解決方案
RabbitMQ：集群採用磁碟、內存節點，任意單點故障都不會影響整個隊列的操作
持久化
Redis：將整個Redis實例持久化到磁碟
RabbitMQ：隊列，消息，都可以選擇是否持久化
消費者負載均衡
Redis：不提供，需自行實現
RabbitMQ：根據消費者情況，進行消息的均衡分發
隊列監控
Redis：不提供，需自行實現
RabbitMQ：後台可以監控某個隊列的所有信息，（內存，磁碟，消費者，生產者，速率等）
流量控制
Redis：不提供，需自行實現
RabbitMQ：伺服器過載的情況，對生產者速率會進行限制，保證服務可靠性
出入隊性能
對於RabbitMQ和Redis的入隊和出隊操作，各執行100萬次，每10萬次記錄一次執行時間。
測試數據分為128Bytes、512Bytes、1K和10K四個不同大小的數據。
實驗表明：
入隊時，當數據比較小時Redis的性能要高於RabbitMQ，而如果數據大小超過了10K，Redis則慢的無法忍受；
出隊時，無論數據大小，Redis都表現出非常好的性能，而RabbitMQ的出隊性能則遠低於Redis。

註：此數據來源於互聯網，但與我自己之前測試的數據基本吻合
應用場景分析
Redis：輕量級，高並發，延遲敏感
即時數據分析、秒殺計數器、緩存等
RabbitMQ：重量級，高並發，非同步
批量數據非同步處理、並行任務串列化，高負載任務的負載均衡等