发表更新中间件2 分钟读完 (大约253个字)

1 | Redis 基础数据结构 SDS

在 redis 中，保存基础的字符串的数据结构为 Simple Dynamic String(SDS)，它是一个对 C 语言中字符串的包装结构。在 C 语言中，用 char[] str 来声明一个字符串，且每个字符串都以 结尾，一些字符串操作函数，都以 作为字符串的结束标识符。而 SDS
阅读更多
发表更新中间件 / 后端开发5 分钟读完 (大约701个字)

一种基于redis的分布式锁的实现（当前项目中在使用）

主要思想是利用redis执行命令时的单线程特性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
/**
 * 分布式锁
 */
@Component
public class DistributedLock {

    public static final Logger logger = LoggerFactory.getLogger(DistributedLock.class);
    /**
     * 加锁默认超时时间
     */
    private static final long DEFAULT_TIMEOUT_SECOND = 5;
    /**
     * 获取所等待的时间
     */
    private static final long DEFAULT_WAITE_TIMEOUT_SECOND = 5;
    /**
     * 加锁循环等待时间
     */
    private static final long LOOP_WAIT_TIME_MILLISECOND = 30;
    @Autowired
    @Qualifier("redisCacheService")
    private BaseCacheService cacheService;

    /**
     * 有超时等待的加锁
     *
     * @param timeoutSecond      如果为null,使用默认超时时间
     * @param waiteTimeoutSecond 若果为null,使用默认超时时间
     * @return 加锁的值（超时时间：-1表示获取失败，超时）
     */
    public long lock(String key, Long timeoutSecond, Long waiteTimeoutSecond) {

        logger.info("Thread：" + Thread.currentThread().getName() + " start lock");
        long beganTime = System.currentTimeMillis() / 1000;
        //如果参数错误
        if (timeoutSecond != null && timeoutSecond <= 0) {
            timeoutSecond = DEFAULT_TIMEOUT_SECOND;
        }
        timeoutSecond = timeoutSecond == null ? DEFAULT_TIMEOUT_SECOND : timeoutSecond;
        if (waiteTimeoutSecond != null && waiteTimeoutSecond <= 0) {
            waiteTimeoutSecond = DEFAULT_WAITE_TIMEOUT_SECOND;
        }
        waiteTimeoutSecond =
                waiteTimeoutSecond == null ? DEFAULT_WAITE_TIMEOUT_SECOND : waiteTimeoutSecond;
        while (true) {
            //等待超时判断
            long endTime = System.currentTimeMillis() / 1000;
            if ((endTime - beganTime) >= waiteTimeoutSecond) {
                return -1l;
            }
            //超时时间点
            long timeoutTimeMilli = cacheService.getCurrentTimeMilliForCache() + timeoutSecond * 1000;

            //如果设置成功
            if (cacheService.setIfAbsent(key, timeoutTimeMilli)) {
                logger.info("Thread：" + Thread.currentThread().getName() + " lock success");
                return timeoutTimeMilli;
            }

            //如果已经超时
            Long value = cacheService.getVal(key, Long.class);
            if (value != null && value.longValue() < cacheService.getCurrentTimeMilliForCache()) {

                //设置新的超时时间
                Long oldValue = cacheService.getAndSet(key, timeoutTimeMilli);

                //多个线程同时getset，只有第一个才可以获取到锁
                if (value.equals(oldValue)) {
                    logger.info("Thread：" + Thread.currentThread().getName() + " lock success");
                    return timeoutTimeMilli;
                }
            }

            //延迟一定毫秒，防止请求太频繁
            try {
                Thread.sleep(LOOP_WAIT_TIME_MILLISECOND);
            } catch (InterruptedException e) {
                logger.error("DistributedLock lock sleep error", e);
            }
        }
    }

