《Java高并发编程详解：多线程与架构设计》笔记（一）_java高并发编程详解多线程与架构设计下载 csdn

本文链接：https://blog.csdn.net/2401_84924979/article/details/138774546

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

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

如果你需要这些资料，可以戳这里获取

线程的查看

1、使用Jconsole或Jstack命令来查看JVM线程。Jconsole是JDK自带的可视化界面，如下图，

Jstack命令查看对应PID（使用命令ps -ef查看进程）,如下图我写了一个死锁的demo，使用jstack 进程号可以看到情况。

线程生命周期

线程NEW状态：当用关键字new创建一个Thread对象时，线程为New状态。

线程RUNNABLE状态：当线程调用start方法进入RUNNABLE状态。RUNNABLE状态只能意外终止或者进入RUNNING状态。

线程RUNNING状态：一旦CPU通过轮询或者其他方式从可执行队列中选中了该线程，该线程才真正地执行自己的逻辑代码，进入RUNNING状态。调用yield方法放弃CPU执行权进入RUNNABLE状态。

线程BLOCKED状态：比如从RUNNING状态调用了sleep或者wait方法加入waitSet中；竞争锁资源而加入到阻塞队列；阻塞的IO操作进入阻塞状态。

线程TERMINATED状态：JDK不推荐使用stop方法或者意外死亡（JVM Crash），一般线程正常结束生命周期。

线程的构造函数

线程的构造函数：如果一个线程没有显式的指定ThreadGroup则它和父线程同属一个ThreadGroup。

栈内存通过xss参数设置，线程的构造函数中stacksize越大表明线程内方法递归调用深度就越深，stacksize越小则代表创建的线程数量越多。

JVM内存结构

程序计数器：存放当前线程接下来要执行的字节码指令、分支、循环、跳转、异常处理等信息。线程私有。
Java虚拟机栈：存放局部变量表、操作栈、动态链接、方法出口等信息。线程私有。
本地方法栈：存放本地方法（JNI方法）。线程私有。
堆内存：运行期的对象，分新生代（Eden区：From Survivor区：To Surivor区= 8:1:1）和老年代。线程共享。
方法区：存储已被JVM加载的类信息、常量、静态变量、即使编译器后的代码等数据。线程共享。
Java8元空间：JDK1.8版本起，元空间取代了持久代内存，可用jstat命令查看JVM的GC内存分布，如下图，持久代被替换为元空间（meta space），元空间同样是堆内存一部分。

堆内存不变，栈内存越大，可创建的线程数量越小。这是由于虚拟机栈内存线程私有，每一个线程都会占有指定的内存大小，Java进程的内存大小=堆内存+线程数*栈内存。

JVM可创建多少个线程与堆内存、栈内存有关，线程数量 = $\frac{MaxProcessMemory - HeapMemory - ReservedOsMemory}{ThreadStackSize(XSS)}$ ，其中MaxProcessMemory是最大地址空间，HeapMemory是JVM堆内存，ReservedOsMemory是系统保留内存（一般136M）。

守护线程

一般用于处理后台工作，如JDK垃圾回收线程。正常情况下，JVM中没有一个非守护线程，则JVM的进程会退出。守护线程具备自动结束声明周期的特性。

设置守护线程只需调用Thread.setDaemon(true)方法即可，它常用作执行一些后台任务，当需要关闭某些线程的时候，或者退出JVM进程的时候，一些线程能够自动关闭，这时采用守护线程。

Thread API

sleep：当前线程进入指定毫秒数休眠，暂停执行，不会放弃monitor锁的所有权。
TimeUnit：sleep方法的封装。
yield：提醒调度器该线程愿意放弃当前CPU资源，如果CPU资源不紧张则会忽略（启发式方式）。调用yield方法会使线程从RUNNING状态切换到RUNNABLE状态。
setPriority：设置线程优先级，同样也是一个hint操作，不会达到预期的效果（除了root用户）。线程优先级默认和父类保持一致，一般都是5。
getId：获取线程唯一ID。
currentThread：返回当前执行线程的引用。
getContextClassLoader：获取线程上下文的类加载器。
interrupt：使当前线程进入阻塞状态。Object类的wait方法，Thread类的sleep方法，Thread类的join方法，InterruptibleChannel的IO操作，Selector的wakeup方法。
isInterrupted：判断当前线程是否被中断。
join：和sleep一样都是可中断的方法。join线程A使线程B进入等待，直到线程A结束生命周期。

线程的关闭

JDK有一个过期（Deprecated）方法stop，早已不推荐使用，保留是为了兼容旧服务。stop方法存在的问题是关闭线程时可能不会释放掉monitor的锁，所以强烈不推荐使用。关闭线程有以下几种方法：

1、线程结束生命周期：线程正常运行结束（生命周期结束）。

