总结：通过redis的set操作是否成功判断当前线程是否争夺到来锁，没有争夺到则一直循环争夺。为了防止无限时间争夺锁，增加了抢夺锁的最长时间，没争夺到则放弃获取锁。
这一节我们用户redis实现锁，从而解决之前遇到的问题。原理主要是借用redis的set的原子操作，每次都通过set操作判断当前的锁是否被占用，如果被占用则需要等到抢到锁位置。
所以此时在redis存在两个值，一个是number，一个是lock。
public class test {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
Redis ru = new Redis();
//锁标志，默认没获得锁
Boolean lock= false;
//一直等到获得锁，再往下执行
String getLockResult=null;
while (!lock){
getLockResult = ru.set("lock","1",1);
if(getLockResult!=null)
lock=true;
}
//获取redis的值
Integer number= ru.getInteger("number");
number++;
//加一再放回redis
ru.set("number",number.toString());
System.out.println(Thread.currentThread().getName() +"---->result:" + number) ;
ru.delete("lock");
}
});
//解锁
thread1.start();
}
}
}
运行后的结果如下所示。
image.png
redis中number的值也正确了。
image.png
这个锁存在一个循环，当无法获取到锁时会一直等待锁的释放，当发生死锁时，长时间无法获取锁会出现问题，因此应该增加一个获取锁的超时时间acquireTimeout。同时优化下循环，每隔10ms尝试获取一次锁，而不是一直获取。
public class test {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
Redis ru = new Redis();
//锁标志，默认没获得锁
Boolean lock = false;
//一直等到获得锁，再往下执行
String getLockResult = null;
//当没有获取到锁且没有超时时循环（超时时间设置为5s）
long end = System.currentTimeMillis() + 5000;
while (!lock && System.currentTimeMillis() < end) {
getLockResult = ru.set("lock", "1", 1);
if (getLockResult != null)
lock = true;
//休息10ms
try {
Thread.sleep(10);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
//抢到了锁才会进行这些操作
if(lock){
//获取redis的值
Integer number = ru.getInteger("number");
number++;
//加一再放回redis
ru.set("number", number.toString());
System.out.println(Thread.currentThread().getName() + "---->result:" + number);
ru.delete("lock");
}
}
});
//解锁
thread1.start();
}
}
}
但是这样的锁还是有问题，问题如下：
假设有两个线程A、B。俩线程的占用锁的最长时间为5s，过了5s就会自动释放锁。如果A先占用锁，但是内部运行的代码超过俩5s，此时锁会自动释放，B就能获得锁了。当运行到第6秒的时候，A线程运行完了，会前往redis手动释放锁，注意此时的锁是B线程申请的，所以A错误的释放了别人的锁。这是不对的，同时如果在A超时的过程中出现了存储数据的过程，则会出现脏读的情况。所以我们得想办法解决这个问题。下面代码模拟了这种情况：
public class test {
public static void main(String[] args) {
//监听线程
Thread monitor = new Thread(new Runnable() {
@Override
public void run() {
int time = 0;
Redis ru = new Redis();
while (time < 100000)
try {
Thread.sleep(500);
time = time + 500;
System.out.println("Time:" + time + "---->" + ru.get("lock"));
} catch (Exception e) {
}
}
});
monitor.start();
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
Redis ru = new Redis();
//加锁，默认没获得锁
Boolean notGetLock = true;
//一直等到获得锁，再往下执行
String getLockResult = null;
while (notGetLock) {
getLockResult = ru.set("lock", Thread.currentThread().getName(), 5);
if (getLockResult != null)
notGetLock = false;
}
try {
Thread.sleep(6000);
} catch (Exception e) {
}
//解锁
ru.delete("lock");
}
});
thread1.start();
//等待5s后再启动线程2
try {
Thread.sleep(5000);
} catch (Exception e) {
}
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
Redis ru = new Redis();
//加锁，默认没获得锁
Boolean notGetLock = true;
//一直等到获得锁，再往下执行
String getLockResult = null;
while (notGetLock) {
getLockResult = ru.set("lock", Thread.currentThread().getName(), 5);
if (getLockResult != null)
notGetLock = false;
}
try {
Thread.sleep(4000);
} catch (Exception e) {
}
//解锁
ru.delete("lock");
}
});
thread2.start();
}
}
Time:500---->Thread-1
Time:1000---->Thread-1
Time:1500---->Thread-1
Time:2000---->Thread-1
Time:2500---->Thread-1
Time:3000---->Thread-1
Time:3500---->Thread-1
Time:4000---->Thread-1
Time:4500---->Thread-1
Time:5000---->Thread-3
Time:5500---->Thread-3
Time:6000---->null
Time:6500---->null
Time:7000---->null
Time:7500---->null
Time:8000---->null
Time:8500---->null
Time:9000---->null
Time:9500---->null
Time:10000---->null
Time:10500---->null
Time:11000---->null
Time:11500---->null
Time:12000---->null
Time:12500---->null
Time:13000---->null
结果可知在第六秒的时候线程2的锁被线程1释放了。
