JAVA锁

已于 2024-07-10 11:49:38 修改
阅读量1.1k 收藏 46
点赞数 8
分类专栏： 线程专题 文章标签： JAVA锁
于 2019-09-21 09:56:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40094875/article/details/100928808
版权

一. JAVA中锁的概念

1、自旋锁：是指当一个线程在获取锁的时候，如果锁已经被其他的线程获取，那么该线程将循环等待，然后不断的判断是否能够被成功获取，知道获取到锁才会退出循环
2、乐观锁：假定没有冲突，在修改数据的时候如果发现和之前的获取的不一致，则读取最新的数据，修改后重试修改
3、悲观锁：界定会发生并发冲突，同步所有对数据的相关操作，从读数据就开始上锁
4、独享锁：给资源加上写锁，线程可以修改资源，其他线程不能再加锁（单写）
5：共享锁：（限流）给资源加上读锁之后只能读不能改，其他的线程也只能加读锁，不能加写锁（多读）
6、可重入锁、不可重入锁：线程拿到一把锁之后，可以自由进入同一把锁所同步的其他代码

二、Synchronized详解

首先说下对象在堆中存的是怎么存的？

1、对象值：最本质的就是对象在堆里面存了对象的值，类对象和一些方法的作为类的结构信息会存在方法区里面；如果类里面存在对象，那么只能存对象的引用。
2、对象头：里面有引用会指向类对象，通过这个标记，会记录对象的值是属于哪个类。
3、padding：对象存在堆中的规律是8个字节的整数倍，padding做补位，无太大的意义。

重点在对象头部：
在这里插入图片描述
根据图片我们知道，对象头里面存了3个字段
Mark Word：锁的状态
Class Mate address：存储对象的引用，根据这个引用找到方法区的类对象。
Array length：如果当前对象是个数组对象，这个字段则标记数组的长度。如果不是数组，这个字段无意义。

Synchronized的加锁过程如下：

要点在于Mark word：

1、线程会在虚拟机栈内开辟一块内存区域 叫做Lock Record
2、线程会把对象头里面的Mark Word里面的HashcodeAge0(无锁状态)写到这个Lock Record的内存区域
3、多个线程枪锁的时候就会进行CAS操作(新值：Lock Record Adress;旧值：HashcodeAge0)，抢到锁的线程会把HashcodeAge0值替换成Lock Record Addess值，这个时候说明一个线程枪锁成功，没有抢到锁的线程会发生自旋，当自旋到达一定的次数(具体几次，暂时没有查到可靠的资料)之后，或者其他线程来了之后CAS的时候compare没有成功，这两种原因都会造成Mark Word里面的锁升级为重量级锁Monitor address。

对象监视器Monitor:
JVM会帮我们维护一个特殊机制（对象监视器），java中每一个对象都可能存在一个对象监视器，这个监视器来监视我们的对象，最大的作用就是实现锁的机制，这个Monitor里面有一个owner，这个owner相当对一个线程的引用，它会记录是哪个线程抢到了锁，类似于owner=thread1。
未抢到锁的线程这个时候会进入到Monitor的锁池(entryList)里面等待状态为Blocked阻塞，锁池是一个队列，先进先出。当然Monitor里不光是只有锁池，还有等待池，当owner释放了锁【可以理解为owner=null】这个时候，线程如果调用wait()方法，由此可见，synchronized只有在获得锁之后才能调用wait()方法，调用wait()方法的线程就会进入等待池里面，线程状态就会变成waiting，然后线程如果调用notify()方法，就会进入锁池(entryList)，状态就会重新变成Blocked状态；当然如果代码运行完了，锁就会自动释放。

以上原理有点绕，但不是瞎编乱造，可以去hotspot官网下载源码来看，大部分看不懂，但是有一些是能看懂的在这里插入图片描述

三、Lock详解

Lock接口的方法签名：

void lock():  获取锁（获取不到一直获取）
boolead tryLock():  获取锁（获取不到我就不获取了）
boolean tryLock(long time,TimeUnit unit) throws InterruptedException （获取锁，有等待时间，过时就不获取了）
void lockInterruptibly() throws InterruptedException;获取锁 (可以被其他线程阻断获取)
void unlock(); 释放锁
Condition newContidion():  挂起或唤醒线程

