打通JAVA与内核，一个ReentrantLock锁的实现原理。，java面试算法题

2401_84411849

于 2024-04-21 22:13:22 发布

阅读量725

点赞数 21

分类专栏： 2024年程序员学习文章标签： java 面试算法

本文链接：https://blog.csdn.net/2401_84411849/article/details/138047477

版权

2024年程序员学习专栏收录该内容

50 篇文章 0 订阅

订阅专栏

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

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

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

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

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

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

正文

如果不成功，则将线程的设置成_thread_in_vm并且_thread_blocked。_thread_in_vm表示线程当前在JVM中执行，_thread_blocked表示线程状态当前模式了。
mutex之后，再次检查_counter是不是>0，如果是，则把_counter设置为0，解锁mutex并返回
如果_counter还是不大于0，则判断等待的时间等于0，然后调用相应的pthread_cond_wait系列函数进行等待，如果等待返回（即有人进行unpark，则pthread_cond_signal来通知），则把_counter设置为0，解锁互斥并返回。

所以上本质原因，LockSupport.park是通过pthread库的条件pthread_cond_t来实现的。下面我们就来看看pthread_cond_t是怎么实现的。

三 GLIBC 层

=========

pthread_cond_t 典型的用法如下：

#include <pthread.h>

#include <stdio.h>

#include <stdlib.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; /初始化互斥锁/

pthread_cond_t cond = PTHREAD_COND_INITIALIZER; //初始化条件变量

void *thread1(void *);

void *thread2(void *);

int i=1;

int main(void)

{

pthread_t t_a;

pthread_t t_b;

pthread_create(&t_a,NULL,thread1,(void *)NULL);/创建进程t_a/

pthread_create(&t_b,NULL,thread2,(void *)NULL); /创建进程t_b/

pthread_join(t_b, NULL);/等待进程t_b结束/

pthread_mutex_destroy(&mutex);

pthread_cond_destroy(&cond);

exit(0);

}

void *thread1(void *junk)

