使用Jedis实现队列

最新推荐文章于 2021-04-09 16:02:18 发布

weixin_33979203

最新推荐文章于 2021-04-09 16:02:18 发布

阅读量673

点赞数

文章标签：数据库 java python

原文链接：https://my.oschina.net/u/3049601/blog/1359290

版权

2019独角兽企业重金招聘Python工程师标准>>>

开始采用多个线程使用同一个redis连接，直接运行程序，总有一个线程提交后没有被执行，然而使用debug单步执行又没有问题（目前还未找到原因），后来改成每个线程一个redis连接，可以成功执行，如果有遇到这个问题的朋友阅读到这篇文章请留言

普通队列

package jv.redis.datatype.queue;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import redis.clients.jedis.Jedis;
/*
 * 普通队列，不阻塞，没有优先级
 */
public class RedisQueueNormal {
	Jedis jedis;
	volatile boolean flag = false;
	ExecutorService es;
	public RedisQueueNormal(){
		initRedis();
		es = Executors.newCachedThreadPool();
	}
	

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		RedisQueueNormal rqn = new RedisQueueNormal();
		List<Future> lf = new ArrayList<Future>();
		lf.add(rqn.producer());
		lf.add(rqn.consumer());
		for(Future f:lf){
			f.get();
		}
		rqn.close();
		System.out.println("program is finished");
	}
	
	public Future producer(){
		System.out.println("submit producer");
		return es.submit(new Runnable() {
				@Override
				public void run() {
					Jedis myEdis = newRedis();
					myEdis.del("redis:queue");
					for(int i=1;i<=10;i++){
						myEdis.lpush("redis:queue", "test"+i);
						System.out.println("producer:test"+i);
					}
					flag = true;
					System.out.println("producer is finished");
				}
			});
	}
	
	public Future consumer() {
		System.out.println("submit consumer");
		return es.submit(new Runnable() {
			@Override
			public void run() {
				Jedis myEdis = newRedis();
				String rlt = "";
				/**
				 * 消费者线程每隔一秒尝试从队列中取一个消息，当取不到消息，且生产者已经完成所有生产，则消费者退出
				 * */
				while (true) {
					rlt = myEdis.rpop("redis:queue");
					if(rlt==null&&flag){
						break;
					}
					System.out.println("consumer:" + rlt);
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				System.out.println("consumer is finished");
			}
		});
	}
	
	public void initRedis(){
		jedis = new Jedis("redis://192.168.1.101:6379");
		System.out.println("redis is connected");
	}
	
	public Jedis newRedis(){
		return new Jedis("redis://192.168.1.101:6379");
	}

	public void closeRedis(){
		//注意不要使用jedis.shutdown()，这样会把服务器停掉。。。
		jedis.close();
	}
	
	public void closePool(){
		es.shutdown();
	}
	
	public void close(){
		closeRedis();
		closePool();
	}
}

阻塞队列

package jv.redis.datatype.queue;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import redis.clients.jedis.Jedis;
/*
 * 阻塞队列
 */
