最全《Java并发编程的艺术》读后笔记-part4，细数Java开发者的艰辛历程

最后

看完美团、字节、腾讯这三家的面试问题，是不是感觉问的特别多，可能咱们又得开启面试造火箭、工作拧螺丝的模式去准备下一次的面试了。

开篇有提及我可是足足背下了1000道题目，多少还是有点用的呢，我看了下，上面这些问题大部分都能从我背的题里找到的，所以今天给大家分享一下互联网工程师必备的面试1000题。

注意不论是我说的互联网面试1000题，还是后面提及的算法与数据结构、设计模式以及更多的Java学习笔记等，皆可分享给各位朋友

互联网工程师必备的面试1000题

而且从上面三家来看，算法与数据结构是必备不可少的呀，因此我建议大家可以去刷刷这本左程云大佬著作的《程序员代码面试指南 IT名企算法与数据结构题目最优解》，里面近200道真实出现过的经典代码面试题。

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

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

// 休眠5秒，让sleepThread和busyThread充分运行

TimeUnit.SECONDS.sleep(5);

sleepThread.interrupt();

busyThread.interrupt();

System.out.println("SleepThread interrupted is " + sleepThread.isInterrupted());

System.out.println("BusyThread interrupted is " + busyThread.isInterrupted());

// 防止sleepThread和busyThread立刻退出

SleepUtils.second(2);

}

static class SleepRunner implements Runnable {

@Override

public void run() {

while (true) {

SleepUtils.second(10);

}

}

}

static class BusyRunner implements Runnable {

@Override

public void run() {

while (true) {

}

}

}

}

输出：

SleepThread interrupted is false

BusyThread interrupted is true

从结果可以看出，抛出InterruptedException的线程SleepThread，其中断标识位被清除了，而一直忙碌运作的线程BusyThread，中断标识位没有被清除。

3.线程间的通信

---

3.1volatile和synchronized关键字

volatile：关键字volatile可以用来修饰字段（成员变量），就是告知程序任何对该变量的访问均需要从共享内存中获取，而对它的改变必须同步刷新回共享内存，它能保证所有线程对变量访问的可见性。过多地使用volatile是不必要的，因为它会降低程序执行的效率。

synchronized：关键字synchronized可以修饰方法或者以同步块的形式来进行使用，它主要确保多个线程 在同一个时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可见性 和排他性。

3.2等待/通知机制

一个线程修改了一个对象的值，而另一个线程感知到了变化，然后进行相应的操作，整个过程开始于一个线程，而最终执行又是另一个线程。前者是生产者，后者就是消费者，这种模式隔离了“做什么”（what）和“怎么做”（How），在功能层面上实现了解耦，体系结构上具备了良好的伸缩性，但是在Java语言中如何实现类似的功能呢？

我们先看一个简单的方法，并想一下它的弊端：

while(value != desire){

Thread.sleep(1000);

}

doSomething();

上面这段伪代码在条件不满足时就睡眠一段时间，这样做的目的是防止过快的“无效”尝试，这种方式看似能够解实现所需的功能，但是却存在如下问题：

1. 难以确保及时性。在睡眠时，基本不消耗处理器资源，但是如果睡得过久，就不能及时发现条件已经变化，也就是及时性难以保证。

2. 难以降低开销。如果降低睡眠的时间，比如休眠1毫秒，这样消费者能更加迅速地发现条件变化，但是却可能消耗更多的处理器资源，造成了无端的浪费。

以上两个问题，看似矛盾难以调和，但是Java通过内置的等待/通知机制能够很好地解决这个矛盾并实现所需的功能。

Java中等待/通知相关的方法：

等待/通知机制：是指一个线程A调用了对象O的wait()方法进入等待状态，而另一个线程B调用了对象O的notify()或者notifyAll()方法，线程A收到通知后从对象O的wait()方法返回，进而执行后续操作。上述两个线程通过对象O来完成交互，而对象上的wait()和notify/notifyAll()的 关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。

我们举个栗子，代码如下：

public class demo1Main2 {

static boolean flag = true;

static Object lock = new Object();

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

Thread waitThread = new Thread(new Wait(), “WaitThread”);

waitThread.start();

TimeUnit.SECONDS.sleep(1);

Thread notifyThread = new Thread(new Notify(), “NotifyThread”);

notifyThread.start();

}

