《Java并发编程的艺术》读后笔记-part4

于 2024-06-18 04:08:54 发布
阅读量680 收藏 15
点赞数 23
文章标签： java 笔记 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_85767200/article/details/139758733
版权

文章目录

  • 《Java并发编程的艺术》读后笔记-part4

  • 第四章 Java并发编程基础

    • 1.线程简介
    • 1.1什么是线程？

  • 1.2为什么要使用多线程？

  • 1.3线程优先级

  • 1.4线程的状态

  • 1.5Daemon线程

  • 2.启动和终止线程

    • 2.1构造线程

  • 2.2启动线程

  • 2.3理解中断

  • 3.线程间的通信

    • [3.1volatile和synchronized关键字](about:blank#31volatile
      synchronized_170)

  • 3.2等待/通知机制

  • 3.3等待/通知的经典范式

  • 3.4管道输入/输出流

  • 3.5Thread.join()的使用

  • 3.6ThreadLocal的使用

《Java并发编程的艺术》读后笔记-part4

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

第四章 Java并发编程基础

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

1.线程简介

1.1什么是线程？

现代操作系统在运行一个程序时，会为其创建一个进程。

现代操作系统调度的最小单元是线程，也叫轻量级进程。

在一个进程里可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，并且能够访问共享的内存变量。处理器在这些线程上高速切换，让使用者感觉到这些线程在同时执行。

一个Java程序从main()方法开始执行，然后按照既定的代码逻辑执行，看似没有其他线程参与，但实际上Java程序天生就是多线程程序，因为执行main()方法的是一个名称为main的线程。

下面我们使用JMX来查看一个普通的Java程序包包含哪些线程？

public class demo1Main1 {

public static void main(String[] args) {

//获取Java线程管理MXBean

ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();

//不需要获取同步的monitor和synchronizer信息，仅获取线程和线程堆栈信息

ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);

// 遍历线程信息，仅打印线程ID和线程名称信息

for (ThreadInfo threadInfo : threadInfos) {

System.out.println(“[” + threadInfo.getThreadId() + “]” + threadInfo.getThreadName());

}

}

}

输出如下：

在这里插入图片描述

结论：可以看到，一个Java程序的运行不仅仅是main()方法的运行，而是main线程和多个其他线程的同时运行。

1.2为什么要使用多线程？

正确使用多线程，会给我们这些开发人员带来一些显著的好处。

使用多线程的原因主要有以下几点：

  1. 更多的处理核心

线程是大多数操作系统调度的基本单元，一个程序作为一个进程来运行，程序运行过程中能够创建多个线程，而一个线程在一个时刻只能运行在一个处理器核心上。

一个单线程程序在运行时只能使用一个处理器核心，那么再多的处理器核心加入也无法显著提升该程序的执行效率。相反，如果该程序使用多线程技术，将计算逻辑分配到多个处理器核心上，就会显著减少程序的处理时间，并且随着更多处理器核心的加入而变得更有效率。

  1. 更快的响应时间

有时我们会编写一些较为复杂的代码（这里的复杂不是说复杂的算法，而是复杂的业务逻辑），例如，一笔订单的创建，它包括插入订单数据、生成订单快照、发送邮件通知卖家和记录货品销售数量等。用户从单击“订购”按钮开始，就要等待这些操作全部完成才能看到订购成功的结果。但是这么多业务操作，如何能够让其更快地完成呢？

在上面的场景中，可以使用多线程技术，即将数据一致性不强的操作派发给其他线程处理（也可以使用消息队列），如生成订单快照、发送邮件等。这样做的好处是响应用户请求的线程能够尽可能快地处理完成，缩短了响应时间，提升了用户体验

  1. 更好的编程模型

Java为多线程编程提供了良好、考究并且一致的编程模型，使开发人员能够更加专注于问题的解决，即为所遇到的问题建立合适的模型，而不是绞尽脑汁地考虑如何将其多线程化。一旦开发人员建立好了模型，稍做修改总是能够方便地映射到Java提供的多线程编程模型上。

1.3线程优先级

在Java线程中，通过一个整型成员变量priority来控制优先级，优先级的范围从1~10，在线程构建的时候可以通过setPriority(int)方法来修改优先级，默认优先级是5，优先级高的线程分配时间片的数量要多于优先级低的线程。

