Java中锁总结

最新推荐文章于 2023-08-11 07:30:00 发布

alex-zhou96

最新推荐文章于 2023-08-11 07:30:00 发布

阅读量213

点赞数

分类专栏：面试

本文链接：https://blog.csdn.net/ZHOUJIAN_TANK/article/details/106594183

版权

面试专栏收录该内容

45 篇文章 1 订阅

订阅专栏

文章目录

Java中常见的锁的分类及其特点

Java中常见的锁的分类及其特点

按照锁特性

公平锁、非公平锁

公平锁、非公平锁:公平锁指多个线程按照申请锁的顺序来获取锁，非公平锁就是没有顺序完全随机，所以能会造成优先级反转或者饥饿现象；synchronized 就是非公平锁，ReentrantLock（使用 CAS 和 AQS 实现）通过构造参数可以决定是非公平锁还是公平锁，默认构造是非公平锁；非公平锁的吞吐量性能比公平锁大好。

可重入锁

可重入锁: 指在同一个线程在外层方法获取锁的时候在进入内层方法会自动获取锁，synchronized 和 ReentrantLock 都是可重入锁，可重入锁可以在一定程度避免死锁。

独享锁和共享锁

独享锁、共享锁:独享锁是指该锁一次只能被一个线程持有，共享锁指该锁可以被多个线程持有；synchronized 和 ReentrantLock 都是独享锁，ReadWriteLock 的读锁是共享锁，写锁是独占锁；ReentrantLock 的独享锁和共享锁也是通过 AQS 来实现的。

乐观锁、悲观锁

乐观锁、悲观锁: 悲观锁认为对于同一个数据的并发操作一定是会发生修改的（哪怕实质没修改也认为会修改），因此对于同一个数据的并发操作，悲观锁采取加锁的形式，因为悲观锁认为不加锁的操作一定有问题；乐观锁则认为对于同一个数据的并发操作是不会发生修改的，在更新数据的时候会采用不断的尝试更新，乐观锁认为不加锁的并发操作是没事的；由此可以看出悲观锁适合写操作非常多的场景，乐观锁适合读操作非常多的场景，不加锁会带来大量的性能提升，悲观锁在 java 中很常见，乐观锁其实就是基于 CAS 的无锁编程，譬如 java 的原子类就是通过 CAS 自旋实现的。

分段锁

分段锁:实质是一种锁的设计策略，不是具体的锁，对于 ConcurrentHashMap 而言其并发的实现就是通过分段锁的形式来实现高效并发操作；当要 put 元素时并不是对整个 hashmap 加锁，而是先通过 hashcode 知道它要放在哪个分段，然后对分段进行加锁，所以多线程 put 元素时只要放在的不是同一个分段就做到了真正的并行插入，但是统计 size 时就需要获取所有的分段锁才能统计；分段锁的设计是为了细化锁的粒度。

偏向锁、轻量级锁、重量级锁

偏向锁、轻量级锁、重量级锁:这种分类是按照锁状态来归纳的，并且是针对 synchronized 的，java 1.6 为了减少获取锁和释放锁带来的性能问题而引入的一种状态，其状态会随着竞争情况逐渐升级，**锁可以升级但不能降级，意味着偏向锁升级成轻量级锁后无法降为偏向锁，**这种升级无法降级的策略目的就是为了提高获得锁和释放锁的效率。

自旋锁

自旋锁:其实是相对于互斥锁的概念，互斥锁线程会进入 WAITING 状态和 RUNNABLE 状态的切换，涉及上下文切换、cpu 抢占等开销，自旋锁的线程一直是 RUNNABLE 状态的，一直在那循环检测锁标志位，机制不重复，但是自旋锁加锁全程消耗 cpu，起始开销虽然低于互斥锁，但随着持锁时间加锁开销是线性增长。

可中断锁

可中断锁:synchronized 是不可中断的，Lock 是可中断的，这里的可中断建立在阻塞等待中断，运行中是无法中断的。

按照功能

隐式锁

synchronized这个特性就是隐式锁

可以加在方法上
锁某个块
加载静态方法上
底层是jvm实现的monitorenter与monitorexit指令

显式锁

在这里插入图片描述

在juc中提供了lock接口，一般锁都是实现了这个接口

/
* Lock接口的API,随后的章节会详细介绍同步器AbstractQueueSynchronizer以及常用Lock接口的实现ReentrantLock
 * Lock接口的实现基本都是通过聚合了一个同步器的子类来完成线程访问控制的。
 *
 *
 */
public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
	 boolean tryLock();
	 boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
	 void unlock();
	/**
	Returns a new {@link Condition} instance that is bound to this
     {@code Lock} instance.
	**/	
	Condition newCondition();
}

ReentrantLock（可重入锁）

