《Java并发编程的艺术》1 第一章并发编程的挑战第四章Java并发编程基础

HotRabbit.

已于 2022-08-14 19:56:14 修改

阅读量165

点赞数

分类专栏： # JUC 文章标签： java 开发语言

于 2022-07-12 20:38:21 首次发布

本文链接：https://blog.csdn.net/qq_52476654/article/details/125751329

版权

JUC 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

参考书籍：《Java并发编程的艺术》方腾飞魏鹏程晓明著

并没有按照书籍章序来阅读本篇阅读顺序：1->4

文章目录

一、并发编程的挑战
1.上下文切换
1.1多线程一定快吗
1.2 如何减少上下文切换

二、Java并发编程基础
1.线程简介
1.1 什么是线程
1.2 为什么要使用线程
(1).更多的处理器核心
(2).更快的响应时间
(3).更好的编程模式

1.3 线程优先级
1.4线程的状态
1.5 Daemon线程

2.启动和终止线程
2.1 构建线程
2.2 启动线程
2.3 理解中断
2.4 过期的suspend()、resume()和stop()
2.5 安全地终止进程

3.线程间通信
3.1 volatile和synchronized关键字
3.2 等待/通知机制
3.3 等待/通知的经典范式
3.4 管道输入/输出流
3.5 Thread.join()的使用
3.6 ThreadLocal的使用

4.线程应用实例
4.1 等待超时模式

一、并发编程的挑战

并发编程的目的是让程序运行的更快，但是不是启动更多的线程就能让程序最大限度地并发执行。

1.上下文切换

时间片：CPU分配给各个线程的时间。

CPU通过给每个线程分配CPU时间片来实现多线程执行代码。

上下文切换：

CPU通过时间片分配算法来循环执行任务，当前任务执行一个时间片之后会切换到下一个任务
在切换前会保存上一个任务的状态，以便下次切换到这个任务时，可以再加载这个任务的状态
任务从保存到在加载的过程就是一次上下文切换

例子：阅读一本英语书时，要查字典，暂停阅读，记住页码，去看字典书，再次根据页码看英语书。

1.1多线程一定快吗

从书上的测试样例，可以发现并发执行累加操作不超过百万次时，并发执行与串行执行速度冲差不多，甚至要比串行慢一点。

为什么并发速度要比串行慢呢？这是因为线程有创建和上下文切换的开销。

1.2 如何减少上下文切换

减少上下文切换的方法有：

无锁并发编程：多线程竞争锁时，会引起上下文切换。可以使用一些方法来避免使用锁。如：将数据的ID安装Hash算法取模分段，不同的线程处理不同段的数据。
CAS算法：Java的Atomic包使用CAS算法来更新数据，而不需要加锁。
使用最少线程：避免创建不需要的线程，减少等待的线程。
协程：在单线程里实现多任务的调度，并再单线程里维持多个任务间的切换。

二、Java并发编程基础

1.线程简介

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

在一个进程中可以创建多个线程

1.1 什么是线程

现代操作系统调度的最小单元是线程，也叫轻量级进程（Light Weight Process）
线程有各自的计数器、堆栈和局部变量等属性，并且能够访问共享的内存变量

public class Main {

    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());
        }
    }
}

1.2 为什么要使用线程

(1).更多的处理器核心

一个线程在一个时刻只能运行在一个处理器核心上

试想一下，一个单线程的程序在运行时只能使用一个处理器核心，那么其他加入的处理器核心无法得到使用。

所以我们使用多线程技术，将计算逻辑分配到多个处理器核心，随着更多处理器核心的加入而变得更加有效率。

(2).更快的响应时间

在复杂的业务逻辑处理情况下，多线程技术将数据一致性不强的操作派发给其他线程处理。

比如用户点击订购按钮后，插入订单数据、生成订单快照、发送邮件通知、记录货品数量等业务操作可以分配给多个线程来操作，缩短响应时间。

(3).更好的编程模式

Java为多线程编程提供了良好、考究并且一致的编程模型，使得开发人员能够更加专注于问题的解决。

1.3 线程优先级

现代操作系统会分出一个个时间片，线程会分配到若干时间片，当线程的时间片用完了就会发生线程调度。

线程分配到的时间片的多少也就决定了线程使用处理器资源的多少。

线程优先级：决定线程需要多或少分配一些处理器资源的线程属性。

针对频繁阻塞（休眠或者I/O操作）的线程要设置较高优先级，而偏重计算（需要较多CPU时间或者偏运算）的线程则设置较低的优先级。可以通过setPriority( int ) 来修改优先级

