JAVA基础知识-JAVA锁

二进制旅人

于 2024-07-12 09:21:15 发布

阅读量909

点赞数 11

分类专栏： Java基础知识文章标签： java 开发语言

本文链接：https://blog.csdn.net/Hisoftjszx/article/details/140369589

版权

Java基础知识专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一. JAVA中锁的概念

1.1自旋锁：是指当一个线程在获取锁的时候，如果锁已经被其他的线程获取，那么该线程将循环等待，然后不断的判断是否能够被成功获取，知道获取到锁才会退出循环

1.2乐观锁：假定没有冲突，在修改数据的时候如果发现和之前的获取的不一致，则读取最新的数据，修改后重试修改

1.3悲观锁：界定会发生并发冲突，同步所有对数据的相关操作，从读数据就开始上锁

1.4独享锁：给资源加上写锁，线程可以修改资源，其他线程不能再加锁（单写）

1.5共享锁：（限流）给资源加上读锁之后只能读不能改，其他的线程也只能加读锁，不能加写锁（多读）

1.6可重入锁、不可重入锁：线程拿到一把锁之后，可以自由进入同一把锁所同步的其他代码

JAVA中常用锁操作介绍

本章节将详细介绍JAVA中Synchronized、Lock、ReentrantLock等实现锁操作的关键字、接口及类的用法和基本原理

1.Synchronized详解

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

1.1 对象值：最本质的就是对象在堆里面存了对象的值，类对象和一些方法的作为类的结构信息会存在方法区里面；如果类里面存在对象，那么只能存对象的引用。

1.2 对象头：里面有引用会指向类对象，通过这个标记，会记录对象的值是属于哪个类。

1.3 padding：对象存在堆中的规律是8个字节的整数倍，padding做补位，无太大的意义。

重点在对象头部：

根据图片我们知道，对象头里面存了3个字段

Mark Word：锁的状态

Class Mate address：存储对象的引用，根据这个引用找到方法区的类对象。

Array length：如果当前对象是个数组对象，这个字段则标记数组的长度。如果不是数组，这个字段无意义。

Synchronized的加锁过程如下：

要点在于Mark word：

1.3.1线程会在虚拟机栈内开辟一块内存区域叫做Lock Record

1.3.2线程会把对象头里面的Mark Word里面的HashcodeAge0(无锁状态)写到这个Lock Record的内存区域

1.3.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官网下载源码来看，大部分看不懂，但是有一些是能看懂的!

2.Lock详解

2.1 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;

}

执行结果如下：

```

3.ReentrantLock底层原理

3.1 ReentrantLock是一把可重入锁，它的内存空间里面有3个东西

waiters: 等待池

owner: 锁持有者

count: 锁重入次数

多个线程来抢锁的时候，是根据CAS原理实现的，抢锁成功的线程，把自己的名字记录到owner，然后执行count+1；未抢到锁的线程这个时候会进入到waiters(此时线程状态：waiting)等待池中，再次抢到锁的线程会修改count+1然后修改owner；如果是同一个线程再次抢到了锁，会直接进行count+1。

3.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;

}

```

4.读写锁ReentrantReadWriterLock

4.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();

}

```

4.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。

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