其中lock()最常用；

复习一下线程通信的内容：
在这里插入图片描述
Object中的wait()/notify()、notifyAll()只能和synchronizde配合使用，可以唤醒一个或者多个线程；condetion需要和Lock配合使用，提供等待线程集合，可以更精准。

好的来看代码演示：

package com.nipx.demo.CAS;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Condition_Demo1 {
    private static Lock lock = new ReentrantLock();
    private static Condition condition = lock.newCondition();

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                lock.lock();
                try {
                    System.out.println("线程开始挂起......");
                    condition.await();
                    System.out.println("线程开始释放......");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });
        thread.start();
        Thread.sleep(5000L);

        condition.signal();
    }
}

在这里插入图片描述
报错了：原因就是我们的condition不管是挂起还是唤醒，都必须和lock配合使用然后我们修改代码：

package com.nipx.demo.CAS;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Condition_Demo1 {
    private static Lock lock = new ReentrantLock();
    private static Condition condition = lock.newCondition();

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                lock.lock();
                try {
                    System.out.println("线程开始挂起......");
                    condition.await();
                    System.out.println("线程开始释放......");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });
        thread.start();
        Thread.sleep(5000L);
        lock.lock();
        condition.signal();
        lock.unlock();
    }
}

在这里插入图片描述
可以了。

然后我们演示死锁的代码，线程先唤醒，再挂起。

package com.nipx.demo.CAS;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Condition_Demo1 {
    private static Lock lock = new ReentrantLock();
    private static Condition condition = lock.newCondition();

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(5000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                lock.lock();
                try {
                    System.out.println("5秒之后线程开始挂起等待......");
                    condition.await();
                    System.out.println("线程开始释放......");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });
        thread.start();
        Thread.sleep(2000L);
        lock.lock();
        System.out.println("2秒之后线程先唤醒.....");
        condition.signal();
        lock.unlock();
    }
}

在这里插入图片描述
然后我们用condition来实现一个阻塞队列：
/**
要求：阻塞队列只能存储n个元素
take 时：若队列有元素就直接获取；如果没有，则等待元素
put 时：若队列未满，就直接put；如果已满，则阻塞，等到再有空间去put
*/