{

for(i=1;i<=9;i++)

{

pthread_mutex_lock(&mutex);//

if(i%3==0)

pthread_cond_signal(&cond);/条件改变，发送信号，通知t_b进程/

else

printf(“thead1:%d/n”,i);

pthread_mutex_unlock(&mutex);//解锁互斥量/

printf(“Up Unlock Mutex/n”);

sleep(1);

}

void *thread2(void *junk)

{

while(i<9)

{

pthread_mutex_lock(&mutex);

if(i%3!=0)

pthread_cond_wait(&cond,&mutex);/等待/

printf(“thread2:%d/n”,i);

pthread_mutex_unlock(&mutex);

printf(“Down Ulock Mutex/n”);

sleep(1);

}

重点就是：无论是

pthread_cond_waitpthread_cond_signal都必须得先pthread_mutex_lock。如果没有这个保护，可能会产生竞态条件，漏掉信号。pthread_cond_wait()函数一进入wait状态会自动释放互斥锁。当其他线程通过pthread_cond_signal或pthread_cond_broadcast 使该线程启动，使 pthread_cond_wait()返回时，该线程又自动获得该互斥锁。

整个过程如下图所示：

打通JAVA与内核！一个ReentrantLock锁的实现原理

1 pthread_mutex_lock

======================

例如，在Linux中，使用了一个Futex（快速用户空间互斥锁的部分）的。

在此系统中，对用户空间中的互斥启动原子和测试操作。

如果操作结果证明锁上没有争用，则对pthread_mutex_lock的调用将返回，而无需可以通信到内核中，因此获得互斥量的操作非常快。

仅当检测到争用时，系统调用（以后futex）才会发生，并且上下文切换到内核中，使这调用进程进入睡眠状态，直到解除互锁直到。

还有很多更多的细节，尤其是可以相信和/或优先级继承反对，但这只是它的本质。

nptl/pthread_mutex_lock.c

int

PTHREAD_MUTEX_LOCK (pthread_mutex_t *mutex)

{

/* See concurrency notes regarding mutex type which is loaded from __kind

in struct __pthread_mutex_s in sysdeps/nptl/bits/thread-shared-types.h. */

unsigned int type = PTHREAD_MUTEX_TYPE_ELISION (mutex);

LIBC_PROBE (mutex_entry, 1, mutex);

if (__builtin_expect (type & ~(PTHREAD_MUTEX_KIND_MASK_NP

| PTHREAD_MUTEX_ELISION_FLAGS_NP), 0))

return __pthread_mutex_lock_full (mutex);

if (__glibc_likely (type == PTHREAD_MUTEX_TIMED_NP))

{

FORCE_ELISION (mutex, goto elision);

simple:

/* Normal mutex. */

LLL_MUTEX_LOCK_OPTIMIZED (mutex);

assert (mutex->__data.__owner == 0);

}

#if ENABLE_ELISION_SUPPORT

else if (__glibc_likely (type == PTHREAD_MUTEX_TIMED_ELISION_NP))

{

elision: attribute((unused))

/* This case can never happen on a system without elision,

as the mutex type initialization functions will not

allow to set the elision flags. */

/* Don’t record owner or users for elision case. This is a

tail call. */

return LLL_MUTEX_LOCK_ELISION (mutex);

}

#endif

else if (__builtin_expect (PTHREAD_MUTEX_TYPE (mutex)

== PTHREAD_MUTEX_RECURSIVE_NP, 1))

{

/* Recursive mutex. */

pid_t id = THREAD_GETMEM (THREAD_SELF, tid);

/* Check whether we already hold the mutex. */

if (mutex->__data.__owner == id)

{

/* Just bump the counter. */

if (__glibc_unlikely (mutex->__data.__count + 1 == 0))

/* Overflow of the counter. */

return EAGAIN;

++mutex->__data.__count;

return 0;

}

/* We have to get the mutex. */

LLL_MUTEX_LOCK_OPTIMIZED (mutex);

assert (mutex->__data.__owner == 0);

mutex->__data.__count = 1;

}

else if (__builtin_expect (PTHREAD_MUTEX_TYPE (mutex)

== PTHREAD_MUTEX_ADAPTIVE_NP, 1))

{

if (LLL_MUTEX_TRYLOCK (mutex) != 0)

{

int cnt = 0;

int max_cnt = MIN (max_adaptive_count (),

mutex->__data.__spins * 2 + 10);

{

if (cnt++ >= max_cnt)

{

LLL_MUTEX_LOCK (mutex);

break;

}

atomic_spin_nop ();

}

while (LLL_MUTEX_TRYLOCK (mutex) != 0);

mutex->__data.__spins += (cnt - mutex->__data.__spins) / 8;

}

assert (mutex->__data.__owner == 0);

}

else

{

pid_t id = THREAD_GETMEM (THREAD_SELF, tid);

assert (PTHREAD_MUTEX_TYPE (mutex) == PTHREAD_MUTEX_ERRORCHECK_NP);

/* Check whether we already hold the mutex. */

if (__glibc_unlikely (mutex->__data.__owner == id))

return EDEADLK;

goto simple;

}

pid_t id = THREAD_GETMEM (THREAD_SELF, tid);

/* Record the ownership. */

mutex->__data.__owner = id;

#ifndef NO_INCR

++mutex->__data.__nusers;

#endif

LIBC_PROBE (mutex_acquired, 1, mutex);

return 0;

}

pthread_mutex_t 的定义如下：

typedef union

{

struct __pthread_mutex_s

{

int __lock;

unsigned int __count;

int __owner;

unsigned int __nusers;

int __kind;

int __spins;

__pthread_list_t __list;

} __data;

…

} pthread_mutex_t;

__一种类型是指锁的类型，取值如下：

/* Mutex types. */

enum

{

PTHREAD_MUTEX_TIMED_NP,

PTHREAD_MUTEX_RECURSIVE_NP,

PTHREAD_MUTEX_ERRORCHECK_NP,

PTHREAD_MUTEX_ADAPTIVE_NP

#if defined __USE_UNIX98 || defined __USE_XOPEN2K8

PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,

PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,

PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,

PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL

#endif

#ifdef __USE_GNU

/* For compatibility. */

, PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP

#endif

};

其中：

PTHREAD_MU_TIMED_NP，这是一种值，也就是普通锁。
PTHREAD_MUTEX_RECURSIVE_NP允许可重入锁，一个线程对同一个锁成功获得多次，并通过多次解锁重启。
PTHREAD_MUTEX_ERRORCHECK_NP，检错锁，如果同一个线程重复请求同一个锁，则返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型相同。
PTHREAD_MUTEX_ADAPTIVE_NP，惯锁，自旋锁与普通锁的混合。

互斥体默认使用的是 PTHREAD_MUTEX_TIMED_NP，所以会走 LLL_MUTEX_LOCK_OPTIMIZED，这是个宏：

define LLL_MUTEX_LOCK_OPTIMIZED(mutex) lll_mutex_lock_optimized (mutex)

lll_mutex_lock_optimized (pthread_mutex_t *mutex)

{

/* The single-threaded optimization is only valid for private

mutexes. For process-shared mutexes, the mutex could be in a

shared mapping, so synchronization with another process is needed

even without any threads. If the lock is already marked as

acquired, POSIX requires that pthread_mutex_lock deadlocks for

normal mutexes, so skip the optimization in that case as

well. */

int private = PTHREAD_MUTEX_PSHARED (mutex);

if (private == LLL_PRIVATE && SINGLE_THREAD_P && mutex->__data.__lock == 0)

mutex->__data.__lock = 1;

else

lll_lock (mutex->__data.__lock, private);

}

因为不是LLL_PRIVATE，所以走lll_lock，lll_lock也是个宏：

#define lll_lock(futex, private) \

__lll_lock (&(futex), private)

注意这里出现了文字，本文的重点主要是围绕它展开的。

#define __lll_lock(futex, private) \

((void) \

({ \

int *__futex = (futex); \

if (__glibc_unlikely \

(atomic_compare_and_exchange_bool_acq (__futex, 1, 0))) \

{ \

if (__builtin_constant_p (private) && (private) == LLL_PRIVATE) \

__lll_lock_wait_private (__futex); \

else \

__lll_lock_wait (__futex, private); \

} \

}))

其中，

atomic_compare_and_exchange_bool_acq是实验如下通过原子操作实验将__futex（mutex->__data.__lock）从0变为1，如果成功就直接返回了，如果失败，则调用__lll_lock_wait，代码：

void

__lll_lock_wait (int *futex, int private)

{

if (atomic_load_relaxed (futex) == 2)

goto futex;

while (atomic_exchange_acquire (futex, 2) != 0)

{

futex:

LIBC_PROBE (lll_lock_wait, 1, futex);

futex_wait ((unsigned int ) futex, 2, private); / Wait if *futex == 2. */

}

在这里先要说明一下，pthread将futex的锁状态定义为3种：

0，代表当前锁开启无锁，可以进行快速上锁，无需进门。
1，代表有线程抓住当前锁，如果有线程线程需要上锁，就必须标记futex为“锁竞争”，然后通过futex系统调用进内核把当前线程挂起。
2，更换锁竞争，有其他线程将要或正在内核的futex系统中等待锁定。

上锁失败进入到__lll_lock_wait后，先判断futex是不是等于2，那么说明大家都在这里所以如果你也排着吧（直接跳转到futex_wait）。如果不等于2，那说明你是第一个来设置自己的人，把futex 2，告诉对方来的人要结婚，然后以身作则先结婚。

futex_wait 就是调用futex系统调用在第四节，我们就来仔细分析这个系统。

2 pthread_cond_wait

=====================

本质也是需要futex系统调用，只有篇幅不展开了。

四面层

===

什么时候加入内核的？

简单简单，futex 的解决思路是：在无战斗的情况下操作完全在用户空间进行，无需系统调用，仅在发生或者发生的时候就进入昏迷去完成相应的处理（等待醒来）。所以说，futex是一种用户模式和内核模式混合的同步机制，需要两种模式合作才能完成，futex创建位于用户空间，而不是代码内核对象，futex的也分为用户模式和内核模式两部分，无竞争的情况下在用户模式，发生竞争时则通过sys_futex系统调用进入内核模式进行处理。

已经在前面演示用户了，本节重点讲解futex在内核部分的实现。

futex 设计了三个基本数据结构：futex_hash_bucket，futex_key，futex_q。

struct futex_hash_bucket {

atomic_t waiters;

spinlock_t lock;

struct plist_head chain;

} ____cacheline_aligned_in_smp;

struct futex_q {

struct plist_node list;

struct task_struct *task;

spinlock_t *lock_ptr;

union futex_key key; //唯一标识uaddr的key值

struct futex_pi_state *pi_state;

struct rt_mutex_waiter *rt_waiter;

union futex_key *requeue_pi_key;

u32 bitset;

};

union futex_key {

struct {

unsigned long pgoff;

struct inode *inode;

int offset;

} shared;

struct {

unsigned long address;

struct mm_struct *mm;

int offset;

} private;

struct {

unsigned long word;

void *ptr;

int offset;

} both;

};

其实还有个struct __futex_data，如下所示，这个

static struct {

struct futex_hash_bucket *queues;

unsigned long hashsize;

} __futex_data __read_mostly __aligned(2*sizeof(long));

#define futex_queues (__futex_data.queues)

#define futex_hashsize (__futex_data.hashsize)

在futex初始化的时候（futex_init），会确定hashsize，比如24核cpu时，hashsize = 8192。然后根据这个hashsize调用alloc_large_system_hash分配数组空间，并初始化数组元素里的相关属性，比如plist_head，lock。

static int __init futex_init(void)

{

unsigned int futex_shift;

unsigned long i;

#if CONFIG_BASE_SMALL

futex_hashsize = 16;

#else

futex_hashsize = roundup_pow_of_two(256 * num_possible_cpus());

#endif

futex_queues = alloc_large_system_hash(“futex”, sizeof(*futex_queues),

futex_hashsize, 0,

futex_hashsize < 256 ? HASH_SMALL : 0,

&futex_shift, NULL,

futex_hashsize, futex_hashsize);

futex_hashsize = 1UL << futex_shift;

futex_detect_cmpxchg();

for (i = 0; i < futex_hashsize; i++) {

atomic_set(&futex_queues[i].waiters, 0);

plist_head_init(&futex_queues[i].chain);

spin_lock_init(&futex_queues[i].lock);

}

return 0;

}

这些数据结构之间的关系如下所示：

打通JAVA与内核！一个ReentrantLock锁的实现原理

脑子里有了数据结构，流程就容易理解了。futex_wait的总体流程如下：

打通JAVA与内核！一个ReentrantLock锁的实现原理

static int futex_wait(u32 __user *uaddr, unsigned int flags, u32 val,

ktime_t *abs_time, u32 bitset)

{

struct hrtimer_sleeper timeout, *to = NULL;

struct restart_block *restart;

struct futex_hash_bucket *hb;

struct futex_q q = futex_q_init;

int ret;

if (!bitset)

return -EINVAL;

q.bitset = bitset;

if (abs_time) {

to = &timeout;

hrtimer_init_on_stack(&to->timer, (flags & FLAGS_CLOCKRT) ?

CLOCK_REALTIME : CLOCK_MONOTONIC,

HRTIMER_MODE_ABS);

hrtimer_init_sleeper(to, current);

hrtimer_set_expires_range_ns(&to->timer, *abs_time,

current->timer_slack_ns);

}

retry:

Prepare to wait on uaddr. On success, holds hb lock and increments
q.key refs.

ret = futex_wait_setup(uaddr, val, flags, &q, &hb);

if (ret)

goto out;

/* queue_me and wait for wakeup, timeout, or a signal. */

futex_wait_queue_me(hb, &q, to);

/* If we were woken (and unqueued), we succeeded, whatever. */

ret = 0;

/* unqueue_me() drops q.key ref */

if (!unqueue_me(&q))

goto out;

ret = -ETIMEDOUT;

if (to && !to->task)

goto out;

We expect signal_pending(current), but we might be the
victim of a spurious wakeup as well.

if (!signal_pending(current))

goto retry;

ret = -ERESTARTSYS;

if (!abs_time)

goto out;

restart = ¤t->restart_block;

restart->fn = futex_wait_restart;

restart->futex.uaddr = uaddr;

restart->futex.val = val;

restart->futex.time = *abs_time;

restart->futex.bitset = bitset;

restart->futex.flags = flags | FLAGS_HAS_TIMEOUT;

ret = -ERESTART_RESTARTBLOCK;

out:

if (to) {

hrtimer_cancel(&to->timer);

destroy_hrtimer_on_stack(&to->timer);

}

return ret;

}

函数futex_wait_setup主要做两件事，一是对uaddr进行hash，找到futex_hash_bucket并获取它上面的自旋锁，二是判断*uaddr是否为预期值。如果没有被录取立即返回，由用户状态继续trylock。

futex_wait_setup() - Prepare to wait on a futex
@uaddr: the futex userspace address
@val: the expected value
@flags: futex flags (FLAGS_SHARED, etc.)
@q: the associated futex_q
@hb: storage for hash_bucket pointer to be returned to caller

Setup the futex_q and locate the hash_bucket. Get the futex value and
compare it with the expected value. Handle atomic faults internally.
Return with the hb lock held and a q.key reference on success, and unlocked
with no q.key reference on failure.

Return:
- 0 - uaddr contains val and hb has been locked;
- <1 - -EFAULT or -EWOULDBLOCK (uaddr does not contain val) and hb is unlocked

static int futex_wait_setup(u32 __user *uaddr, u32 val, unsigned int flags,

struct futex_q *q, struct futex_hash_bucket **hb)

{

u32 uval;

int ret;

retry:

//初始化futex_q，把uaddr设置到futex_key的字段中，将来futex_wake时也是通过这个key来查找futex。

ret = get_futex_key(uaddr, flags & FLAGS_SHARED, &q->key, VERIFY_READ);

if (unlikely(ret != 0))

return ret;

retry_private:

//根据key计算hash，然后在数组里找到对应的futex_hash_bucket

*hb = queue_lock(q);

//原子地将uaddr的值读到uval中

ret = get_futex_value_locked(&uval, uaddr);

if (ret) {

queue_unlock(*hb);

ret = get_user(uval, uaddr);

if (ret)

goto out;

if (!(flags & FLAGS_SHARED))

goto retry_private;

put_futex_key(&q->key);

goto retry;

}

//如果当前uaddr指向的值不等于val，即说明其他进程修改了

//uaddr指向的值，等待条件不再成立，不用阻塞直接返回。

if (uval != val) {

queue_unlock(*hb);

ret = -EWOULDBLOCK;

}

out:

if (ret)

put_futex_key(&q->key);

return ret;

}

然后调用futex_wait_queue_me 把当前进程挂起：

/**

futex_wait_queue_me() - queue_me() and wait for wakeup, timeout, or signal
@hb: the futex hash bucket, must be locked by the caller
@q: the futex_q to queue up on
@timeout: the prepared hrtimer_sleeper, or null for no timeout

static void futex_wait_queue_me(struct futex_hash_bucket *hb, struct futex_q *q,

struct hrtimer_sleeper *timeout)

{

The task state is guaranteed to be set before another task can
wake it. set_current_state() is implemented using smp_store_mb() and
queue_me() calls spin_unlock() upon completion, both serializing
access to the hash list and forcing another memory barrier.

set_current_state(TASK_INTERRUPTIBLE);

queue_me(q, hb);

/* Arm the timer */

if (timeout)

hrtimer_start_expires(&timeout->timer, HRTIMER_MODE_ABS);

If we have been removed from the hash list, then another task
has tried to wake us, and we can skip the call to schedule().

if (likely(!plist_node_empty(&q->list))) {

If the timer has already expired, current will already be

最后

小编在这里分享些我自己平时的学习资料，由于篇幅限制，pdf文档的详解资料太全面，细节内容实在太多啦，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！

程序员代码面试指南 IT名企算法与数据结构题目最优解

这是” 本程序员面试宝典!书中对IT名企代码面试各类题目的最优解进行了总结，并提供了相关代码实现。针对当前程序员面试缺乏权威题目汇总这一-痛点，本书选取将近200道真实出现过的经典代码面试题，帮助广“大程序员的面试准备做到万无一失。 “刷”完本书后，你就是“题王”!

《TCP-IP协议组(第4版)》

本书是介绍TCP/IP协议族的经典图书的最新版本。本书自第1版出版以来，就广受读者欢迎。

本书最新版进行」护元，以体境计算机网络技不的最新发展，全书古有七大部分共30草和7个附录:第一部分介绍一些基本概念和基础底层技术:第二部分介绍网络层协议:第三部分介绍运输层协议;第四部分介绍应用层协议:第五部分介绍下一代协议，即IPv6协议:第六部分介绍网络安全问题:第七部分给出了7个附录。

Java开发手册（嵩山版）

这个不用多说了，阿里的开发手册，每次更新我都会看，这是8月初最新更新的**（嵩山版）**

MySQL 8从入门到精通

本书主要内容包括MySQL的安装与配置、数据库的创建、数据表的创建、数据类型和运算符、MySQL 函数、查询数据、数据表的操作(插入、更新与删除数据)、索引、存储过程和函数、视图、触发器、用户管理、数据备份与还原、MySQL 日志、性能优化、MySQL Repl ication、MySQL Workbench、 MySQL Utilities、 MySQL Proxy、PHP操作MySQL数据库和PDO数据库抽象类库等。最后通过3个综合案例的数据库设计，进步讲述 MySQL在实际工作中的应用。

Spring5高级编程（第5版）

本书涵盖Spring 5的所有内容，如果想要充分利用这一领先的企业级 Java应用程序开发框架的强大功能，本书是最全面的Spring参考和实用指南。

本书第5版涵盖核心的Spring及其与其他领先的Java技术(比如Hibemate JPA 2.Tls、Thymeleaf和WebSocket)的集成。本书的重点是介绍如何使用Java配置类、lambda 表达式、Spring Boot以及反应式编程。同时，将与企业级应用程序开发人员分享一些见解和实际经验，包括远程处理、事务、Web 和表示层，等等。

JAVA核心知识点+1000道互联网Java工程师面试题

企业IT架构转型之道阿里巴巴中台战略思想与架构实战

本书讲述了阿里巴巴的技术发展史，同时也是-部互联网技术架构的实践与发展史。

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

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

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

b);

/* Arm the timer */

if (timeout)

hrtimer_start_expires(&timeout->timer, HRTIMER_MODE_ABS);

If we have been removed from the hash list, then another task
has tried to wake us, and we can skip the call to schedule().

if (likely(!plist_node_empty(&q->list))) {

If the timer has already expired, current will already be

最后

程序员代码面试指南 IT名企算法与数据结构题目最优解

[外链图片转存中…(img-hIYww5NO-1713708790397)]

《TCP-IP协议组(第4版)》

本书是介绍TCP/IP协议族的经典图书的最新版本。本书自第1版出版以来，就广受读者欢迎。

[外链图片转存中…(img-4Y2JgVSS-1713708790398)]

Java开发手册（嵩山版）

这个不用多说了，阿里的开发手册，每次更新我都会看，这是8月初最新更新的**（嵩山版）**

[外链图片转存中…(img-BMesaAsc-1713708790399)]

MySQL 8从入门到精通

[外链图片转存中…(img-tEyS7lDi-1713708790399)]

Spring5高级编程（第5版）

本书涵盖Spring 5的所有内容，如果想要充分利用这一领先的企业级 Java应用程序开发框架的强大功能，本书是最全面的Spring参考和实用指南。

[外链图片转存中…(img-Ca84CTp5-1713708790400)]

JAVA核心知识点+1000道互联网Java工程师面试题

[外链图片转存中…(img-BXlSkuyo-1713708790400)]

[外链图片转存中…(img-L2QvGcEN-1713708790401)]

企业IT架构转型之道阿里巴巴中台战略思想与架构实战

本书讲述了阿里巴巴的技术发展史，同时也是-部互联网技术架构的实践与发展史。

[外链图片转存中…(img-R2IdZOeg-1713708790401)]

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

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

2401_84411849

关注

21
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
打通JAVA与内核，一个ReentrantLock锁的实现原理。，java面试算法题

小编在这里分享些我自己平时的学习资料，由于篇幅限制，pdf文档的详解资料太全面，细节内容实在太多啦，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！程序员代码面试指南 IT名企算法与数据结构题目最优解这是” 本程序员面试宝典!书中对IT名企代码面试各类题目的最优解进行了总结，并提供了相关代码实现。针对当前程序员面试缺乏权威题目汇总这一-痛点，本书选取将近200道真实出现过的经典代码面试题，帮助广“大程序员的面试准备做到万无一失。“刷”完本书后，你就是“题王”!
复制链接

扫一扫