static class Wait implements Runnable {

@Override

public void run() {

// 加锁，拥有lock的Monitor

synchronized (lock) {

// 当条件不满足时，继续wait，同时释放了lock的锁

while (flag) {

System.out.println(Thread.currentThread() + " flag is true.wa@ " + new SimpleDateFormat(“HH:mm:ss”).format(new Date()));

try {

lock.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

// 条件满足时，完成工作

System.out.println(Thread.currentThread() + "flag is false. running@ " + new SimpleDateFormat(“HH:mm:ss”).format(new Date()));

}

}

}

static class Notify implements Runnable {

@Override

public void run() {

// 加锁，拥有lock的Monitor

synchronized (lock) {

// 获取lock的锁，然后进行通知，通知时不会释放lock的锁，

// 直到当前线程释放了lock后，WaitThread才能从wait方法中返回

System.out.println(Thread.currentThread() + " hold lock. notify @ " + new SimpleDateFormat(“HH:mm:ss”).format(new Date()));

lock.notifyAll();

flag = false;

try {

TimeUnit.SECONDS.sleep(5);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

// 再次加锁

synchronized (lock) {

System.out.println(Thread.currentThread() + “hold lock again. sleep@” + new SimpleDateFormat(“HH:mm:ss”).format(new Date()));

try {

TimeUnit.SECONDS.sleep(5);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

}

//输出:

Thread[WaitThread,5,main] flag is true.wa@ 16:52:33

Thread[NotifyThread,5,main] hold lock. notify @ 16:52:34

Thread[NotifyThread,5,main]hold lock again. sleep@16:52:39

Thread[WaitThread,5,main]flag is false. running@ 16:52:44

需要注意的细节：

（1）使用wait()、notify()和notifyAll()时需要先对调用对象加锁。

（2）调用wait()方法后，线程状态由RUNNING变为WAITING，并将当前线程放置到对象的等待队列。

（3）notify()或notifyAll()方法调用后，等待线程依旧不会从wait()返回，需要调用notify()或notifAll()的线程释放锁之后，等待线程才有机会从wait()返回。

（4）notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll()方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由WAITING变为BLOCKED。

（5）从wait()方法返回的前提是获得了调用对象的锁。

可以看出：等待/通知机制依托于同步机制，其目的就是确保等待线程从wait()方法返回时能够感知到通知线程对变量做出的修改。。

下图描述了该栗子的过程：

3.3等待/通知的经典范式

从上一节的示例中可以提炼出等待/通知的经典范式。该范式分为等待方（消费者）和通知方（生产者）两部分。

等待方遵循如下原则：

1. 获取对象的锁。

2. 如果条件不满足，那么调用对象的wait()方法，被通知后仍要检查条件。

3. 条件满足则执行对应的逻辑。

对应伪代码：

synchronized(对象){

while(条件不满足){

对象.wait();

}

对应的处理逻辑

}

通知方遵循如下原则：

1. 获得对象的锁。

2. 改变条件。

3. 通知所有等待在对象上的线程。

对应伪代码：

synchronized(对象){

改变条件

对象.notifyAll();

}

3.4管道输入/输出流

管道输入/输出流和普通的文件输入/输出流或者网络输入/输出流不同之处在于，它主要用于线程之间的数据传输，而传输的媒介为内存。

管道输入/输出流主要包括了如下4种具体实现：PipedOutputStream、PipedInputStream、 PipedReader和PipedWriter，前两种面向字节，而后两种面向字符。

public class demo1Main2 {

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

PipedWriter out = new PipedWriter();

PipedReader in = new PipedReader();

// 将输出流和输入流进行连接，否则在使用时会抛出IOException

out.connect(in);

Thread printThread = new Thread(new Print(in), “PrintThread”);

printThread.start();

int receive = 0;

try {

while ((receive = System.in.read()) != -1) {

out.write(receive);

}

} finally {

out.close();

}

}

static class Print implements Runnable {

private PipedReader in;

public Print(PipedReader in) {

this.in = in;

}

public void run() {

int receive = 0;

try {

while ((receive = in.read()) != -1) {

System.out.print((char) receive);

}

} catch (IOException ex) {

}

}

}

}

运行该示例，输入一组字符串，可以看到被printThread进行了原样输出。

xppmzz

xppmzz

对于Piped类型的流，必须先要进行绑定，也就是调用connect()方法，如果没有将输入/输出流绑定起来，对于该流的访问将会抛出异常。

3.5Thread.join()的使用

如果一个线程A执行了thread.join() 语句，其含义是：当前线程A等待thread线程终止之后才从thread.join()返回。

线程Thread除了提供join()方法之外，还提供了join(long millis)和join(long millis,int nanos)两个具备超时特性的方法。这两个超时方法表示，如果线程thread在给定的超时时间里没有终止，那么将会从该超时方法中返回。

我们先看一段代码连接以下它的功能：

public class demo1Main2 {

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

Thread previous = Thread.currentThread();

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

// 每个线程拥有前一个线程的引用，需要等待前一个线程终止，才能从等待中返回

Thread thread = new Thread(new Domin(previous), String.valueOf(i));

thread.start();

previous = thread;

}

TimeUnit.SECONDS.sleep(5);

System.out.println(Thread.currentThread().getName() + " terminate.");

}

static class Domin implements Runnable {

private Thread thread;

public Domin(Thread thread) {

this.thread = thread;

}

@Override

public void run() {

try {

写在最后

还有一份JAVA核心知识点整理（PDF）：JVM，JAVA集合，JAVA多线程并发，JAVA基础，Spring原理，微服务，Netty与RPC，网络，日志，Zookeeper，Kafka，RabbitMQ，Hbase，MongoDB，Cassandra，设计模式，负载均衡，数据库，一致性哈希，JAVA算法，数据结构，加密算法，分布式缓存，Hadoop，Spark，Storm，YARN，机器学习，云计算…

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

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

public Domin(Thread thread) {

this.thread = thread;

}

@Override

public void run() {

try {

写在最后

还有一份JAVA核心知识点整理（PDF）：JVM，JAVA集合，JAVA多线程并发，JAVA基础，Spring原理，微服务，Netty与RPC，网络，日志，Zookeeper，Kafka，RabbitMQ，Hbase，MongoDB，Cassandra，设计模式，负载均衡，数据库，一致性哈希，JAVA算法，数据结构，加密算法，分布式缓存，Hadoop，Spark，Storm，YARN，机器学习，云计算…

[外链图片转存中…(img-yBXkeVEx-1715585697848)]

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

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