    /**
     * 无超时等待的加锁
     *
     * @param timeoutSecond 如果为null,使用默认超时时间
     * @return 加锁的值（超时时间）
     */
    public long lock(String key, Long timeoutSecond) {

        logger.info("Thread：" + Thread.currentThread().getName() + " start lock");

        //如果参数错误
        if (timeoutSecond != null && timeoutSecond <= 0) {
            timeoutSecond = DEFAULT_TIMEOUT_SECOND;
        }
        timeoutSecond = timeoutSecond == null ? DEFAULT_TIMEOUT_SECOND : timeoutSecond;
        while (true) {
            //超时时间点
            long timeoutTimeMilli = cacheService.getCurrentTimeMilliForCache() + timeoutSecond * 1000;

            //如果设置成功
            // 若在redis中、没有相应的key值，那么可以认为，当前线程即或得该锁。
            if (cacheService.setIfAbsent(key, timeoutTimeMilli)) {
                logger.info("Thread：" + Thread.currentThread().getName() + " lock success");
                return timeoutTimeMilli;
            }

            //如果已经超时
            // 此时该key在redis已存在，获取该key的值
            Long value = cacheService.getVal(key, Long.class);
            if (value != null && value.longValue() < cacheService.getCurrentTimeMilliForCache()) {

                //设置新的超时时间
                // 如果此时获取到的oldValue，与前面获取的value相同，则说明该线程可以获得锁
                // 获得锁后，set进新值。
                Long oldValue = cacheService.getAndSet(key, timeoutTimeMilli);

                //多个线程同时getset，只有第一个才可以获取到锁
                if (value.equals(oldValue)) {
                    logger.info("Thread：" + Thread.currentThread().getName() + " lock success");
                    return timeoutTimeMilli;
                }
            }

            //延迟一定毫秒，防止请求太频繁
            try {
                Thread.sleep(LOOP_WAIT_TIME_MILLISECOND);
            } catch (InterruptedException e) {
                logger.error("DistributedLock lock sleep error", e);
            }
        }
    }

    /**
     * 释放锁
     */
    public void unLock(String key, long lockValue) {

        logger.info("Thread：" + Thread.currentThread().getName() + " start unlock");
        Long value = cacheService.getVal(key, Long.class);
        if (value != null && value.equals(lockValue)) {//如果是本线程加锁
            cacheService.deleteVal(key);
            logger.info("Thread：" + Thread.currentThread().getName() + " unlock success");
        }
    }
}
发表更新中间件 / 操作系统2 分钟读完 (大约308个字)

CentOS7中Redis的安装与基本配置

安装

1
2
3
sudo yum install redis # 看yum源中是否有redis，我试的没有。不过应该是没有的，要从源码编译安装
sudo yum install epel-release # 下载fedora的epel库
sudo yum install redis # 再次安装

启动、关闭、连接

1
2
3
4
5
6
7
8
9
10
11
12
# 启动redis
service redis start
# 停止redis
service redis stop
# 查看redis运行状态
service redis status
# 查看redis进程
ps -ef | grep redis
# 进入本机redis
redis-cli
# 列出所有key
keys *

配置开机启动

1
2
# 设置redis为开机自动启动
chkconfig redis on

从防火墙开放端口

1
2
sudo firewall-cmd --zone=public --add-port=6379/tcp --permanent # 开放6379端口
sudo firewall-cmd --reload # 重新加载配置

开启远程访问

默认是只能在本机访问、所以通过网络访问需要额外的配置。配置文件的目录在：/etc/redis.conf。然后分别修改下面两处配置：

这里写图片描述

这里写图片描述

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
import redis.clients.jedis.Jedis;

public class TestRedis {
    public static void main(String[] args) {
        Jedis redis = new Jedis("192.168.102.6");
        System.out.println(redis.ping());
    }
}
/* 输出：
*  PONG
* 
*  Process finished with exit code 0
* /

参考：
https://www.cnblogs.com/rslai/p/8249812.html
https://blog.csdn.net/xujian_2001/article/details/78927706

归档

最新文章

链接

×