说说在JAVA中使用Redis，以及Redis分布锁

最新推荐文章于 2024-05-05 12:00:36 发布
最新推荐文章于 2024-05-05 12:00:36 发布
阅读量456 收藏 2
点赞数
分类专栏： JAVA 文章标签： JAVA REDIS 分布式锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangweiaixiu/article/details/81975598
版权

只上代码和说明，其他的不讲了，权当做个笔记。

该代码使用了1年多，在高并发的情况下并无问题，所以分享给大家。

package util;


import java.io.UnsupportedEncodingException;
import java.net.SocketTimeoutException;

import com.system.PublicParameter;



import net.sf.json.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.exceptions.JedisConnectionException;

public final class  RedisUtil{
    
	private static String ADDR = "XXX.XXX.X.XXX";

    
    //Redis的端口号
    private static int PORT = 6379;
    
    //访问密码
    private static String AUTH = "XXXX";
    
    //可用连接实例的最大数目，默认值为8；
    //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
    private static int MAX_ACTIVE = 800;
    
    //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
    private static int MAX_IDLE = 100;
    
    //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
    private static long MAX_WAIT = 50000;
    
    private static int TIMEOUT = 50000;
    
    //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
    private static boolean TEST_ON_BORROW = true;
    
    public static JedisPool jedisPool = null;
    
