“琐事”？ “锁事”。

最新推荐文章于 2024-07-25 13:40:37 发布

方圆想当图灵

最新推荐文章于 2024-07-25 13:40:37 发布

阅读量1.4k

点赞数

分类专栏： Java并发编程文章标签： java 多线程并发编程

本文链接：https://blog.csdn.net/qq_46225886/article/details/108038072

版权

Java并发编程专栏收录该内容

8 篇文章 0 订阅

订阅专栏

大家好，我是方圆
查漏补缺了一下锁的知识点儿

1. synchronized

它会在发生异常时自动释放锁

2. 你知道Git是乐观锁吗？

当我们在向远程仓库push的时候，git会检查远端仓库的版本是不是要比我们现在的版本要高，如果是的话，就表示有人修改了远端代码，我们不能进行提交，需要先进行同步；如果版本一致的话，则能够提交成功

2.1 在MySQL中实现乐观锁

我们需要创建出一个单独的version列，用来标记版本号，这样每次我们对数据进行修改的时候，则会对版本号进行验证

在这里插入图片描述

SQL语句如下

UPDATE active SET num = 3 ,`version` = `version` + 1 WHERE id = 1 AND `version` = 1

2.2 乐观锁的适用场景

乐观锁：适用于读多写少的场景，这样不加锁能大幅的提高效率
悲观锁：适合大并发，代码复杂或者循环量大

3. 公平锁和非公平锁

公平锁：不允许插队的哟，谁先来谁就会先获取到锁
非公平锁：允许插队的哟，这样能提高效率，避免了唤醒带来的空档期，也是ReentrantLock的默认策略

3.1 来，看看这个特例

ReentrantLock中有一个tryLock方法，它实在是很厉害，它并不遵守我们既定的公平策略，怎么说呢，就是一旦有线程将锁的资源释放了出来，那么这个执行了tryLock方法的线程就能获取到锁，即便已经有线程在前面进行排队了，它就像VIP一样

4. 读写锁的插队策略

公平锁：不允许插队
非公平锁：写锁可以随时插队；读锁仅在阻塞队列的头节点是想要获取读锁的线程的时候，可以插队；当阻塞队列的节点是想要获取写锁的线程时，那么不能进行插队，这样能够避免发生饥饿现象（饥饿就是获取写锁被一直插队，一直也获取不到锁）

4.1 代码测试

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadAndWriteDemo2 {
    private static final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
    private static ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
    private static ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();

    public static void read() {
        System.out.println(Thread.currentThread().getName() + "尝试获取读锁");
        readLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "获取到了读锁");
            TimeUnit.MILLISECONDS.sleep(80);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            readLock.unlock();
        }
    }

    public static void write() {
        System.out.println(Thread.currentThread().getName() + "尝试获取写锁");
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "获取到了写锁");
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            writeLock.unlock();
            System.out.println(Thread.currentThread().getName() + "释放了写锁");
        }
    }

    public static void main(String[] args) {
        new Thread(() -> write(),"A").start();
        new Thread(() -> read(),"B").start();
        new Thread(() -> read(),"C").start();
        new Thread(() -> {
            for (int i = 0; i < 1500; i++) {
                new Thread(() -> read(),String.valueOf(i)).start();
            }
        }).start();
    }
}

在非公平的情况下 ↓
在公平的情况下↓

5. 写一个死锁

5.1 代码

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class DeadLockDemo2 {
    public static void main(String[] args) throws InterruptedException {
        DeadLock deadLock = new DeadLock(1);
        new Thread(deadLock,"1").start();
        TimeUnit.MILLISECONDS.sleep(1);
        deadLock.setFlag(2);
        new Thread(deadLock,"2").start();
    }
}

class DeadLock implements Runnable{

    private ReentrantLock lock1 = new ReentrantLock();
    private ReentrantLock lock2 = new ReentrantLock();
    private int flag;

    public DeadLock(int flag) {
        this.flag = flag;
    }

    public void setFlag(int flag) {
        this.flag = flag;
    }