package com.nipx.demo.CAS;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Condition_Demo2 {
    private static Lock lock = new ReentrantLock();
    private static Condition putCondition = lock.newCondition();
    private static Condition takeCondition = lock.newCondition();
    List<Object> list = new ArrayList();
    private int length;
    public Condition_Demo2(int length) {
        this.length = length;
    }
    public static void main(String[] args) throws InterruptedException {
        Condition_Demo2 demo2 = new Condition_Demo2(4);
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                try {
                    demo2.put("元素：" + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        Thread.sleep(3000L);
        for (int i = 0; i < 10; i++) {
            demo2.take();
            Thread.sleep(2000L);
        }
    }
    public void put(Object object) throws InterruptedException {
        lock.lock();
        try {
            while (true) {
                if (list.size() < length) {
                    list.add(object);
                    takeCondition.signal();
                    System.out.println("put" + object);
                    return;
                } else {
                    putCondition.await();
                }
            }
        } finally {
            lock.unlock();
        }
    }

    public Object take() {
        lock.lock();
        try {
            while (true) {
                if (list.size() > 0) {
                    Object ob = list.remove(0);
                    putCondition.signal();
                    System.out.println("take" + ob);
                    return ob;
                } else {
                    takeCondition.await();
                }
            }
        } finally {
            lock.unlock();
            return null;
        }
    }
}

执行结果如下：

在这里插入图片描述

四、ReentrantLock底层原理

1、ReentrantLock是一把可重入锁，它的内存空间里面有3个东西
waiters: 等待池
owner: 锁持有者
count: 锁重入次数
多个线程来抢锁的时候，是根据CAS原理实现的，抢锁成功的线程，把自己的名字记 录到owner，然后执行count+1；未抢到锁的线程这个时候会进入到waiters(此时线程状态：waiting)等待池中，再次抢到锁的线程会修改count+1然后修改owner；如果是同一个线程再次抢到了锁，会直接进行count+1。

2、自己实现一把可重入锁ReentrantLock代码如下：

package com.nipx.demo.CAS;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;

public class ReentrantLock implements Lock {
    // 锁持有者 owner
    private AtomicReference<Thread> owner = new AtomicReference<>();

    // 可重入次数
    private AtomicInteger count = new AtomicInteger(0);

    // 等待池
    private LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue();


    @Override
    public boolean tryLock() {
        int ct = count.get();
        //判断count值是否为0，如果不为0，则说明锁被占用
        if (ct != 0) {
            //判断是否是当前线程占用，做重入
            if (Thread.currentThread() == owner.get()) {
                count.set(ct + 1);
                return true;
            }
        } else {// 判断count值如果为0，则通过CAS来抢锁
            if (count.compareAndSet(ct, ct + 1)) {
                owner.set(Thread.currentThread());
            }
        }
        return false;
    }

    @Override
    public void lock() {
        if (!tryLock()) {
            //加入等待队列
            waiters.offer(Thread.currentThread());
            while (true) {//自旋
                //如果线程是队列的头部，则尝试加锁
                Thread thread = waiters.peek();
                if (thread == Thread.currentThread()) {
                    if (!tryLock()) {
                        LockSupport.park();
                    } else {
                        waiters.poll();
                        return;
                    }
                } else {
                    LockSupport.park();
                }
            }

        }

    }

    public boolean tryUnlock() {
        if (owner.get() != Thread.currentThread()) {
            throw new IllegalMonitorStateException();
        } else {
            //unlock 就是将count-1
            int newCount = count.get() - 1;
            count.set(newCount);
            //如果减1之后为0，说明成功释放锁
            if (newCount == 0) {
                owner.compareAndSet(Thread.currentThread(), null);
                return true;
            } else {
                return false;
            }
        }
    }

    @Override
    public void unlock() {
        if (!tryUnlock()) {
            //获取头部的线程
            Thread head = waiters.peek();
            if (head != null) {
                LockSupport.unpark(head);
            }
        }
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }


    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }


    @Override
    public Condition newCondition() {
        return null;
    }
}

五、读写锁ReentrantReadWriterLock

1、主要目的就是解决了性能问题，正常的读和写是互斥的，每次只能有一个线程去执行读或者写，这样就产生了性能问题，读写锁主要让读和写继续互斥，但是把读锁变成共享锁，写操作只需要一个线程操作，而读操作可以是多个线程来操作。

首先明确一点，Hashtable的源码解释是这样的：
在这里插入图片描述
【{@code Hashtable}是同步的。如果一个不需要线程安全实现，建议使用

  • {@link HashMap}代替了{@code Hashtable}。
  • 如果一个线程安全的需要高并发的实现，然后推荐使用
    *使用{@link java.util.concurrent。ConcurrentHashMap}代替】

也就是说JDK其实是不建议用hashtable的，对于高并发，它建议我们使用ConcurrentHashMap；如何用读写锁把HashMap变得线程安全？

代码如下：

package com.nipx.demo.CAS;
import java.util.HashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class HashMap_Demo {
    private final HashMap<String, Object> map = new HashMap<>();
    private final ReadWriteLock writeLock = new ReentrantReadWriteLock();
    private final Lock r = writeLock.readLock();
    private final Lock w = writeLock.writeLock();
    public Object put(String key, Object value) {
        w.lock();
        try { 
            return map.put(key, value);
        } finally {
            w.unlock();
        }
    }

    public Object get(Object key) {
        r.lock();
        try {
            return map.get(key);
        } finally {
            r.unlock();
        }
    }
    public void clear() {
        w.lock();
        try {
            map.clear();
        } finally {
            w.unlock();
        }
    }
}

2、读写锁的原理
读写锁是两把锁，一把是读锁，一把是写锁，他和ReentrantLock差不多，也有waiters等待池，owner和count；但是count分为readCount和writerCount。
waiters：等待池
owner：锁拥有着
readCount：读锁次数
writerCount：写锁次数

假设现在又线程t1、t2、t3、t4。

如果现在t1线程去抢写锁，那么它会判断此时读锁里面的readCount是否为0，如果不为零，那么表示此时有线程在持有读锁，t1线程就会去等待池中；如果为0，那么t1线程就会抢锁成功，writerCount+1之后会把owner修改为自己，t2线程这时也要抢写锁，它首先也得判断此时读锁里面的readCount是否为0，如果为0，那么它就会进行CAS操作去抢写锁，抢锁失败就会去等待池中等待。

如果现在t3线程去抢读锁，那么它首先会判断此时写锁里面的writerCount是否为0，如果不为0，那么它说明此时有线程持有写锁，这个时候t3会对owner进行判断，如果是自己，那么进行锁降级，写锁降级为读锁；如果不是自己，那么t3就去等待池等待；如果为0，那么就去抢读锁，成功之后只会把readCount+1,并不会修改owner；t4线程这时候如果也来抢占读锁，判断此时写锁里面的writerCount是为0后，那么t4也会执行readCount+1。

这样就形成了单写多读的状态。

六、synchronized和lock的区别

synchronized和lock的区别在哪

1、synchronized:
【优点】：
a.使用简单，语义清晰，哪里需要加哪里。
b.由jvm提供，提出了很多优化（锁粗话，锁消除，偏向锁）
c.锁的释放由虚拟机提供，无人工化，降低了死锁的可能性
【缺点】
a.无法实现一些高级的功能，例如：公平锁、中断锁、超时锁、读写锁、共享锁

2、lock:
【优点】：所有synchronized的缺点
【缺点】：需要手动释放锁

鲁子敬。
关注
  • 8
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java中的各种锁
weixin_53818213的博客
09-20 500
乐观锁、悲观锁、共享锁、独占锁、公平锁、非公平锁、可重入锁、互斥锁、读写锁、分段锁、同步锁、死锁、自旋锁、锁粗化、锁消除、重量级锁、偏向锁、轻量级锁
java锁详解.pdf
12-31
Java 锁详解 Java 锁是 Java 并发编程中的一种基本机制，用于确保线程安全和避免竞争条件。Java 锁可以分为两大类：synchronized 锁和 ReentrantLock 锁。 一、Synchronized 锁 1. 锁的原理：synchronized 锁是...
Java中的锁
weixin_34413103的博客
04-20 1679
在学习或者使用Java的过程中进程会遇到各种各样的锁的概念：公平锁、非公平锁、自旋锁、可重入锁、偏向锁、轻量级锁、重量级锁、读写锁、互斥锁等待。这里整理了Java中的各种锁，若有不足之处希望大家在下方留言探讨。 WARNING：本文适合有一定JAVA基础的同学阅读。 公平锁和非公平锁 公平锁是指多个线程在等待同一个锁时，必须按...
java锁机制
Mr.BoBo的博客
08-21 377
Java锁机制【转自：java各种锁的详细介绍】 个人总结： 悲观锁：在共享的资源上直接加锁，即为认为线程操作会出现线程问题，所以悲观。 乐观锁：乐观锁认为自己在使用数据时不会有别的线程修改数据，所以不会添加锁，只是在更新数据的时候去判断之前有没有别的线程更新了这个数据。例如CAS 自旋锁：对于某些线程，可能执行的操作比较简单，如果阻塞的话，可能会比较耗费CPU资源，所以采用让他先自己等待（即自旋），每旋转一次则判断一次是否可以操作当前资源，直到操作成功。 public final int getAn
Java中的锁详解篇
古城的博客
06-08 5330
在Java中的锁主要是用于保障线程在多并发的情况下数据的一致性。就是实现并发的原子性。在多线程编程中为了保证数据的一致性，我们通常需要在使用对象或者调用方法之前加锁，这时如果有其他线程也需要使用该对象或者调用该方法，则首先要获得锁，如果某个线程发现锁正在被其他线程使用，就会进入阻塞队列等待锁的释放，直到其他线程执行完成并释放锁，该线程才有机会再次获取锁并执行操作。这样做可以保障了在同一时刻只有一个线程持有该对象的锁并修改该对象，从而保障数据的安全性。在Java当中有很多锁的名次，这些并不时全指锁，有的指所得
不可不说的Java“锁”事
weixin_33924312的博客
11-28 259
2019独角兽企业重金招聘Python工程师标准>>> ...
Java锁的升级策略 偏向锁 轻量级锁 重量级锁
08-25
Java锁的升级策略 Java锁的升级策略是指Java语言中锁机制的四种状态：无锁状态、偏向锁、轻量级锁、重量级锁。这些锁状态都是专门针对Synchronized关键字的，是为了提高获得锁和释放锁的效率。 首先，无锁状态是指...
Java锁升级的实现过程
08-19
Java 锁升级的实现过程 Java 锁升级是 Java 中的一种同步机制，用于解决多线程并发访问共享资源的问题。 Java 锁升级的实现过程可以分为三个阶段：偏向锁、轻量级锁和重量级锁。 对象内存布局 在 Java 中，对象在...
Java锁之自旋锁详解
09-04
Java中的自旋锁是一种在多线程环境下用于同步和控制并发访问共享资源的机制。它在并发编程中扮演着重要角色，特别是在高并发系统中。自旋锁的基本思想是，当一个线程试图获取锁而该锁已被其他线程持有时，这个线程并...
Java中的锁分类
weixin_30729609的博客
05-09 1210
在读很多并发文章中，会提及各种各样锁如公平锁，乐观锁等等，这篇文章介绍各种锁的分类。介绍的内容如下： 公平锁/非公平锁 可重入锁 独享锁/共享锁 互斥锁/读写锁 乐观锁/悲观锁 分段锁 偏向锁/轻量级锁/重量级锁 自旋锁 上面是很多锁的名词，这些分类并不是全是指锁的状态，有的指锁的特性，有的指锁的设计，下面总结的内容是对每个锁的名词进行一定的解释。 公平锁/非公平锁 公平锁是指多个线程按照申请...
java中的锁
我写我所想！
09-28 1325
java中有哪些锁这个问题在我看了一遍synchronized首先来看看用的比较多的synchronized，我的日常工作中大多用的也是它。synchronized是用于为某个代码块的提供锁机制，在java的对象中会隐式的拥有一个锁，这个锁被称为内置锁(intrinsic)或监视器锁(monitor locks)。线程在进入被synchronized保护的块之前自动获得这个锁，直到完成代码后(也可能
Java锁
夏目川城的博客
03-24 1226
Java锁是什么？为什么要用Java锁？ 在并发编程中，经常遇到多个线程访问同一个共享资源 ，这时候作为开发者必须考虑如何维护数据一致性，在java中synchronized关键字被常用于维护数据一致性。synchronized机制是给共享资源上锁，只有拿到锁的线程才可以访问共享资源，这样就可以强制使得对共享资源的访问都是顺序的，因为对于共享资源属性访问是必要也是必须的。 一般在java中所说的锁...
Java多线程中锁的理解与使用
热门推荐
洪伟的专栏
10-14 4万+
锁作为并发共享数据，保证一致性的工具，在JAVA平台有多种实现(如 synchronized 和 ReentrantLock等 )
Java中常见的各种锁（非常全）
xingchensuiyue的博客
09-21 1万+
这里写自定义目录标题乐观锁悲观锁自旋锁原理自旋锁优缺点优点缺点自旋锁时间阈值(1.6 引入了适应性自旋锁)自旋锁的开启Synchronized 同步锁Synchronized作用范围Synchronized实现JDK1.6后的优化ReentrantLockLock接口主要方法tryLock 和 lock 和 lockInterruptiblyReentrantLock 与 synchronized非公平锁公平锁可重入锁(递归锁)读写锁独占锁共享锁独占锁共享锁锁状态重量级锁(Mutex Lock)轻量级锁偏向
深入理解JAVA锁的膨胀过程与Monitor机制
"JAVA锁的膨胀过程-分析-适合Java新手到架构师" 在Java编程语言中，`synchronized`关键字是实现线程同步的关键，它提供了锁机制来保证多线程环境下的数据一致性。自从JDK 6开始，Java引入了优化措施，包括偏向锁和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值