    /**
     * 初始化Redis连接池
     */
    static {
        try {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(MAX_ACTIVE);
            config.setMaxIdle(MAX_IDLE);
            config.setMaxWaitMillis(MAX_WAIT);
            config.setTestOnBorrow(TEST_ON_BORROW);
            jedisPool = new JedisPool(config, ADDR, PORT,TIMEOUT);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 获取Jedis实例
     * @return
     */
    public synchronized static Jedis getJedis()  
    {  
        int timeoutCount = 0;  
        while (true) // 如果是网络超时则多试几次  
        {  
            try  
            {  
                Jedis jedis = jedisPool.getResource();  
                return jedis;  
            } catch (Exception e)  
            {  
                // 底层原因是SocketTimeoutException，不过redis已经捕捉且抛出JedisConnectionException，不继承于前者  
                if (e instanceof JedisConnectionException || e instanceof SocketTimeoutException)  
                {  
                    timeoutCount++;  
                   System.out.println("getJedis timeoutCount="+timeoutCount);  
                    if (timeoutCount > 3)  
                    {  
                        break;  
                    }  
                }else  
                {  
                 
                    break;  
                }  
            }  
        }  
        return null;  
    }  
    /**
     * 释放jedis资源
     * @param jedis
     */
    public static void returnResource(final Jedis jedis) {
        if (jedis != null) {
            jedisPool.returnResource(jedis);
        }
    }
    
    
    public static void mset(String key,String value){
    	Jedis redis = getJedis();
    	try {
    		redis.set(key, value);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			jedisPool.returnResource(redis);
		}
    	
    }
    
    public static String mget(String co_make,String key){
    	Jedis redis = getJedis();
    	String value="";
    	try {
    		
        	if(key.equals("")){
        		value=redis.get(co_make);
        	}else{
        		if(redis.get(co_make)!=null){
        			 net.sf.json.JSONObject json1 = net.sf.json.JSONObject.fromObject(redis.get(co_make).toString());
        			if(json1.get(key)!=null){
	    	       		 value=json1.getString(key);
        			}
        		}
        	}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			jedisPool.returnResource(redis);
		}
    	
		return setNullToBanlk(value);
    }
    
    
    
    public static String mget(String key){
    	Jedis redis = getJedis();
    	String value="";
    	try {
    		value=redis.get(key);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			jedisPool.returnResource(redis);
		}
    	
		return setNullToBanlk(value);
    }
    
    public static void mdel(String key){
    	Jedis redis = getJedis();
    	try {
    		redis.del(key);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			jedisPool.returnResource(redis);
		}
    	
    }
    
    
    
    
	public static String setNullToBanlk(String name) {
	    if (name == null) {
	      name = "";
	    }
	    return name != null ? name.trim() : "";
 }
	public RedisUtil() {
		
	}
	public static void main(String[] args) {
		for (int i = 0; i < 3000; i++) {
			new Thread(new Runnable() {
				
				public void run() {
					Jedis redis = getJedis();
					try {
						for (int i = 0; i < 1000; i++) {
							redis.mset("a", "1");
							System.out.println("线程1成功==="+i);
						}
					} catch (Exception e) {
						e.printStackTrace();
					}
					
				}
			}).start();
		}
		
		
		
		
		
		
		
	}
	
	

}

使用的jar包：

jedis-2.7.2.jar

commons-pool2-2.2.jar

jackson-core-asl-1.6.4.jar

再说说分布锁，这个比较重要，因为在分布式架构哦的并发情况下，如果有业务需要计算金额，或者计数，就需要用到分布锁

 

package com.qh_goal;


import java.net.SocketTimeoutException;
import java.util.Collections;
import java.util.UUID;




import net.sf.json.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.exceptions.JedisConnectionException;

public final class  RedisUtil{

	private static String ADDR = "xxx.xxx.x.xxx";


	//Redis的端口号
	private static int PORT = 6379;

	//访问密码
	private static String AUTH = "xxxxxx";

	//可用连接实例的最大数目，默认值为8；
	//如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
	private static int MAX_ACTIVE = 800;

	//控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
	private static int MAX_IDLE = 100;

	//等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
	private static long MAX_WAIT = 50000;

	private static int TIMEOUT = 50000;

	//在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
	private static boolean TEST_ON_BORROW = true;

	public static JedisPool jedisPool = null;
	private static DistributedLock lock = null;
	/**
	 * 初始化Redis连接池
	 */
	static {
		try {
			JedisPoolConfig config = new JedisPoolConfig();
			config.setMaxTotal(200);
			config.setMaxIdle(50);
			config.setMinIdle(8);//设置最小空闲数
			config.setMaxWaitMillis(10000);
			config.setTestOnBorrow(true);
			config.setTestOnReturn(true);
			//Idle时进行连接扫描
			config.setTestWhileIdle(true);
			//表示idle object evitor两次扫描之间要sleep的毫秒数
			config.setTimeBetweenEvictionRunsMillis(30000);
			//表示idle object evitor每次扫描的最多的对象数
			config.setNumTestsPerEvictionRun(10);
			//表示一个对象至少停留在idle状态的最短时间，然后才能被idle object evitor扫描并驱逐；这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义
			config.setMinEvictableIdleTimeMillis(60000);
			jedisPool = new JedisPool(config, ADDR, PORT,TIMEOUT);
			lock = new DistributedLock(jedisPool);
			System.out.println("1");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	


	

	/**
	 * 获取Jedis实例
	 * @return
	 */
	synchronized public  static Jedis getJedis()  
	{  
		int timeoutCount = 0;  
		while (true) // 如果是网络超时则多试几次  
		{  
			try  
			{  
				Jedis jedis = jedisPool.getResource();  
				return jedis;  
			} catch (Exception e)  
			{  
				// 底层原因是SocketTimeoutException，不过redis已经捕捉且抛出JedisConnectionException，不继承于前者  
				if (e instanceof JedisConnectionException || e instanceof SocketTimeoutException)  
				{  
					timeoutCount++;  
					System.out.println("getJedis timeoutCount="+timeoutCount);  
					if (timeoutCount > 3)  
					{  
						break;  
					}  
				}else  
				{  

					break;  
				}  
			}  
		}  
		return null;  
	}  
	/**
	 * 释放jedis资源
	 * @param jedis
	 */
	public static void returnResource(final Jedis jedis) {
		if (jedis != null) {
			jedisPool.returnResource(jedis);
		}
	}
	public static void msetValue(String key,String value){
		Jedis redis = getJedis();
		try {
			redis.set(key, value);

		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			redis.close();
			redis = null;
		}

	}
	
	public static String mgetValue(String key){
		Jedis redis = getJedis();
		String value="";
		try {
			value=redis.get(key);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			redis.close();
			redis = null;
		}

		return setNullToBanlk(value);
	}

	public static void mset(String key,String value,Jedis redis){
		try {
			redis.set(key, value);

		} catch (Exception e) {
			e.printStackTrace();
		}finally{
		}

	}

	public static String mget(String co_make,String key){
		Jedis redis = getJedis();
		String value="";
		try {

			if(key.equals("")){
				value=redis.get(co_make);
			}else{
				if(redis.get(co_make)!=null){
					net.sf.json.JSONObject json1 = net.sf.json.JSONObject.fromObject(redis.get(co_make).toString());
					if(json1.get(key)!=null){
						value=json1.getString(key);
					}
				}

			}

		} catch (Exception e) {
			e.printStackTrace();
		}finally{

		}

		return setNullToBanlk(value);
	}



	public static String mget1(String key,Jedis redis){
		
		String value="";
		try {
			value=redis.get(key);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
		}

		return setNullToBanlk(value);
	}

	public static void mdel(String key){
		Jedis redis = getJedis();
		try {
			redis.del(key);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			jedisPool.returnResource(redis);
		}

	}




	public static String setNullToBanlk(String name) {
		if (name == null) {
			name = "";
		}
		return name != null ? name.trim() : "";
	}
	public RedisUtil() {

	}
	 static int n = 500;
	 public static String seckill(String company_id,float value) {
		  Jedis redis = getJedis();
		  String a = "";
		 	try {
		 		 // 返回锁的value值，供释放锁时候进行判断
		 		  String indentifier = lock.lockWithTimeout("resource", 5000, 1000);
			       
			        System.out.println("REDIS----1----"+Thread.currentThread().getName() + "获得了锁");
			        a = mget1(company_id,redis);
			        mset(company_id, Float.parseFloat(a)-value+"",redis);
			        a = mget1(company_id,redis);
			        lock.releaseLock("resource", indentifier,redis);
			} catch (Exception e) {
				e.printStackTrace();
			}finally{
				redis.close();
				redis = null;
			}
			return a;
	       
	      
	       

	 }
	 
	 
	 public static String secGetValue(String company_id) {
		  Jedis redis = getJedis();
		  String value = "";
		 	try {
		 		 // 返回锁的value值，供释放锁时候进行判断
		 		  String indentifier = lock.lockWithTimeout("resource", 5000, 1000);
			       
			        System.out.println("REDIS----1----"+Thread.currentThread().getName() + "获得了锁");
			        value = mget1(company_id,redis);
			        lock.releaseLock("resource", indentifier,redis);
			} catch (Exception e) {
				e.printStackTrace();
			}finally{
				redis.close();
				redis = null;
			}
		 	return setNullToBanlk(value);
	       
	      
	       

	 }
	 
	 public static void seckill2() {
		  Jedis redis = getJedis();
		 	try {
		 		 // 返回锁的value值，供释放锁时候进行判断
		 		  String indentifier = lock.lockWithTimeout("resource", 5000, 1000);
			       
//			        System.out.println("REDIS----1----"+Thread.currentThread().getName() + "获得了锁");
//			        String a = mget1("a",redis);
//			        mset("a", n--+"",redis);
			        System.out.println("线程成功2==="+mget1("a",redis));
			        lock.releaseLock("resource", indentifier,redis);
			} catch (Exception e) {
				// TODO: handle exception
			}finally{
				redis.close();
				redis = null;
			}
	       
	      
	       

	 }
	 
	public static void main(String[] args) throws InterruptedException {
		final String uuid = UUID.randomUUID().toString();
		 Jedis redis = getJedis();
		mset("a", "0",redis);
		jedisPool.returnResource(redis);
		for (int i = 0; i < 500; i++) {
			new Thread(new Runnable() {

				public void run() {
					try {

						seckill("",1);
						seckill2();
						

					} catch (Exception e) {
						e.printStackTrace();
					}

				}
			}).start();
		}
		
		





	}

	
}

main方法中的seckill("",1); seckill2();两个方法都使用了分布式锁。

大家先看代码，有疑问可以提出。

紫川琴秀
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Java面试题+Java并发编程(J.U.C)+Java8实战+Redis+kafka
05-15
『死磕Java并发编程系列』 05 图解Java中那18 把锁.md 『死磕Java并发编程系列』06 倒计时计数CountDownLatch 『死磕Java并发编程系列』07 人齐了一起干CyclicBarrier 『死磕Java并发编程系列』08 限量供应Semaphore...
【Java】三种方案实现 Redis 分布式锁
人生苦短，我用python
11-04 5534
三种 Redis 分布式锁的实现方案
封装RedisTemplate的RedisUtil工具类
choufei4244的博客
07-05 1244
public class RedisUtil { private RedisTemplate<String, Object> redisTemplate; public void setRedisTemplate(RedisTemplate<Strin...
2024年Java最全借助Redis锁，完美解决高并发秒杀问题，百度、阿里、滴滴、新浪的面试心经总结
最新发布
2401_83064295的博客
05-05 947
在面试前我整理归纳了一些面试学习资料，文中结合我的朋友同学面试美团滴滴这类大厂的资料及案例由于篇幅限制，文档的详解资料太全面，细节内容太多，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！大家看完有什么不懂的可以在下方留言讨论也可以关注。本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取将商品的数量存到Redis中。
java -Redis分布式锁学习
qq_27561019的博客
04-25 947
分布式锁是一种用于分布式系统的锁机制，它能够保证在分布式环境下对共享资源进行互斥访问，防止并发访问时出现数据竞争和不一致问题。在分布式系统中，多个节点可能同时修改共享资源，为了保证数据的正确性和一致性，需要对共享资源进行串行化访问。传统的单节点锁无法满足分布式系统的要求，因此需要使用分布式锁来保证在整个分布式系统中只会有一个节点可以获取到锁，从而保证共享资源的独占性。实现分布式锁的方法有很多种，包括利用数据库、缓存系统等。
java中使用Redis实现分布式锁
cz1803472613的博客
04-18 3848
目前很多大型的互联网公司后端都采用了分布式架构来支撑前端应用，其中服务拆分就是分布式的一种体现，既然服务拆分了，那么多个服务协调工作就会出现一些资源竞争的情况。比如多个服务对同一个表中的数据进行处理。容易出现类似多线程的不同步问题。多线程不同步我们一般通过代码中的锁来强制同步执行。但是对于这种多个服务的，这种本地锁久显得无能为力了。
Java+Redis：使用java实现分布式锁--redis篇
netyeaxi的专栏
04-04 4432
使用java实现分布式锁-redis篇
Redis面试专题30道.zip
08-10
14、Redis 支持的 Java 客户端都有哪些？官方推荐用哪个？ 15、Redis 和 Redisson 有什么关系？ 16、Jedis 与 Redisson 对比有什么优缺点？ 17、Redis 如何设置密码及验证密码？ 18、说说 Redis 哈希槽的概念？ 19、...
redis客户端和redis绿色免安装版和redis插件
04-25
再来说说Java开发者必备的Redis插件。在Java开发中，与Redis集成常常需要用到相应的库或插件，例如Jedis、Lettuce等。这些库允许Java应用通过简单的API与Redis服务器通信，执行读写操作。虽然这里没有具体提到Java...
缓存redis框架
12-19
Spring Redis 框架支持基于注解的编程模型，这意味着开发者可以在 Java 代码中使用注解来声明 Redis 相关的操作，从而减少配置文件的使用，提高代码的可读性和可维护性。例如，我们可以使用 `@Cacheable` 注解来标记...
基于redis的缓存框架
12-16
6. **分布式锁**：在多线程或多节点环境中，需要实现分布式锁机制，防止并发操作导致的数据不一致。 7. **性能优化**：根据实际需求，可以考虑使用Redis的发布/订阅功能实现缓存更新的广播，或者利用HyperLogLog等...
redis实现分布式锁(java/jedis)
08-06
redis实现分布式锁(java/jedis),其中包含工具方法以及使用demo 本资源是利用java的jedis实现 redis实现分布式锁(java/jedis),其中包含工具方法以及使用demo 本资源是利用java的jedis实现
Java分布式锁
q16974058的博客
04-03 902
很多程序员，整天沉浸在业务代码的 CRUD 中，业务中没有大量数据做并发，缺少实战经验，对并发仅仅停留在了解，做不到精通，所以总是与大厂擦肩而过。我把私藏的这套并发体系的笔记和思维脑图分享出来，理论知识与项目实战的结合，我觉得只要你肯花时间用心学完这些，一定可以快速掌握并发编程。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！on e) {自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
java使用redis加锁
qq_42376785的博客
04-01 4450
1.编写LockUtil工具类 import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.connection.RedisStringCommands.SetOption; import org.springframework.data.redis.core.RedisCallback; import org.springframework.data.redis
java整合redis分布式锁
yushun的博客
09-08 357
平台发放优惠券库存数量为1，用户在领取优惠券时需要减库存这时候会存在一个并发的情况，两个用户同时抢就需要使用redis分布式锁（或mq类似的东西）只允许一个用户执行完后才轮到下一个用户继续操作
Java中使用redis锁
qq_37025445的博客
12-03 4566
业务场景：有一个统计报表的task（定时）业务，业务大概就是统计数据然后存入数据库中，在线上环境部署到两台不同tomcat上，就是防止我一个task失败之后，另一个也会跑。 像这种业务的话，我们要实现会遇到一些问题： 1、有可能两个task同时跑，这样的话就会造成两个不同的进程会同时向数据库中写入，会造成数据混乱。 为了解决这个问题，我们就可以使用redis锁来解决。 解决思路：    ...
Java使用Redis实现分布式锁
zl
03-07 6970
思路 主要用的是redis的setnx()函数，利用函数的特性，即成功setnx的话返回1，如果key已经存在，setnx返回0，来判断能否将key插入到redis中。 但是要考虑锁无法正常释放的情况，避免成为垃圾锁，导致其他进程或线程无法进入加锁区域，需要特殊处理。通过redis的expire()函数来给key设置过期时间，当各种原因未能对锁unlock时，可以通过过期时间来实现锁的释放
Java使用redis实现分布式锁
balsamspear的博客
02-25 397
当并发时，有几种处理方案 一、Java代码同步处理 优点：使用简单 缺点：程序等待造成响应慢、服务器集群时不能用 总结：不推荐使用 二、数据库悲观锁 优点：相对简单、服务器集群时可以使用 缺点：需要注意锁级别和表索引，否则容易造成锁表！ 总结：不推荐使用 三、数据库乐观锁 优点：相对简单、服务器集群时可以使用、不会造成锁表 缺点：并发时，容易造成相同的业务代码多次执行 总结：可以使用 四、redi...
在java中使用redis
03-24
作为一个CSDN开发的C知道，我可以告诉你如何在Java中使用Redis。你需要使用Java Redis客户端，目前比较流行的客户端有Jedis和Lettuce。你需要连接Redis服务，并使用相应的指令来进行操作，比如set和get等。下面是一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

紫川琴秀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值