    //TODO tryLock避免死锁式,注意tryLock方法的使用位置，是在if条件中
    @Override
    public void run() {
        if(flag == 1) {
            if(lock1.tryLock()) {
                try {
                    System.out.println(Thread.currentThread().getName() + "成功获取到了锁1");
                    TimeUnit.SECONDS.sleep(1);
                    if(lock2.tryLock()) {
                        try {
                            System.out.println(Thread.currentThread().getName() + "成功获取到了锁2");
                        }finally {
                            lock2.unlock();
                        }
                    }else {
                        System.out.println(Thread.currentThread().getName() + "获取锁2失败");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock1.unlock();
                }
            }else {
                System.out.println(Thread.currentThread().getName() + "获取锁1失败");
            }
        }else {
            if(lock2.tryLock()) {
                try {
                    System.out.println(Thread.currentThread().getName() + "成功获取到了锁2");
                    TimeUnit.SECONDS.sleep(1);
                    if(lock1.tryLock()) {
                        try {
                            System.out.println(Thread.currentThread().getName() + "成功获取到了锁1");
                        }finally {
                            lock1.unlock();
                        }
                    }else {
                        System.out.println(Thread.currentThread().getName() + "获取锁1失败");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock2.unlock();
                }
            }else {
                System.out.println(Thread.currentThread().getName() + "获取锁2失败");
            }
        }
    }

    //TODO 死锁式
    /*@Override
    public void run() {
        if(flag == 1) {
            lock1.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "获取到了锁1");
                TimeUnit.SECONDS.sleep(1);
                System.out.println(Thread.currentThread().getName() + "尝试获取锁2");
                lock2.lock();
                try {
                    System.out.println(Thread.currentThread().getName() + "获取到了锁2");
                }finally {
                    lock2.unlock();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock1.unlock();
            }
        }else {
            lock2.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "获取到了锁2");
                TimeUnit.SECONDS.sleep(1);
                System.out.println(Thread.currentThread().getName() + "尝试获取锁1");
                lock1.lock();
                try {
                    System.out.println(Thread.currentThread().getName() + "获取到了锁1");
                }finally {
                    lock1.unlock();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock2.unlock();
            }
        }
    }*/
}

5.2 总结

以上代码中，提供了两种方法，一个是会出现死锁的情况，调用的是lock方法；另一个是不会发生死锁的情况，也就是使用了tryLock方法，这个方法可以尝试获取锁，获取不到锁就会自动放弃，当然我们自己也能指定等待时间，同时我们也要注意tryLock的使用位置，它是在if条件语句中的，与lock方法有些区别

若发生死锁现象，我们有一种解决方案，

使用jps -l 命令显示出进程的信息，我们想要的就是进程号
之后根据进程号我们使用 jstack 进程号我们就能查看堆栈信息了

6. 自旋锁

自旋锁：阻塞或唤醒一个Java线程需要CPU切换状态来完成，需要耗费时间，如果当我们的代码过于简单的时候，切换状态消耗的时间可能会比用户代码执行的时间还要长，为了避免这种情况，自旋锁应需而生，它会让线程进行不断的自旋，直到获取到锁，避免了先换线程的开销（不过JVM中会对自旋锁进行优化，有一个自旋次数的阈值，超过之后就会停止自旋）
atomic包下的类基本上都是自旋锁的实现，例如AtomicInteger，它的原理是CAS，它的getAndIncrement方法（自增）就是利用的自旋锁，调用Unsafe的getAndAddInt方法，如下，直至修改成功才停止

在这里插入图片描述

局限：
如果自旋锁被占用的时间太长，那么自旋的线程只会白白浪费处理器资源
适用场景
在并发度不是特别高的情况下，而且代码块比较简单的时候

6.1 手写一个简单的自旋锁

public class SpinLockDemo {
    private AtomicReference<Thread> spinLock = new AtomicReference<>();
    
    public void lock() {
        Thread cur = Thread.currentThread();
        
        while(spinLock.compareAndSet(null,cur)) {
            
        }
    }
    
    public void unLock() {
        Thread cur = Thread.currentThread();
        spinLock.compareAndSet(cur,null);
    }
}

加油儿！

方圆想当图灵

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
“琐事”？ “锁事”。

1. synchronized2. 你知道Git是乐观锁吗？2.1 在MySQL中实现乐观锁2.2 乐观锁的适用场景3. 公平锁和非公平锁3.1 来，看看这个特例4. 读写锁的插队策略4.1 代码测试5. 写一个死锁5.1 代码5.2 总结6. 自旋锁6.1 手写一个简单的自旋锁1. synchronized它会在发生异常时自动释放锁2. 你知道Git是乐观锁吗？当我们在向远程仓库push的时候，git会检查远端仓库的版本是不是要比我们现在的.
复制链接

扫一扫