设置线程优先级时，针对频繁阻塞（休眠或者I/O操作）的线程需要设置较高优先级，而偏重计算（需要较多CPU时间或者偏运算）的线程则设置较低的优先级，确保处理器不会被独占。

注意：线程优先级不能作为程序正确性的依赖，因为操作系统可以完全不用理会Java线程对于优先级的设定。

1.4线程的状态

Java线程在运行的生命周期中可能处于6种状态，在给定的一个时刻，线程宅男处于其中一个状态，如图：

在这里插入图片描述

Java线程状态变迁图：

在这里插入图片描述

注意：Java将操作系统中的运行和就绪两个状态合并称为运行状态。

1.5Daemon线程

Daemon线程是一种支持型线程，因为它主要被用作程序中后台调度以及支持性工作。这意味着，当一个Java虚拟机中不存在非Daemon线程的时候，Java虚拟机将会退出。可以通过调用Thread.setDaemon(true)将线程设置为Daemon线程。

注意1：Daemon属性需要在启动线程之前设置，不能在启动线程之后设置。

注意2：在构建Daemon线程时，不能依靠finally块中的内容来确保执行关闭或清理资源的逻辑。

2.启动和终止线程

2.1构造线程

在运行线程之前首先要构造一个线程对象，线程对象在构造的时候需要提供线程所需要的属性，如线程所属的线程组、线程优先级、是否是Daemon线程等信息。

2.2启动线程

线程对象在初始化完成之后，调用start() 方法就可以启动这个线程。线程start()方法的含义是：当前线程（即parent线程）同步告知Java虚拟机，只要线程规划器空闲，应立即启动调用 start()方法的线程。

注意：启动一个线程前，最好为这个线程设置线程名称。

因为这样在使用jstack分析程序或者进行问题排查时，就会给开发人员提供一些提示，自定义的线程最好能够起个名字。

2.3理解中断

中断可以理解为线程的一个标识位属性，它表示一个运行中的线程是否被其他线程进行了中断操作。中断好比其他线程对该线程打了个招呼，其他线程通过调用该线程的interrupt()方法对其进行中断操作。

线程通过检查自身是否被中断来进行响应，线程通过方法isInterrupted()来进行判断是否被中断，也可以调用静态方法Thread.interrupted()对当前线程的中断标识位进行复位。如果该线程已经处于终结状态，即使该线程被中断过，在调用该线程对象的isInterrupted()时依旧会返回false。

从Java的API中可以看到，许多声明抛出InterruptedException的方法（例如Thread.sleep(long millis)方法）这些方法在抛出InterruptedException之前，Java虚拟机会先将该线程的中断标识位清除，然后抛出InterruptedException，此时调用isInterrupted()方法将会返回false。

我们先看一段代码来了解：

public class demo1Main2 {

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

// sleepThread不停的尝试睡眠

Thread sleepThread = new Thread(new SleepRunner(), “SleepThread”);

sleepThread.setDaemon(true);

// busyThread不停的运行

Thread busyThread = new Thread(new BusyRunner(), “BusyThread”);

busyThread.setDaemon(true);

sleepThread.start();

busyThread.start();

// 休眠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 {

thread.join();

} catch (InterruptedException e) {

}

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

}

}

}

可以看出：每个线程终止的前提是前驱线程的终止，每个线程等待前驱线程终止后，才从join()方法返回，这里涉及了等待/通知机制（等待前驱线程结束，接收前驱线程结束通知）。

3.6ThreadLocal的使用

ThreadLocal，即线程变量，是一个以ThreadLocal对象为键、任意对象为值的存储结构。这个结构被附带在线程上，也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值。

可以通过set(T)方法来设置一个值，在当前线程下再通过get()方法获取到原先设置的值。

代码演示如下：

public class demo1Main2 {

public static final ThreadLocal TIME_THREADLOCAL = new ThreadLocal() {

protected Long initialValue() {

return System.currentTimeMillis();

}

};

public static final void begin() {

TIME_THREADLOCAL.set(System.currentTimeMillis());

}

public static final long end() {

return System.currentTimeMillis() - TIME_THREADLOCAL.get();

}

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

demo1Main2.begin();

TimeUnit.SECONDS.sleep(1);

System.out.println(“Cost: " + demo1Main2.end() + " mills”);
}
}

2401_85767200
关注
  • 23
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值