最新【Java之多线程】JUC常见知识点全面总结，阿里java面试题库

最后

按照上面的过程，4个月的时间刚刚好。当然Java的体系是很庞大的，还有很多更高级的技能需要掌握，但不要着急，这些完全可以放到以后工作中边用别学。

学习编程就是一个由混沌到有序的过程，所以你在学习过程中，如果一时碰到理解不了的知识点，大可不必沮丧，更不要气馁，这都是正常的不能再正常的事情了，不过是“人同此心，心同此理”的暂时而已。

“道路是曲折的，前途是光明的！”

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

public class Test {

static class Counter{

public int count=0;

public void increase(){

count++;

}

}

public static void main(String[] args) {

Counter counter=new Counter();

Thread t1 = new Thread() {

@Override

public void run() {

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

counter.increase();

}

}

};

Thread t2 = new Thread() {

@Override

public void run() {

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

counter.increase();

}

}

};

t1.start();

t2.start();

try {

t1.join();

t2.join();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(counter.count);

}

}

经过之前的学习，我们认为此方法打印count是线程不安全的，不会每次都很准确地打印10000：

第一次运行

第二次运行

之前我们学过的解决方法是使用synchronized保证线程的安全性，代码如下：

static class Counter{

public int count=0;

synchronized public void increase(){

count++;

}

}

改动部分如上图所示（其他部分一样），打印结果如下：

但此时我们可以通过创建ReentrantLock这一对象对其实现加锁，完整代码如下：

import java.util.concurrent.locks.ReentrantLock;

public class Test {

static class Counter {

public int count;

public ReentrantLock locker = new ReentrantLock();

public void increase() {

locker.lock();

count++;

locker.unlock();

}

}

public static void main(String[] args) {

Counter counter=new Counter();

Thread t1 = new Thread() {

@Override

public void run() {

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

counter.increase();

}

}

};

Thread t2 = new Thread() {

@Override

public void run() {

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

counter.increase();

}

}

};

t1.start();

t2.start();

try {

t1.join();

t2.join();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(counter.count);

}

}

打印结果如下：

3. 与synchronized区别

---

那么，与synchronized同样都能对其实现加锁功能，这两者有什么区别呢？

1. ReentrantLock把加锁和解锁拆成了两个方法，确实存在遗忘解锁的风险，但可以让代码变得更加灵活，可以把加锁和解锁的代码分别放到两个方法之中

2. synchronized在申请锁失败时，代码会死等。而ReentrantLock 可以通过trylock这个方法等待一段时间就放弃，不会浪费时间

3. synchronized是非公平锁，而ReentrantLock默认是非公平锁。但可以通过构造方法传入一个 true 开启公平锁模式

4. ReentrantLock 有更强大的唤醒机制，synchronized 是通过 Object 的 wait / notify 方法实现等待唤醒过程的，每次唤醒的是一个随机等待的线程。而ReentrantLock搭配 Condition 类实现等待-唤醒，可以更精确控制唤醒某个指定的线程。

4. 总结

---

1. 大部分情况下使用 synchronized就足够了

2. 锁竞争激烈的时候，使用ReentrantLock , 搭配 trylock 方法可以更灵活地控制加锁的行为，而不是死等。

3. 如果需要使用公平锁, 使用 ReentrantLock

二. 原子类

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

1. 理解

---

保证线程安全不一定非得加锁，当然也可以用原子类，从java1.5开始，jdk提供了java.util.concurrent.atomic包，这个包内包含一系列的原子操作类，提供了一种用法简单，性能高效，线程安全的更新一个变量的方式。其内部通常以CAS方式实现，因此性能通常比加锁实现i++要高很多，具体使用方法如下（上述例子）

public AtomicInteger count = new AtomicInteger(0);

public void increase() {

count.getAndIncrement();

}

这里只展示改动后的代码，其打印结果如下：

2. 常见的原子类

---

1. AtomicBoolean

2. AtomicInteger

3. AtomicIntegerArray

4. AtomicLong

5. AtomicReference

6. AtomicStampedReference

3. 常见的方法

---

以 AtomicInteger 举例，常见方法有

1. addAndGet(int delta); 相当于 i += delta;

2. decrementAndGet(); 相当于–i;

3. getAndDecrement(); 相当于i–;

4. incrementAndGet(); 相当于++i;

5. getAndIncrement(); 相当于i++;

三. 线程池

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

1. 为什么要引入线程池

---