2、捕获中断信号关闭线程：线程中循环执行某个任务，如心跳检查。通过检查线程interrupt的标识来决定是否退出。

3、使用volatile开关控制：由于线程的interrupt标识很有可能被擦除，或者逻辑单元不会调用任何可中断方法，使用volatile修饰的开发flag关闭线程是一种常用做法。

public class FlagThreadExit {
    static class MyTask extends Thread{
        private volatile boolean closed = false;
        @Override
        public void run(){
            System.out.println("I will start work");
            while(!closed && !isInterrupted()){
                //working
            }
            System.out.println("I will be exiting.");
        }

        public void close(){
            this.closed = true;
            this.interrupt();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyTask t = new MyTask();
        t.start();
        TimeUnit.MINUTES.sleep(1);
        System.out.println("System will be shutdown.");
        t.close();
    }
}

异常退出

在线程执行单元中，不允许抛checked异常（无论Thread.run方法还是Runnable的run方法），如果需要捕获的话将checked异常封装成unchecked异常（RuntimeException）抛出而结束线程生命周期。

进程假死

假死的绝大部分原因是某个线程阻塞了，或者出现死锁的情况。使用jstack、jconsole、jvisualvm工具诊断。

线程安全与数据同步

多个线程同时对同一份资源进行访问（读写操作）时，保证多个线程访问到的数据一致，出现不一致的原因是由于线程的执行是由CPU时间片轮询调度的。

通过synchronized关键字可以防止线程干扰和内存一致性错误，synchronized关键字的具体表现如下：

synchronzed关键字提供了锁的机制，能确保共享变量的互斥访问。
synchroinzed关键字包含monitor enter和monitor exit两个JVM指令，它能保证在任何时候任何线程执行到monitor enter成功之前都必须从主内存中获取数据，而不是从缓存中，在monitor exit成功之后，共享变量被更新后的值必须刷入主内存。
synchronized指令严格遵守happends-before规则，一个monitor exit指令之前必须要有一个monitor enter。

举个简单栗子，创建5个线程，每个线程持有锁1分钟，如下，

package com.hust.zhang.threadSafe;

import java.util.concurrent.TimeUnit;

public class Mutex {
    private final static Object MUTEX = new Object();

