既有适合小白学习的零基础资料,也有适合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可创建多少个线程与堆内存、栈内存有关,线程数量 = ,其中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)**