学习Java并发编程之前你不得不知道的那点事，java面试感觉啥也不会怎么办

2401_84447417

已于 2024-04-21 19:46:46 修改

阅读量516

点赞数 30

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

于 2024-04-21 19:46:44 首次发布

本文链接：https://blog.csdn.net/2401_84447417/article/details/138043177

版权

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

18 篇文章 0 订阅

订阅专栏

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

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

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

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

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

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

正文

无锁并发编程。多线程竞争锁时，会引起上下文切换，所以多线程处理数据时，可以用一些办法来避免使用锁，如将数据的id按照Hash算法取模分段，不同的线程处理不同段的数据。
CAS算法。Java的Atomic包使用CAS算法来更新数据，而不需要加锁。
使用最少线程。避免创建不需要的线程，比如任务很少，但是创建了很多线程来处理，这样会造成大量线程处于等待状态。
协程。在单线程里实现多任务调度，并在单线程里维持多个任务见的切换。

1.4 减少上下文切换实战

这个例子简单说明如何来减少线程池中大量WAITING线程，来减少上下文切换次数。（本文在Windows环境dump测试）

写一个模拟出现WAITING状态的代码：

package com.lizba.p1;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

/**

 线程池Dump测试 -- 代码只是示例

@Author: Liziba
@Date: 2021/6/4 23:26

public class ThreadPoolDumpTest {

public static void main(String[] args) {

// 创建固定大小的线程池

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(300);

// 初始化线程池中的线程

for (int i = 0; i < 300; i++) {

fixedThreadPool.execute(getThread(i));

}

while (true) {

try {

Thread.sleep(5000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(“测试！”);

}

/**

创建线程
@param i
@return

private static Runnable getThread(final int i) {

return new Runnable() {

public void run() {

try {

Thread.sleep(50);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(i);

}

};

}

用jstack命令dump线程信息，可以看当前运行的Java程序的pid，查看当前进程号里的线程在做什么。

查看Java进程

jps

结果：

1216

12176 RemoteMavenServer36

18052 ThreadPoolDumpTest

18084 Launcher

15800 Jps

统计所有线程分别处于什么状态，找出处于(onobjectmonitor)阻塞状态的线程。

dump下快照

jstack -l 18052 > d:\dump.txt

打开dump文件查看处于(onobjectmonitor)阻塞的线程在做什么。

发现有300个线程处于WAITING状态

“pool-1-thread-300” #311 prio=5 os_prio=0 tid=0x000000002fe46800 nid=0x4880 waiting on condition [0x0000000033cfe000]

java.lang.Thread.State: WAITING (parking)

at sun.misc.Unsafe.park(Native Method)

parking to wait for <0x000000077b098178> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)

at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)

at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2039)

at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:442)

at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1074)

at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1134)

at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)

at java.lang.Thread.run(Thread.java:748)

Locked ownable synchronizers:

None

此时如果发现是我们在程序中定义的线程池中的线程，则我们应该适当考虑降低线程池的maxThreads的值。

此处示例中我们修改线程池的固定大小为10:

// 创建固定大小的线程池

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);

修改maxThread值之后我们可以重启项目。再次dump线程信息，然后重新统计(onobjectmonitor)阻塞的线程数。

再次dump快照分析线程运行情况，发现只有10个线程处于WAITING状态了：

“pool-1-thread-10” #21 prio=5 os_prio=0 tid=0x000000001ecde000 nid=0x312c waiting on condition [0x00000000212ef000]

java.lang.Thread.State: WAITING (parking)

在上面的简单案例中WAITING线程减少了，系统上下文切换的次数就会减少，因为每一次从WAITING到RUNNABLE都会进行一次上下文的切换。在实际开发中，我们并不会做这么看似低级的操作，但是样例却能给我们代理线程池优化和程序线程优化各方面的解决问题的思路。

二、死锁

锁是一个非常有用的工具，运用的场景非常多，因为它使用起来非常简单，而且易于理解。但同时它会带来一些困扰，那就是可能会引起死锁，一旦产生死锁，就会造成系统功能不可用。

2.1 死锁示例

下面演示一段引起死锁的代码，使得线程t1和线程t2互相等待对方释放锁。

package com.lizba.p1;

/**

```
 死锁示例代码
```
@Author: Liziba
@Date: 2021/6/5 0:37

public class DeadLockDemo {

private static final String A = “A”;

private static final String B = “B”;

/**

t1\t2互相持有锁

private void deadLock() {

Thread t1 = new Thread(new Runnable() {

public void run() {

// 持有锁A

synchronized (A) {

try {

Thread.currentThread().sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

// 持有锁B

synchronized (B) {

System.out.println(“hold Lock B”);

}

});

Thread t2 = new Thread(new Runnable() {

public void run() {

// 持有锁B

synchronized (B) {

try {

Thread.currentThread().sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

// 持有锁A

synchronized (A) {

System.out.println(“hold Lock A”);

}

});

t1.start();

t2.start();

}

public static void main(String[] args) {

new DeadLockDemo().deadLock();

}

这段代码演示的是简单的死锁场景，在现实中大家都不会写出这样的代码。但是，在一些更为复杂的场景中，你可能会遇到这样的问题，比如t1拿到锁之后，因为一些异常情况并没有释放锁（比如死循环）。又或者t1拿到一个数据库锁，释放锁的时候抛出了异常，没有释放掉。

现实中，一旦出现了死锁，业务是可感知的，因为不能继续提供服务了，那么只能通过dump线程查看到底是哪个线程出现了问题，我们分析如下Dump出的线程信息：

“Thread-1” #13 prio=5 os_prio=0 tid=0x000000001e011000 nid=0x5318 waiting for monitor entry [0x000000001fcef000]

java.lang.Thread.State: BLOCKED (on object monitor)

at com.lizba.p1.DeadLockDemo$2.run(DeadLockDemo.java:50)

waiting to lock <0x000000076b042000> (a java.lang.String)
locked <0x000000076b042030> (a java.lang.String)

at java.lang.Thread.run(Thread.java:748)

Locked ownable synchronizers:

None

“Thread-0” #12 prio=5 os_prio=0 tid=0x000000001e00f800 nid=0x4b38 waiting for monitor entry [0x000000001fbef000]

java.lang.Thread.State: BLOCKED (on object monitor)

at com.lizba.p1.DeadLockDemo$1.run(DeadLockDemo.java:33)

waiting to lock <0x000000076b042030> (a java.lang.String)
locked <0x000000076b042000> (a java.lang.String)

at java.lang.Thread.run(Thread.java:748)

Locked ownable synchronizers:

None

从上可以看出第33行和第50行引发了死锁。

2.2 避免产生死锁

避免一个线程同时获取多个锁。
避免一个线程在锁内同时占用多个资源，尽量保证每个锁只占用一个资源。
尝试使用定时锁，使用lock.tryLock(timeout)来替代使用内部锁机制。
对于数据库锁，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败的情况。

学习分享，共勉

这里是小编拿到的学习资源，其中包括“中高级Java开发面试高频考点题笔记300道.pdf”和“Java核心知识体系笔记.pdf”文件分享，内容丰富，囊括了JVM、锁、并发、Java反射、Spring原理、微服务、Zookeeper、数据库、数据结构等大量知识点。同时还有Java进阶学习的知识笔记脑图（内含大量学习笔记）！