    public void accessResource() {
        synchronized (MUTEX) {
            try {
                TimeUnit.MINUTES.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        final Mutex mutex = new Mutex();
        for (int i = 0; i < 5; i++) {
            new Thread(mutex::accessResource).start();
        }
    }
}

Jconsole中可以看到当前持有锁的线程为Thread-0，且线程状态为TIMED_WAITING状态。

使用JDK命令javap对编译后的class文件进行反汇编可以看到monitor enter和monitor exit成对出现，且满足happen-before原则。每个对象都有一个监视器锁（monitor），被占用就会处于锁定状态，若已占有该monitor，重新进入（monitor enter），则进入数+1。

使用synchronized需要注意的几个地方：

monitor关联的对象不能为空。比如上面定义的MUTEX对象为空。
synchronized作用域太大，synchronized一般用于代码块或方法。由于synchronized关键字存在排他性，所有线程必须串行地经过synchronized保护的共享区域，如果作用域越大，其效率就越低。
不同monitor企图锁相同的方法。
多个锁的交叉导致死锁。
同一个实例对象中的不同方法都加上synchronized关键字时，争抢的时同一个monitor的lock。

死锁原因

交叉锁：线程A持有R1的锁等待R2的锁，线程B持有R2的锁等待R1的锁。
内存不足：两个线程都在等待彼此能够释放内存资源。
一问一答式数据交换：客户端和服务器端都在等待双方发送数据。
数据库锁：无论表锁、行锁，某个线程执行for update语句退出事务，其他线程访问该数据库都会陷入死锁。
文件锁：某线程获得文件锁意外退出，其他线程进入死锁直到系统释放文件句柄（Handle）资源。
死循环：死循环造成的死锁一般成为系统假死。

线程间通信

同步阻塞和异步阻塞

同步阻塞消息处理缺点：客户端等待时间过长会陷入阻塞；吞吐量不高；频繁创建开启与销毁；业务高峰系统性能低。

异步非阻塞消息处理：优势明显，但也存在缺陷，如客户端再次调用接口方法仍然需要进行查询（可通过异步回调接口解决）。

单线程间通信

服务器端与客户端通过事件队列进行通信的case比较好的方式就是使用通知机制：创建一个事件队列，有事件则通知工作线程开始工作，没有则工作线程休息并等待通知。下面就是这样的case。

事件队列：

package com.hust.zhang.conn;

import java.util.LinkedList;

import static java.lang.Thread.currentThread;

public class EventQueue {

    private int max;

    public EventQueue(int num) {
        this.max = num;
    }

    public EventQueue() {
        this(DEFAULT_MAX_EVENT);
    }

    //object类是所有类的父类
    static class Event {
    }

    private final LinkedList<Event> eventQueue = new LinkedList<>();
    private final static int DEFAULT_MAX_EVENT = 10;

    public void offer(Event event) {
        synchronized (eventQueue) {
            //当共享资源eventQueue队列达到上限，调用eventQueue的wait方法使当前线程进入wait set中并释放monitor的锁
            if (eventQueue.size() >= max) {
                try {
                    console("the queue is full.");
                    /**
                     * wait方法：
                     * 1、可中断，一旦调用wait方法进入阻塞状态，其他线程是可以使用interrupt方法将其打断。
                     * 2、执行某个对象的wait方法后，加入与之对应的wait set中，每一个对象的monitor都有一个与之关联的wait set。
                     * 3、必须在同步方法中使用wait和notify，因为执行wait和notify前提条件是必须持有同步方法的monitor所有权。否则会出现IllegalMonitorStateException。
                     * */
                    eventQueue.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            console("the event is submitted");
            eventQueue.addLast(event);
            eventQueue.notify();
        }
    }

    public Event take() {
        synchronized (eventQueue) {
            if (eventQueue.isEmpty()) {
                try {
                    console("the queue is empty");
                    //eventQueue是Event类的集合，调用的是父类Object的wait方法
                    eventQueue.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            Event event = eventQueue.removeFirst();
            //notify唤醒在此对象监视器monitor上等待的单个线程
            this.eventQueue.notify();
            console("the event " + event + " is handled.");
            return event;
        }
    }

    private void console(String message) {
        System.out.printf("%s:%s\n", currentThread().getName(), message);
    }

}

模拟服务者和消费者的两个线程：

package com.hust.zhang.conn;

import java.util.concurrent.TimeUnit;

public class EventClient {
    public static void main(String[] args) {
        final EventQueue eventQueue = new EventQueue();
        new Thread(() -> {
            for (; ; ) {
                eventQueue.offer(new EventQueue.Event());
            }
        }, "Producer").start();

        new Thread(() -> {
            for (; ; ) {
                eventQueue.take();
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Consumer").start();
    }
}

多线程通信

上面的case中Producer很快提交了10个Event数据，此时队列已满，然后执行eventQueue的wait方法进入阻塞状态，Consumer线程由于要处理数据，花费1秒处理其中的一条数据，然后通知Producer线程可以继续提交数据了，如此循环。

但是上面的case如果有多个线程同时take或offer上面的程序就会出现数据不一致的问题，当eventQueue元素为空时，两个线程执行take方法分别调用wait方法进入阻塞，另一个offer线程执行addLast方法后唤醒了其中一个阻塞的线程，该线程顺利消费了一个元素之后恰巧再次唤醒了一个take线程，这时导致执行空LinkedList的removeFirst方法。所以再在上面做了一定的优化，判断eventQuque队列满或空变成了轮询队列条件（if -> while），唤醒在此对象监视器monitor等待的单个线程变成唤醒在此对象监视器monitor等待的所有线程（notify -> notifyAll）。这样改进可以防止多个线程同时take或offer造成的线程安全问题。

自定义显式锁BooleanLock

synchronized提供的是一种排他式的数据同步机制，某个线程在获取monitor lock的时候可能会被阻塞，而这种阻塞有两个很明显的缺陷：

无法控制阻塞时长。
阻塞不可被中断。

下面是一个缺陷分析的case。

package com.hust.zhang.synchronizedAnalysis;

import java.util.concurrent.TimeUnit;

public class SynchronizedDefect {
    public synchronized void syncMethod() {
        try {
            //阻塞时间长无法控制
            TimeUnit.HOURS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizedDefect defect = new SynchronizedDefect();
        Thread t1 = new Thread(defect::syncMethod, "T1");
        //make sure the t1 start
        t1.start();
        TimeUnit.MICROSECONDS.sleep(2);

        //T2因争抢monitor的锁而进入阻塞状态，无法中断
        Thread t2 = new Thread(defect::syncMethod, "T2");
        t2.start();

        //虽然可以设置中断标识，但是无法被中断
        TimeUnit.MICROSECONDS.sleep(2);
        t2.interrupt();
        System.out.println("t2.isInterrupt: " + t2.isInterrupted());    //true
        System.out.println("t1.state: " + t1.getState());               //TIMED_WAITING
        System.out.println("t2.state: " + t2.getState());               //BLOCKED
    }
}

上面的case可以看到线程t2因为争抢monitor的锁而进入阻塞状态，对其调用interrupt方法只会设置中断标识，线程一直处于阻塞状态无法被中断。但如果是休眠中的线程（Thread.sleep），调用interrupt方法会中断该线程并抛出InterruptException异常。

所以这里采用自定义显式锁BooleanLock，demo如下，

锁接口：

package com.hust.zhang.synchronizedAnalysis;

import java.util.List;
import java.util.concurrent.TimeoutException;

public interface Lock {
    //永远阻塞，除非获取到了锁，方法可以被中断
    void lock() throws InterruptedException;

    //增加超时功能
    void lock(long mills) throws InterruptedException, TimeoutException;

    //锁的释放
    void unlock();

    //获取当前哪些线程被阻塞
    List<Thread> getBlockedThreads();
}

自定义显式锁实现类：

package com.hust.zhang.synchronizedAnalysis;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.TimeoutException;

import static java.lang.System.currentTimeMillis;
import static java.lang.Thread.currentThread;

public class BooleanLock implements Lock {
    //当前拥有锁的线程
    private Thread currentThread;
    //boolean开关，true代表该锁被某个线程获得，false代表当前锁没有被哪个线程获得或者已经释放
    private boolean locked = false;
    //存储哪些线程在获取当前线程时进入阻塞状态
    private final List<Thread> blockedList = new ArrayList<>();

    @Override
    public void lock() throws InterruptedException {
        //同步代码块
        synchronized (this) {
            //当前锁被某线程获得，则该线程加入阻塞队列，并使当前线程wait释放对this monitor的所有权
            while (locked) {
                blockedList.add(currentThread());
                this.wait();
            }
            //如果当前线程没有被其他线程获得，则该线程会从阻塞队列中删除自己（如未进入阻塞队列删除也不会有影响）
            blockedList.remove(currentThread());
            //locked开关设为true
            this.locked = true;
            //记录获取锁的线程
            this.currentThread = currentThread();
        }
    }

    @Override
    public void lock(long mills) throws InterruptedException, TimeoutException {
        //同步代码块
        synchronized (this) {
            //如果mills不合法，则默认调用lock方法，抛出异常也是一个比较好的做法
            if (mills <= 0) {
                this.lock();
            } else {
                long remainingMills = mills;
                long endMills = currentTimeMillis() + remainingMills;
                while (locked) {
                    //如果remainingMills<=0，则表示当前线程被其他线程唤醒或者在指定的wait时间到之后还没有获得锁
                    if (remainingMills <= 0) throw new TimeoutException("can not get the lock during " + mills);
                    if (!blockedList.contains(currentThread)) blockedList.add(currentThread());
                    //等待remainingMills的毫秒数，该值最开始由其他线程传入，但多次wait过程中会重新计算
                    this.wait(remainingMills);
                    //重新计算remainingMills
                    remainingMills = endMills - currentTimeMillis();
                }
                //获得该锁，并且从block队列中删除当前线程，将locked的状态设置为true，并且指定获得锁的线程就是当前线程
                blockedList.remove(currentThread());
                this.locked = true;
                this.currentThread = currentThread();
            }
        }
    }

    @Override
    public void unlock() {
        synchronized (this) {
            //判断当前线程是否为获取锁的那个线程，只有加了锁的线程才有资格进行解锁
            if (currentThread == currentThread()) {
                this.locked = false;
                //Optional类是一个可以为null的容器对象。ifPresent方法可以接受接口段或lambda表达式
                Optional.of(currentThread().getName() + "release the lock.").ifPresent(System.out::println);
                //通知其他在wait set中的线程，大家可以尝试抢锁了
                this.notifyAll();
            }
        }
    }

    @Override
    public List<Thread> getBlockedThreads() {
        //重构收发Encapsulate Collection（封装集群）将参数中的List返回一个不可修改的List
        return Collections.unmodifiableList(blockedList);
    }
}

测试类：

package com.hust.zhang.synchronizedAnalysis;

import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;

import static java.lang.Thread.currentThread;
import static java.util.concurrent.ThreadLocalRandom.current;

public class BooleanLockTest {
    private final Lock lock = new BooleanLock();

    public void synMethod() throws InterruptedException {
        lock.lock();
        try {
            int randomInt = current().nextInt(10);
            System.out.println(currentThread() + "get the lock.");
            TimeUnit.SECONDS.sleep(randomInt);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }


![img](https://img-blog.csdnimg.cn/img_convert/dfff3b93c577b21fcf9dc11d6c4380a2.png)
![img](https://img-blog.csdnimg.cn/img_convert/891e35c6a369ea3fb9316ad7f3d568f1.png)
![img](https://img-blog.csdnimg.cn/img_convert/d666060cc3ff631b2d27964c0f8f448a.png)

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

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

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618658159)**

        System.out.println(currentThread() + "get the lock.");
            TimeUnit.SECONDS.sleep(randomInt);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }


[外链图片转存中...(img-ReihqW2E-1715533457841)]
[外链图片转存中...(img-rVySIe1q-1715533457841)]
[外链图片转存中...(img-ZIKHaRl1-1715533457842)]

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

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

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618658159)**