注意：在不同的JVM以及操作系统上，线程规划会存在差异，有些操作系统甚至会忽略对线程优先级的设定。

1.4线程的状态

线程在运行的生命状态中只可能有6种状态，在某一时刻只能处于一种状态。

NEW ：初始状态，线程被构建，还没有调用start（）方法
RUNNABLE ：运行状态，java将操作系统中的就绪和运行两种状态笼统地称作“运行中”
BLOCKED ：阻塞状态，表示线程阻塞于锁
WAITING ：等待状态，进入该状态表示当前线程需要等待其他线程做出一些特定动作（通知或者中断）
TIME_WAITING：超时等待状态，不同于WAITING，它可以在指定的时间自行返回
TERMINATED ：终止状态，当前线程已执行完

线程在创建之后，调用start()方法开始运行
当线程执行Wait()方法后，进入等待状态，进入等待状态的线程需要依靠其他线程的通知才能返回到运行状态
超时等待状态相当于在等待状态上加了时间限制，一旦超过时间线程就会返回到运行状态
当线程调用同步状态，在没有获取到锁的情况下，线程将会进入阻塞状态
线程在执行Runnable的run()方法后会进入终止状态

1.5 Daemon线程

Daemon线程也可以称为守护线程，是一种支持性线程，主要用于程序中的后台调度及支持性工作

比如垃圾回收就算一种守护线程

因为是守护线程，或者说是支持性线程，就意味着这个线程并不属于程序中不可或缺的一部分。所以当所有的非守护线程（即用户线程）结束之后，程序就会结束，JVM退出，同时也就会杀死所有的非守护线程。
设置守护线程的方法是setDeamon(true)方法，此方法应在start()方法前设置。

在构建Deamon线程的时候，不能依靠finally块中的内容来确保执行关闭或清理资源的逻辑

2.启动和终止线程

2.1 构建线程

以当前线程为parent线程来构建了一个child线程，继承了parent的是否为Daemon、优先级（priority）、加载资源的contextClassLoader以及可继承的ThreadLocal，同时还会分配一个唯一的ID来标识这个child线程。

2.2 启动线程

线程对象在初始化完成之后，调用start()方法就可以启动这个线程

线程start()方法：当前线程同步告知Java虚拟机，只要线程规划器空闲，应立即调用start()方法的线程

2.3 理解中断

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

2.4 过期的suspend()、resume()和stop()

线程Thread的API suspend()、resume()和stop() 就相当于音乐播放做出的暂停、恢复和停止操作

public class Main {
    public static void main(String[] args) throws InterruptedException {
        DateFormat format = new SimpleDateFormat("HH:mm:ss");
        Thread printThread = new Thread(new Runner(), "PrintThread");
        printThread.setDaemon(true);
        printThread.start();
        TimeUnit.SECONDS.sleep(3);
        //暂停
        printThread.suspend();
        System.out.println("暂停了在"+format.format(new Date()));
        TimeUnit.SECONDS.sleep(3);

        //恢复
        printThread.resume();
        System.out.println("恢复了在"+format.format(new Date()));
        TimeUnit.SECONDS.sleep(3);

        //终止
        printThread.stop();
        System.out.println("终止了在"+format.format(new Date()));
        TimeUnit.SECONDS.sleep(3);
    }

    static class Runner implements Runnable{