ReentranReadWriteLock(读写锁）

/
 * 这底层采用的是AQS？？？
 * 这些锁在同一时刻只允许一个线程进行访问，而读写锁在同一时刻
 * 可以允许多个线程访问，但是在写线程访问时，
 * 所有的度线程和其他写线程均被阻塞。
 * 读写锁维护了一对锁，一个读锁和一个写锁，
 * 通过分离读锁和写锁，使得并发性相比一般的排他锁有很大提升、
 *
 * 在读多余写的情况下，读写锁能够提供比排他锁更好的并发性和吞吐量。
 * Java并发包提供读写锁的实现是ReetrantReadWriteLock,
 *
 *
 * 读写锁同样依赖自定义同步器来实现同步功能
 * 而读写状态就是其同步器的同步状态
 * 回响ReetranLock中自定义同步器的实现，同步状态表示锁被一个线程重复获取的次数，
 * 而读写锁的自定义同步器需要在同步状态（一个整型变量）上维护多个读线程和一个写线程的状态，使得该状态的设计成为读写锁实现的关键
 *
 *
 *如果在一个整型变量上维护多种状态，就一定需要“按位切割使用”这个变量，
 * 读写锁将变量切分成了两个部分，高16位表示读，低16位表示写
 */
public class ReentrantReadWriteLock
        implements ReadWriteLock, java.io.Serializable {


    private static final long serialVersionUID = -6992448646407690164L;

    /** Inner class providing readlock */
    private final ReentrantReadWriteLock.ReadLock readerLock;

    /** Inner class providing writelock */
    private final ReentrantReadWriteLock.WriteLock writerLock;

    /** Performs all synchronization mechanics */
    final Sync sync;

    /**
     * Creates a new {@code ReentrantReadWriteLock} with
     * default (nonfair) ordering properties.
     */
    public ReentrantReadWriteLock() {
        this(false);
    }

    /**
     * Creates a new {@code ReentrantReadWriteLock} with
     * the given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }

    public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
    public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }

例子


package Multithread.Improve.ReadWriteLock;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @Author Zhou  jian
 * @Date 2020 ${month}  2020/5/4 0004  21:56
 * 读写锁更加细粒度的读写 数据
 * 独占锁（写锁）
 * 共享锁（读锁）
 */
public class ReadWriteLockDemo {

    public static void main(String[] args) {
        MyCache2 myCache = new MyCache2();
        for(int i=0;i<20;i++){
            final int temp = i;
            new Thread(()->{myCache.put(temp+"",temp);}).start();
        }

        for(int i=0;i<20;i++){
            final int temp = i;
            new Thread(()->{myCache.get(temp+"");}).start();
        }
    }


}


//加锁的
class MyCache2{

    private volatile Map<String,Object> map = new HashMap<>();
    //读写锁，更加细粒度的控制
    private ReadWriteLock lock = new ReentrantReadWriteLock();

    //存 写  写入的时候只希望同时有一个线程写
    public  void put(String key,Object value){
        //加了一把写锁
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"写入"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写入ok");
        }finally {
            lock.writeLock().unlock();
        }


    }

    //读取
    public  void get(String key){
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"读取"+key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取OK");
        }finally {
            lock.readLock().unlock();
        }

    }


}

synchronize与reentranlock的区别？

在这里插入图片描述
两者共同点

协调多线程对共享对象、变量的访问
可重入，同一线程可以多次获得同一个锁
都保证了可见性和互斥性

两者区别

首选synchronbized是jvm提供的，可以修饰方法和代码块，底层翻译成moniorenter指令；reentralock是jdk提供的lock接口实现的一个类
其次，都可以实现同步机制；在使用的时候synchronized是隐式的加锁与释放锁，reentranLock需要显示的加锁与释放锁
reentrnlock提供了丰富的api，实现了更为丰富的功能，reentranLock是等待可中断的，lockIntreeruptly()，**等待可中断是当当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择释放等待，改为处理其他事情，可以避免死锁
公平锁，多个线程等待同一个锁时，必须按照申请锁的时间顺序获得锁，Synchronized锁非公平锁，ReentrantLock默认的构造函数是创建的非公平锁，可以通过参数true设为公平锁，但公平锁表现的性能不是很好
锁绑定多个条件，一个ReentrantLock对象可以同时绑定对个对象。

什么时候用synchronized与用reentranLock?

什么时候选择使用synchronized，什么使用选择使用ReentrantLock
仅当synchronized不能满足时才使用ReentrantLock，因为使用ReentrantLock要非常小心，不释放锁将影响其他需要该锁的代码块运行
不能使用synchronized不满足的情形：

公平性
可中断
分块结构的加锁，比如jdk1.7ConcurrentHashMap的分段锁（目前还不是提别理解这个，先记住这个例子，后头补充）

alex-zhou96

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java中锁总结

文章目录Java中常见的锁的分类及其特点按照锁特性公平锁、非公平锁可重入锁独享锁和共享锁乐观锁、悲观锁分段锁偏向锁、轻量级锁、重量级锁自旋锁可中断锁按照功能隐式锁显式锁ReentrantLock（可重入锁）ReentranReadWriteLock(读写锁）synchronize与reentranlock的区别？什么时候用synchronized与用reentranLock?Java中常见的锁的分类及其特点按照锁特性公平锁、非公平锁公平锁、非公平锁:公平锁指多个线程按照申请锁的顺序来获取锁，非公
复制链接

扫一扫