public class RedisBlockingQueue {
	Jedis jedis;
	ExecutorService es;
	public RedisBlockingQueue(){
		initRedis();
		es = Executors.newCachedThreadPool();
	}
	

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		RedisBlockingQueue rqn = new RedisBlockingQueue();
		List<Future> lf = new ArrayList<Future>();
		lf.add(rqn.producer());
		lf.add(rqn.consumer());
		for(Future f:lf){
			f.get();
		}
		rqn.close();
		System.out.println("program is finished");
	}
	
	public Future producer(){
		System.out.println("submit producer");
		return es.submit(new Runnable() {
				@Override
				public void run() {
					Jedis myEdis = newRedis();
					Random rd = new Random();
					int timeout = 0;
					myEdis.del("redis:queue");
					for(int i=1;i<=10;i++){
						myEdis.lpush("redis:queue", "test"+i);
						timeout = rd.nextInt(10);
						System.out.println("producer:test"+i+",sleep "+timeout+" seconds");
						try {
							Thread.sleep(timeout*1000);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
					System.out.println("producer is finished");
				}
			});
	}
	
	public Future consumer() {
		System.out.println("submit consumer");
		return es.submit(new Runnable() {
			@Override
			public void run() {
				Jedis myEdis = newRedis();
				List<String> rlt = null;
				/**
				 * 只要队列中有数据，消费者线程就取出来
				 */
				while (true) {
					rlt = myEdis.brpop(0,"redis:queue");
					System.out.println("consumer:" + rlt);
				}
			}
		});
	}
	
	public void initRedis(){
		jedis = new Jedis("redis://192.168.0.114:6379");
		System.out.println("redis is connected");
	}
	
	public Jedis newRedis(){
		return new Jedis("redis://192.168.0.114:6379");
	}

	public void closeRedis(){
		//注意不要使用jedis.shutdown()，这样会把服务器停掉。。。
		jedis.close();
	}
	
	public void closePool(){
		es.shutdown();
	}
	
	public void close(){
		closeRedis();
		closePool();
	}
}

优先级队列

package jv.redis.datatype.queue;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import redis.clients.jedis.Jedis;
/*
 * 优先级队列
 */
public class RedisPriorityQueue {
	Jedis jedis;
	ExecutorService es;
	public RedisPriorityQueue(){
		initRedis();
		es = Executors.newCachedThreadPool();
	}
	

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		RedisPriorityQueue rqn = new RedisPriorityQueue();
		List<Future> lf = new ArrayList<Future>();
		lf.add(rqn.producerOne());
		lf.add(rqn.producerTwo());
		lf.add(rqn.consumer());
		for(Future f:lf){
			f.get();
		}
		rqn.close();
		System.out.println("program is finished");
	}
	
	public Future producerOne(){
		System.out.println("submit producerOne");
		return es.submit(new Runnable() {
				@Override
				public void run() {
					Jedis myEdis = newRedis();
					myEdis.del("redis:queue:one");
					for(int i=1;i<=1000;i++){
						myEdis.lpush("redis:queue:one", "test"+i);
						//System.out.println("producer:test"+i);
					}
					System.out.println("producer is finished");
				}
			});
	}
	public Future producerTwo(){
		System.out.println("submit producerTwo");
		return es.submit(new Runnable() {
				@Override
				public void run() {
					Jedis myEdis = newRedis();
					Random rd = new Random();
					int timeout = 0;
					myEdis.del("redis:queue:two");
					for(int i=1;i<=10;i++){
						myEdis.lpush("redis:queue:two", "test"+i);
						timeout = rd.nextInt(10);
						System.out.println("producer:test"+i+",sleep "+timeout+" seconds");
						try {
							Thread.sleep(timeout*1000);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
					System.out.println("producer is finished");
				}
			});
	}
	
	public Future consumer() {
		System.out.println("submit consumer");
		return es.submit(new Runnable() {
			@Override
			public void run() {
				Jedis myEdis = newRedis();
				List<String> rlt = null;
				/**
				 * 为了看得效果更明显，虽然采用了阻塞方式获取数据，还是强制每隔一秒休眠一次，以达到队列一种有很多消息，队列二中随机来消息，但是先取走
				 */
				while (true) {
					rlt = myEdis.brpop(0,"redis:queue:two","redis:queue:one");
					System.out.println("consumer:" + rlt);
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		});
	}
	
	public void initRedis(){
		jedis = new Jedis("redis://192.168.0.114:6379");
		System.out.println("redis is connected");
	}
	
	public Jedis newRedis(){
		return new Jedis("redis://192.168.0.114:6379");
	}

	public void closeRedis(){
		//注意不要使用jedis.shutdown()，这样会把服务器停掉。。。
		jedis.close();
	}
	
	public void closePool(){
		es.shutdown();
	}
	
	public void close(){
		closeRedis();
		closePool();
	}
}

转载于:https://my.oschina.net/u/3049601/blog/1359290