面试官一次次问Java的锁时，你是怎么回答的？80%的人都说不完善

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

并发包中ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁或非公平锁，默认是非公平锁。

关于两者的区别

公平锁：Threads acquire a fair lock in the order which they requested it.

公平锁，就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后按照FIFO的规则从队列中取到自己。

非公平锁：a nonfair lock permits barging: treads requesting a lock can jump ahead of the queue of waiting threads if the lock happens to be available when it is requested.

非公平锁，毕竟粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁的那种方式。

题外话

Java ReentrantLock而言

通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。

对于Synchronized而言，也是一种非公平锁。

自旋锁与非自旋锁

自旋锁的概念

自旋锁（spinlock），是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU。

自旋锁的优点

自旋锁不会使线程状态发生切换，一直处于用户态，即线程一直都是active的；不会使线程进入阻塞状态，减少了不必要的上下文切换，执行速度快

非自旋锁在获取不到锁的时候会进入阻塞状态，从而进入内核态，当获取到锁的时候需要从内核态恢复，需要线程上下文切换。 （线程被阻塞后便进入内核（Linux）调度状态，这个会导致系统在用户态与内核态之间来回切换，严重影响锁的性能）

// unsafe.getAndAddInt
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

return var5;
}

Demo1# 实现一个自旋锁

package com.nuih.lock;

import sun.misc.Unsafe;

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

/**

• 题目：实现一个自旋锁
• 自旋锁好处：循环比较获取直到成功为止，没有类似wait的阻塞
• 通过cas操作完成自旋锁，A线程先进来调用myLock方法自己持有锁5秒钟，
• B随后进来后发现当前又线程持有锁，不是null，所以只能通过自旋等待，直到A释放锁后B随后抢到
• @author: hejianhui
• @create: 2020-06-21 15:05
• @see SpinLockDemo
• @since JDK1.8
  */
  public class SpinLockDemo {

// 原子引用
AtomicReference atomicReference = new AtomicReference<>();

public void myLock(){
Thread thread = Thread.currentThread();
System.out.println(thread.getName() + “\t come in 😊”);
while (!atomicReference.compareAndSet(null,thread)){

}
}

public void myUnLock(){
Thread thread = Thread.currentThread();
atomicReference.compareAndSet(thread,null);
System.out.println(thread.getName() + “\t invoked myUnLock”);
}

public static void main(String[] args) throws InterruptedException {
SpinLockDemo spinLockDemo = new SpinLockDemo();

new Thread(() -> {
spinLockDemo.myLock();

try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
spinLockDemo.myUnLock();

},“A”).start();

TimeUnit.SECONDS.sleep(1);

new Thread(() -> {
spinLockDemo.myLock();

try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
spinLockDemo.myUnLock();
},“B”).start();

}
}

可重入锁（又名递归锁）

可重入锁的概念

可重入锁（也叫做递归锁）

指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。也就是说，线程可以进入任何一个它已经拥有的锁所同步着的代码快。

ReentrantLock / Synchronized 就是一个典型的可重入锁

可重入锁的最大作用是避免死锁

Demo2# 可重入锁

package com.nuih.lock;

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

class MyPhone implements Runnable {

public synchronized void sendMsg(){
System.out.println(Thread.currentThread().getName() + “\t invoked sendMsg”);
sendEmail();
}

public synchronized void sendEmail(){
System.out.println(Thread.currentThread().getName() + “\t##### invoked sendEmail”);
}

Lock lock = new ReentrantLock();

@Override
public void run() {
get();
}

public void get(){
lock.lock();
try{
System.out.println(Thread.currentThread().getName() + “\t invoked get”);
set();
}finally {
lock.unlock();
}
}

public void set(){
lock.lock();
try{
System.out.println(Thread.currentThread().getName() + “\t###### invoked set”);
}finally {
lock.unlock();
}
}
}

/**

• 可重入锁（也叫做递归锁）
• 指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，
• 在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。
• 也就是说，线程可以进入任何一个它已经拥有的锁所同步着的代码快。
• t1 invoked sendMsg() t1线程在外层方法获取锁的时候
• t1 ##### invoked sendEmail t1在进入内层方法会自动获取锁
• t2 invoked sendMsg()
• t2 ##### invoked sendEmail
• @author: hejianhui
• @create: 2020-06-21 14:10
• @see ReentrantLockDemo
• @since JDK1.8
  */
  public class ReentrantLockDemo {

public static void main(String[] args) throws InterruptedException {

MyPhone myPhone = new MyPhone();

new Thread(() -> {
myPhone.sendMsg();
},“t1”).start();

new Thread(() -> {
myPhone.sendMsg();
},“t2”).start();

TimeUnit.SECONDS.sleep(1);
System.out.println(“\n\n\n\n”);

Thread t3 = new Thread(myPhone,“t3”);
t3.start();

Thread t4 = new Thread(myPhone,“t4”);
t4.start();

}
}

独占锁（写锁）/共享锁（写锁）/互斥锁

是什么？

独占锁：指该锁一次只能被一个线程所持有。对ReentrantLock和Synchronized而言都是独占锁

共享锁：指该锁可被多个线程所持有。

对ReentrantReadWriteLock其读锁是共享锁，其写锁是独占锁。

读锁的共享锁可保证并发读是非常高效的，读写、写读、写写的过程是互斥的。

Demo#3 独占锁/共享锁

package com.nuih.lock;

import com.nuih.map.HashMap;
import com.nuih.map.Map;

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

最后

既已说到spring cloud alibaba，那对于整个微服务架构，如果想要进一步地向上提升自己，到底应该掌握哪些核心技能呢？

就个人而言，对于整个微服务架构，像RPC、Dubbo、Spring Boot、Spring Cloud Alibaba、Docker、kubernetes、Spring Cloud Netflix、Service Mesh等这些都是最最核心的知识，架构师必经之路！下图，是自绘的微服务架构路线体系大纲，如果有还不知道自己该掌握些啥技术的朋友，可根据小编手绘的大纲进行一个参考。

如果觉得图片不够清晰，也可来找小编分享原件的xmind文档！

且除此份微服务体系大纲外，我也有整理与其每个专题核心知识点对应的最强学习笔记：

• 出神入化——SpringCloudAlibaba.pdf

• SpringCloud微服务架构笔记（一）.pdf

• SpringCloud微服务架构笔记（二）.pdf

• SpringCloud微服务架构笔记（三）.pdf

• SpringCloud微服务架构笔记（四）.pdf

• Dubbo框架RPC实现原理.pdf

• Dubbo最新全面深度解读.pdf

• Spring Boot学习教程.pdf

• SpringBoo核心宝典.pdf

• 第一本Docker书-完整版.pdf

• 使用SpringCloud和Docker实战微服务.pdf

• K8S(kubernetes)学习指南.pdf

另外，如果不知道从何下手开始学习呢，小编这边也有对每个微服务的核心知识点手绘了其对应的知识架构体系大纲，不过全是导出的xmind文件，全部的源文件也都在此！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
mind文件，全部的源文件也都在此！

[外链图片转存中…(img-4UmYZTwp-1713381540125)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-n121e744-1713381540125)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！