Java高并发编程实战6,通过AQS源码分析lock()锁机制

目录

    • 一、JVM内存区域
    • 二、JVM内存模型(Java Memory Model,简称JMM)
    • 三、各个线程运行期间必须遵守的规定
    • 四、wait与notify
    • 五、tryLock
      • 1、代码实例
      • 2、lock()和tryLock()有何不同?
    • 六、AQS源码分析
      • 1、state
      • 2、访问state的方法
      • 3、加锁方式
      • 4、独占方式的加锁与解锁
      • 5、共享方式的加锁与解锁
      • 6、CountDownLatch
      • Java高并发编程实战系列文章
      • 哪吒精品系列文章

一、JVM内存区域

JVM在运行时,会将其管理的内存区域划分为方法区、堆、虚拟机栈、本地方法栈和程序计数器5个区域;

  • 方法区和堆是所有下城共享的区域;
  • 虚拟机栈、本地方法栈、程序计数器是各个线程私有的;

Java高并发编程实战6,通过AQS源码分析lock()锁机制_第1张图片

二、JVM内存模型(Java Memory Model,简称JMM)

JMM用于定义程序汇总变量的访问规则,即在JVM中如何将变量存储到内存,以及如何从内存中获取变量(此处变量指所有线程共享的变量)。

与JVM内存区域不同,JMM是从另一个角度对内存进行划分,分为主内存和工作内存。

JMM规定所有的变量都存储在主内存中,每个线程还拥有自己独立的工作内存。主内存中的变量会通过复制的方式留给线程的工作内存一个副本,供各个线程独立使用。 线程对变量的所有读写操作都是在工作内存中进行的,工作内存中的副本变量会通过JMM与主内存中的原变量保持同步。

Java高并发编程实战6,通过AQS源码分析lock()锁机制_第2张图片

三、各个线程运行期间必须遵守的规定

  1. 只能方案文自己工作内存中的变量;
  2. 无法直接访问其他线程工作内存中的变量;
  3. 可以通过主内粗间接访问其他线程工作内存中的变量;

四、wait与notify

多个线程在争夺同一个资源时,为了让这些线程协同工作、提高CPU利用率,可以让线程之间进行沟通,具体可以通过wait()和notify()实现。

  1. wait():使当前线程处于等待状态,即阻塞,直到其它线程调用此对象的notify()方法;
  2. notify():唤醒在此对象监视器上等待的单个线程,如果有多个线程同时在监视器上等待,则随机唤醒一个;
  3. notifyAll():唤醒在此对象监视器上等待的所有线程;

使用时需要注意几点:

  1. 三个方法都是Object()类中定义的native方法,而不是thread类提供的,这是因为Java提供的类是对象级的,而不是线程级的;
  2. 这三个方法都必须在synchronized修饰的方法或代码块中使用,否则会抛出异常;
  3. 使用wait()时,为了避免并发带来的问题,通常建议将wait()方法写在循环的内部。

五、tryLock

tryLock的意思是,当一个线程尝试加锁失败后,会再次请求,持续一段时间,如果一直失败则放弃加锁。

1、代码实例

package com.guor.demo.thread;

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

public class TryLockTest extends Thread{

    Lock lock = new ReentrantLock();

    @Override
    public void run() {
        // 获取线程名称
        String threadName = Thread.currentThread().getName();
        boolean isLocked = false;
        try {
            // 在2秒内尝试加锁
            isLocked = lock.tryLock(2, TimeUnit.SECONDS);
            // 加锁成功
            if(isLocked){
               Thread.sleep(1000);
                System.out.println(threadName+"加锁成功");
            }else {
                System.out.println(threadName+"加锁失败");
            }
        } catch (InterruptedException e) {
            System.out.println(threadName+"tryLock 异常:"+e);
        }finally {
            if(isLocked){
                lock.unlock();
                System.out.println(threadName+"解锁");
            }
        }
    }

    public static void main(String[] args) {
        TryLockTest thread1 = new TryLockTest();
        TryLockTest thread2 = new TryLockTest();
        thread1.setName("线程1");
        thread2.setName("线程2");
        thread1.start();
        thread2.start();
    }
}