解决并发编程的方案一般是靠多进程的，但是进程开销的资源是非常大的，因此我们进一步地引入了多线程。虽然创建销毁线程比创建销毁进程看起来似乎更轻量了，但是在频繁创建毁线程的时还是会比较低效。线程池就是为了解决这个问题。如果某个线程不再使用了，并不是真正把线程释放，而是放到一个 "池子"中。当我们需要使用多线程的时候，直接从之前创建好的池子中取出一个就行了，当我们不用的时候，直接把这个线程放回池子中即可。

2. 引入线程池的好处

---

1. 当我们不用线程池的时候，频繁地创建或者销毁线程涉及到用户态和内核态的来回切换，从用户态切换到内核态会创建出对应的PCB（进程控制块，英文是Processing Control Block），这样会消耗大量的系统资源，而且效率还会比较低。

2. 当我们引入线程池后，相当于只在用户态完成各种操作，这样代码执行效率和系统开销会大大优化

3. 创建线程池的方法

---

（1）ThreadPoolExecutor

使用Java标准库中的ThreadPoolExecutor方式创建，但需注意里面各自的参数代表的含义，使用起来相对而言比较复杂。

构造方法

为了更好地理解每个参数的具体含义，大家可以利用空闲时间去jdk的官方文档学习学习，对自己是非常有帮助的：

（2） Executors

使用 Executors 这个类创建，这个类相当于一个工厂类，通过这个工厂类中的一些方法，就可以创建出不同风格的线程池实例了。

部分方法

1. Executors.newFixedThreadPool：创建一个固定大小的线程池

2. Executors.newCachedThreadPool：创建一个可缓存的线程池，若线程数超过处理所需，缓存一段时间后会回收，若线程数不够，则新建线程。

3. Executors.newSingleThreadExecutor：创建出只包含一个线程数的线程池，它可以保证先进先出的执行顺序。

4. Executors.newScheduledThreadPool：创建一个可以执行延迟任务的线程池（放入的任务能够过一会再执行）

5. Executors.newSingleThreadScheduledExecutor：创建出具有一个单线程并且可以执行延迟任务的线程池

用法示例：

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class Test {

public static void main(String[] args) {

ExecutorService service = Executors.newFixedThreadPool(10);

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

service.submit(new Runnable() {

@Override

public void run() {

System.out.println(“hello”);

}

});

}

}

}

运行结果：

四. 信号量Semaphore

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

1. 定义

---

信号量Semaphore一般用来表示可用资源的个数，相当于一个计数器，可类比生活中停车场牌子上面显示的停车场剩余车位数量。

1. 当有车开进去的时候, 就相当于申请一个可用资源，可用车位就 -1 (这个称为信号量的 P 操作)

2. 当有车开出来的时候, 就相当于释放一个可用资源, 可用车位就 +1 (这个称为信号量的 V 操作)

3. 如果计数器的值已经为 0 了，还尝试申请资源，就会阻塞等待，直到有其他线程释放资源（计数器的值是大于等于0的）

2. 作用

---

1. 在创建信号量的时候，可以给定一个初始值（可用资源个数），当可用资源个数用完时，就会阻塞等待，以确保线程安全

2. 若把信号量的初始值设成1，则计数器的值只能取0或1了，此时把这个信号量称为二元信号量，和锁的功能类似，有加锁（没法申请资源）和解锁状态（可以申请资源）

3. 用法示例

---

最后

关于面试刷题也是有方法可言的，建议最好是按照专题来进行，然后由基础到高级，由浅入深来，效果会更好。当然，这些内容我也全部整理在一份pdf文档内，分成了以下几大专题：

• Java基础部分

• 算法与编程

• 数据库部分

• 流行的框架与新技术（Spring+SpringCloud+SpringCloudAlibaba）

这份面试文档当然不止这些内容，实际上像JVM、设计模式、ZK、MQ、数据结构等其他部分的面试内容均有涉及，因为文章篇幅，就不全部在这里阐述了。

作为一名程序员，阶段性的学习是必不可少的，而且需要保持一定的持续性，这次在这个阶段内，我对一些重点的知识点进行了系统的复习，一方面巩固了自己的基础，另一方面也提升了自己的知识广度和深度。

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

619)]

• 数据库部分

[外链图片转存中…(img-VdMjh68v-1715653883619)]

• 流行的框架与新技术（Spring+SpringCloud+SpringCloudAlibaba）

[外链图片转存中…(img-yYccqrlt-1715653883619)]

这份面试文档当然不止这些内容，实际上像JVM、设计模式、ZK、MQ、数据结构等其他部分的面试内容均有涉及，因为文章篇幅，就不全部在这里阐述了。

作为一名程序员，阶段性的学习是必不可少的，而且需要保持一定的持续性，这次在这个阶段内，我对一些重点的知识点进行了系统的复习，一方面巩固了自己的基础，另一方面也提升了自己的知识广度和深度。

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取