Redis实现缓存队列

1.用redis中的List可以实现队列，这样可以用来做消息处理和任务调度的队列

2.代码模拟

代码结构

生产者模拟程序

[java] view plain copy

1. /** 
2.  *  
3.  */  
4. package scheduleTest;  
5.   
6. import java.util.Random;  
7. import java.util.UUID;  
8.   
9. import redis.clients.jedis.Jedis;  
10.   
11. /** 
12.  * 模拟一个生产者 
13.  * <p>Title: TaskProducer</p> 
14.  * <p>Description: </p> 
15.  * <p>Company: </p> 
16.  * @author 夏 杰 
17.  * @date 2015年12月11日 下午4:26:48 
18.  * @vesion 1.0 
19. */  
20. public class TaskProducer implements Runnable{  
21.     Jedis jedis = new Jedis(“120.55.195.177”,6379);  
22.       
23.     public void run() {  
24.         Random random = new Random();  
25.         while(true){  
26.             try{  
27.                 Thread.sleep(random.nextInt(600) + 600);  
28.                 // 模拟生成一个任务  
29.                 UUID taskid = UUID.randomUUID();  
30.                 //将任务插入任务队列：task-queue  
31.                 jedis.lpush(”task-queue”, taskid.toString());  
32.                 System.out.println(”插入了一个新的任务： ” + taskid);  
33.   
34.             }catch(Exception e){  
35.                 e.printStackTrace();  
36.             }  
37.         }  
38.           
39.     }  
40.   
41. }  

消费者模拟程序

[java] view plain copy

1. /** 
2.  *  
3.  */  
4. package scheduleTest;  
5.   
6. import java.util.Random;  
7.   
8. import redis.clients.jedis.Jedis;  
9.   
10. /** 
11.  * 模拟消费者 
12.  * <p>Title: TaskConsumer</p> 
13.  * <p>Description: </p> 
14.  * <p>Company: </p> 
15.  * @author 夏 杰 
16.  * @date 2015年12月11日 下午4:44:23 
17.  * @vesion 1.0 
18. */  
19. public class TaskConsumer implements Runnable {  
20.     Jedis jedis = new Jedis(“120.55.195.177”,6379);  
21.   
22.     public void run() {  
23.         Random random = new Random();  
24.           
25.         while(true){  
26.               
27.             //从任务队列”task-queue”中获取一个任务，并将该任务放入暂存队列”tmp-queue”  
28.             String taskid = jedis.rpoplpush(”task-queue”, “tmp-queue”);  
29.               
30.               
31.             // 处理任务—-纯属业务逻辑，模拟一下：睡觉  
32.             try {  
33.                 Thread.sleep(1000);  
34.             } catch (InterruptedException e) {  
35.                 e.printStackTrace();  
36.             }  
37.               
38.               
39.             //模拟成功和失败的偶然现象  
40.             if(random.nextInt(13) % 7 == 0){// 模拟失败的情况,概率为2/13  
41.                 //将本次处理失败的任务从暂存队列”tmp-queue”中，弹回任务队列”task-queue”  
42.                 jedis.rpoplpush(”tmp-queue”, “task-queue”);  
43.                 System.out.println(taskid + ”处理失败，被弹回任务队列”);  
44.               
45.             } else {// 模拟成功的情况  
46.                   
47.                 // 将本次任务从暂存队列”tmp-queue”中清除  
48.                 jedis.rpop(”tmp-queue”);  
49.                 System.out.println(taskid+”处理成功，被清除”);  
50.                   
51.             }     
52.         }  
53.                           
54.     }  
55.       
56.   
57.       
58. }  

调度主程序

[java] view plain copy

1. /** 
2.  *  
3.  */  
4. package scheduleTest;  
5.   
6. /** 
7.  * <p>Title: TaskShedulerSystem</p> 
8.  * <p>Description: </p> 
9.  * <p>Company: </p> 
10.  * @author 夏 杰 
11.  * @date 2015年12月11日 下午4:19:09 
12.  * @vesion 1.0 
13. */  
14. public class TaskShedulerSystem {  
15.     public static void main(String[] args) throws Exception {  
16.           
17.         // 启动一个生产者线程，模拟任务的产生  
18.         new Thread(new TaskProducer()).start();  
19.           
20.         Thread.sleep(15000);  
21.           
22.         //启动一个线程者线程，模拟任务的处理  
23.         new Thread(new TaskConsumer()).start();  
24.           
25.         //主线程休眠  
26.         Thread.sleep(Long.MAX_VALUE);  
27.     }  
28. }