        @Override
        public void run() {
            DateFormat format = new SimpleDateFormat("HH:mm:ss");
            while (true){
                System.out.println(Thread.currentThread().getName() + " Run at " + format.format(new Date()));
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

运行结果：

PrintThread Run at 18:26:14
PrintThread Run at 18:26:15
PrintThread Run at 18:26:16
暂停了在18:26:17
恢复了在18:26:20
PrintThread Run at 18:26:20
PrintThread Run at 18:26:21
PrintThread Run at 18:26:22
终止了在18:26:23

2.5 安全地终止进程

前面提到的中断状态时线程的标识位，而中断操作是一种简便的线程间交互方式，而这种交互方式最适合用来取消或停止任务。

除了中断以外，还可以利用一给boolean变量来控制是否需要停止任务并终止线程。

在下面的程序中，main线程通过中断操作（interrupt()）和cancel()方法均可使线程终止。这种操作方法能够使线程在终止时有机会去清理资源，而不是武断地将线程停止，这种操作更加安全、优雅。

3.线程间通信

3.1 volatile和synchronized关键字

java支持多个线程同时访问一个对象或对象的成员变量，由于每个线程都可以拥有这个变量的拷贝（尽管对象以及成员变量分配的内存是在共享内存中的，但每个执行的线程还是可以拥有一份拷贝，这样做的目的是加速程序的执行），所以在程序运行时，一个线程看到的变量不一定是最新的。

如果多个线程同时拷贝了一个变量，但是其中一个线程修改了变量，那么如何保证其他线程可以对最新的变量进行修改呢？

关键字volatile

关键字volatile可以用来修饰字段（成员变量），告知程序任何对该变量的访问均要从共享内存中获取，而对它的改变必须同步刷新回共享内存，它能保证所有线程对变量访问的可见性。

volatile int n = 0712;

尽管volatile保证了所有线程对变量访问的可见性，但是大量使用volatile会降低程序执行的效率！

关键字synchronized

synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。
关键字synchronized 可以修饰方法或者以同步块的形式来进行使用，它主要确保多个线程在同一个时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可见性和排他性。

任何一个对象都拥有自己的监视器，当这个对象由同步块或者这个对象的同步方法调用时，执行方法的线程必须先获取到该对象的监视器后才能进入同步块或者同步方法，而没有获取到监视器（执行该方法）的线程将会被阻塞在同步块和同步方法的入口处，进入BLOCKED状态。

对象、对象的监视器、同步队列、执行线程之间的关系：

3.2 等待/通知机制

等待/通知的相关方法时任意Java对象都具备的，因为这些方法定义在所有对象的超类java.lang.Object上。

3.3 等待/通知的经典范式

等待方（消费者）和通知方（生产者）

等待方循环如下原则：

获取对象的锁
如果条件不满足，那么调用对象的wait()方法，被通知后仍要检查条件
条件满足则执行相应的逻辑

synchronized(对象) {
    while(条件不满足){
        对象.wait();
    }
    对应的处理逻辑
}

通知方循环如下原则：

获取对象的锁
改变条件
通知所有等待在对象上的线程

synchronized(对象) {
    改变条件
    对象.notigyAll();
}

3.4 管道输入/输出流

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

字节管道输入/输出流：PipedOutputStream/PipedInputStream

字符管道输入/输出流：PipedReader/PipedWriter

public class Main {
    public static void main(String[] args) throws IOException {
        //将输入和输出流连接
        //否则对于流的访问会抛出异常
        PipedReader in = new PipedReader();
        PipedWriter out = new PipedWriter();
        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;
        }

        @Override
        public void run() {
            int receive = 0;
            try {
                while ((receive = in.read()) != -1){
                    System.out.print((char) receive);
                }
            } catch (IOException e){

            }
        }
    }

}

3.5 Thread.join()的使用

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

join(long millis)和join(long millis,int nanos)两个具备超时性质的方法

3.6 ThreadLocal的使用

ThreadLocal（线程变量）：是一个以ThreadLocal对象为键、任意对象为值的存储结构。

这个结构被附带在线程上，一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值。

4.线程应用实例

4.1 等待超时模式

等待超时模式：如果被调用的方法能在给定时间内得到结果，那么立即将结果返回。否则，超时返回默认结果。

等待超时模式其实就是在等待/通知范式基础上加了超时控制

public synchronized Object get(long mills) throws InterruptedException{
    //假设超时时段是 T
    //超时时间：FUTURE = now + T
    long future = System.currentTimeMillis() + mills;
    //等待持续时间: REMAINING = T
    long remaining = mills;
    //当超时大于0并且result返回值不满足要求
    while ((result == null) && remaining > 0){
        wait(remaining);
        remaining = future - System.currentTimeMillis();
    }
    
    return result;
}

HotRabbit.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
《Java并发编程的艺术》1 第一章并发编程的挑战第四章Java并发编程基础

并发编程的目的是让程序运行的更快，但是不是启动更多的线程就能让程序最大限度地并发执行。时间片：CPU分配给各个线程的时间。CPU通过给每个线程分配CPU时间片来实现多线程执行代码。上下文切换：例子：阅读一本英语书时，要查字典，暂停阅读，记住页码，去看字典书，再次根据页码看英语书。从书上的测试样例，可以发现并发执行累加操作不超过百万次时，并发执行与串行执行速度冲差不多，甚至要比串行慢一点。为什么并发速度要比串行慢呢？这是因为线程有创建和上下文切换的开销。减少上下文切换的方法有：进程：现代操作系统在运行一个程序
复制链接

扫一扫