Java高并发编程实战6,通过AQS源码分析lock()锁机制_第3张图片

2、lock()和tryLock()有何不同?

  • lock():尝试获取锁,如果锁被占用则等待;
  • tryLock():尝试获取锁,如果锁被占用则返回false,则不再等待,如果锁未被占用,则立刻获取锁,并返回true;
  • tryLock(long time, TimeUnit unit):在tryLock()的基础上,如果锁被占用,则会在一段时间内不断地尝试获取锁,直至成功获取锁;
  • lockInterruptibly():一个线程加锁之后,其它线程因为无法获取锁而导致的等待状态可以被中断;

六、AQS源码分析

1、state

在AQS中维护着一个表示共享资源加锁情况的变量 volatile int state,以及一个FIFO的线程阻塞队列(称为CLH队列)。当多个线程并发访问共享资源时,如果共享资源已经被某个线程加了锁,那么其它线程在访问此共享资源时就会加入CLH队列。

Java高并发编程实战6,通过AQS源码分析lock()锁机制_第4张图片
state表示共享资源被线程加锁的次数。

当state的值为1时,就表示共享资源被某个线程加了一次锁;
当state的值为0时,表示共享资源没有被加锁,随时可以访问;

2、访问state的方法

  1. int getState(),获取state值;
  2. void setState(int newState),设置state值;
  3. compareAndSetState(int expect,int update),使用哪个CAS算法,设置state值;

3、加锁方式

  1. Exclusive:独占方式,同一时间内只能有一个线程访问资源,如ReentrantLock采用的是独占方式;
  2. Share:共享方式,同一时间内允许多个线程并发访问资源,如CountDownLatch采用的就是共享方式;

4、独占方式的加锁与解锁

  1. boolean tryAcquire(int arg):尝试获取资源,如果成功,就给该资源加arg个锁,并独占该资源;
  2. boolean tryRelease(int arg):尝试释放资源,如果成功,就释放该资源的arg个锁;
  3. boolean isHeldExclusively():判断当前线程,是否正在独占共享资源;

例如ReentrantLock的state初始值为0,当某个线程调用lock()方法时,lock()就会在底层触发tryAcquire(1),把该资源的state修改为1,表示该资源加了一把锁,之后就可以独占使用该资源,之后再调用lock()就会失败并进入阻塞状态(因为ReentrantLock是独占方式,同一时间只能被一个线程加锁),只有在该线程调用哪个unlock()的时候,会在底层触发tryRelease(1)将state的值变为0,也就是释放锁。

5、共享方式的加锁与解锁

(1)int tryAcquireShared(int arg)

  1. 尝试给太资源加arg个共享锁,并访问该资源;
  2. 返回负数:加锁失败,当前线程进入CLH等待;
  3. 返回0:当前线程加锁成功,但后续其它线程无法再加共享锁;
  4. 返回整数:当前线程加锁成功,并且后续线程也可以再加共享锁;

(2)tryReleaseShared(int arg)

尝试释放该资源的arg个锁。

6、CountDownLatch

CountDownLatch的构造方法CountDownLatch(int count)可以将state的初始值设置为count,并交给count个线程去并发执行,于此同时,主线程进入阻塞状态。当每个子线程执行完毕后,都会调用一次countDown(),countDown()会在底层调用tryReleaseShared(1),即把state减1。

因此,当所有子线程全部执行完毕后,state的值就会变为0,此时唤醒主线程,从而实现了闭锁功能


Java高并发编程实战系列文章

Java高并发编程实战1,那些年学过的锁

Java高并发编程实战2,原子性、可见性、有序性,傻傻分不清

Java高并发编程实战3,Java内存模型与Java对象结构

Java高并发编程实战4,synchronized与Lock底层原理

Java高并发编程实战5,异步注解@Async自定义线程池

哪吒精品系列文章

Java学习路线总结,搬砖工逆袭Java架构师

10万字208道Java经典面试题总结(附答案)

SQL性能优化的21个小技巧

Java基础教程系列

Spring Boot 进阶实战
在这里插入图片描述

你可能感兴趣的:(Java高并发编程,java,jvm,高并发)