Java多线程(基础、线程安全、线程间通信)

李_杰

已于 2022-03-29 09:50:19 修改

阅读量197

点赞数

分类专栏： Java # 多线程文章标签：后端 java

于 2022-02-25 22:30:58 首次发布

本文链接：https://blog.csdn.net/li_jie9309/article/details/123132492

版权

Java 同时被 2 个专栏收录

15 篇文章 0 订阅

订阅专栏

多线程

8 篇文章 0 订阅

订阅专栏

一、基础

1、多线程的优势和问题

1. 优势

• 利用多个cpu核⼼
• 编码简单(相对于需要编写切换cpu任务的代码)

2. 问题

• 理解上有成本
• 线程切换开销
• 线程安全问题
• 资源互斥访问
• 活跃性问题：死锁

2、线程基础

1. 启动方式

常用的2个Thread构造方法
new Thread(new Runnable())
new Thread(new Runnable(), “thread-name”)
启动方法是start()，而不是run()

2. Thread核⼼方法

currentThread：指获取当前线程对象
sleep：暂停当前线程一段时间，把cpu片段让给其他线程，减缓当前线程的执行。但不释放锁
interrupt：用于中断指定线程。指定线程的状态将被置为中断状态
interrupted：用于当前线程，判断当前线程是否被中断了，调用后会清除该线程的中断状态。
isInterrupted：用于指定线程，判断该线程是否被中断了，调用后不会清除该线程的中断状态。
join：让父线程等待子线程结束之后才能继续运行。

3. 扩展：sleep()和wait()的区别

sleep是Thread的静态方法、wait是Object的实例方法
sleep是占用着cpu阻塞，wait是不占用cpu阻塞。
sleep仅仅释放CPU资源或者让当前线程停止执行一段时间，但不会释放锁；wait用于线程间通信，如果等待条件为真且其它线程被唤醒时它会释放锁。
sleep在休眠时间到达后如果再次获的CPU时间片就会继续执行；wait必须等待Object.notify()或Object.notifyAll()通知后，才会离开等待池，并且再次获的CPU时间片才会继续执行

4. 线程状态

在这里插入图片描述
创建状态：当用 new 操作符创建一个线程的时候
就绪状态：调用 start 方法，处于就绪状态的线程并不一定马上就会执行 run 方法，还需要等待CPU的调度
运行状态：CPU 开始调度线程，并开始执行 run 方法
阻塞状态：线程的执行过程中由于一些原因进入阻塞状态比如：调用 sleep 方法、尝试去得到一个锁等等
死亡状态：run 方法执行完或者执行过程中遇到了一个异常

二、线程安全

1. 死锁

1、产生死锁的条件

互斥条件：进程要求对所分配的资源进行排它性控制，即在一段时间内某资源仅为一进程所占用。
请求和保持条件：当进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。
环路等待条件：在发生死锁时，必然存在一个进程–资源的环形链。

2、死锁demo

public class TestDeadLock {
    private static String a = "A";
    private static String b = "B";

    public static void deadLock () {
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (a){
                    System.out.println("threadA get a");
                    synchronized (b){
                        System.out.println("threadA get b");
                    }
                }
            }
        });
        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (b){
                    System.out.println("threadB get b");
                    synchronized (a){
                        System.out.println("threadB get a");
                    }
                }
            }
        });
        threadA.start();
        threadB.start();
    }
    public static void main(String[] args) {
        deadLock();
    }
}

3、怎么查看死锁？

Linux下：ps -ef | grep java 或者 jps -l 查看Java进程的pid
Windows下： jps -l 查看Java进程的pid
然后jstack pid：查看线程情况
在这里插入图片描述

2、Java内置锁 synchronized

1、synchronized依赖于底层的操作系统的Mutex Lock来实现的， JDK1.6之后做了较大的优化-锁升级机制。

原子性：指一个操作或者多个操作，要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。
持有同一个锁的两个同步代码块，只能串行进入。
可见性：当一个线程对共享变量进行了修改，那么另外的线程都是立即可以看到修改后的最新值。
如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值。
对一个变量执行unlock操作之前，必须先把此变量同步回写到主内存中（执行store和write操作）。
可重入性：一个线程可以重复获取自身已经获取的锁，避免死锁

2、锁的内存语义

当线程释放锁时， JMM会把该线程对应的本地内存中的共享变量刷新到主内存中
当线程获取锁时， JMM会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区
代码必须从主内存中读取共享变量

3、锁释放和锁获取的内存语义

线程A释放一个锁，实质上是线程A向接下来将要获取这个锁的某个线程发出了（线程A对共享变量所做修改的）消息。
线程B获取一个锁，实质上是线程B接收了之前某个线程发出的（在释放这个锁之前对共享变量所做修改的）消息。
线程A释放锁，随后线程B获取这个锁，这个过程实质上是线程A通过主内存向线程B发送消息

4、synchronized用法

修饰代码块
修饰实例方法
修饰静态方法

本质上能锁的资源就两类：对象、类

5、扩展

javap -c -s -v -l xxx.class 可以查看对应的字节码指令

同步代码块：由monitorenter指令进入，然后monitorexit释放锁
同步方法：通过ACC_SYNCHRONIZED标识

本质都是对对象监视器 monitor 的获取。

3、Java显示锁 JUC-Lock

JUC包，代码写的都非常精妙
核⼼类AQS（ AbstractQueuedSynchronizer ）
Lock是一个接口提供了无条件的、可轮询的、定时的、可中断的锁获取操作，所有加锁和解锁的方法都是显式的
包路径是： java.util.concurrent.locks.Lock
核⼼方法是lock()， unlock()， tryLock()
实现类有ReentrantLock、 ReentrantReadWriteLock、 ReadLock、
WriteLock

1、锁的公平性

1、公平锁/非公平锁的含义

公平锁：一个线程组里，能保证每个线程都能拿到锁。
非公平锁：一个线程组里，存在线程拿不到锁的情况。
在这里插入图片描述

2、如何能保证每个线程都能拿到锁？

2.1、队列FIFO

• 是一个完美的解决方案，也就是先进先出， ReentrantLock也就是用队列实现的公平锁和非公平锁。
• 公平锁中，如果有另一个线程持有锁或者有其他线程在等待队列中等待这个锁，那么新发出的请求的线程将被放入到队列中。
• 非公平锁中，只有当锁被某个线程持有时，新发出请求的线程才会被放入队列中（此时和公平锁是一样的）。所以，它们的差别在于非公平锁会有更多的机会去抢锁。

2.2、 CLH同步队列

• AQS 核⼼思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制是用 CLH 队列变种实现的，即将暂时获取不到锁的线程加入到队列中。
• CLH同步队列（ Craig、 Landin 和 Hagersten三位大佬的发明）一种基于虚拟队列、无饥饿性的自旋公平锁。 AQS会将当前线程已经等待状态的信息构造成一个节点（Node）并将其加入到CLH同步队列，同时会阻塞当前线程，当同步状态释放时，会把首节点唤醒（公平锁），使其再次尝试获取同步状态

4、Lock和synchronized的区别

都是可重入锁（Java未提供不可重入锁，因为不可重入锁会造成死锁问题）
synchronized依赖JVM， lock依赖JDK的API
synchronized是非公平锁， lock可以实现公平锁
lock等待可中断
lock可以绑定多个条件，选择性通知

三、线程间同步

1、volatile

适用于一写多读的场景
volatile存在的背景
互斥的悲观锁是较重的操作
有些场景下，仅单个线程去更新值，其他线程读取值
数据互斥访问的诉求不强
典型的场景
java自带的原子类Atomic类
高流量的接口限流值的获取及更新
volatile作用 – 内存可见性
每次读取变量的时候，都从主存中取。而不是从各个线程的“工作内存”
而在每次写入变量的时候，都将线程工作内存的值写入主存

李_杰

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java多线程(基础、线程安全、线程间通信)

文章目录一、基础1、多线程的优势和问题1. 优势2. 问题2、线程基础1. 启动方式2. Thread核⼼方法3. 扩展：sleep()和wait()的区别4. 线程状态3、线程安全1. 死锁2、synchronized1、synchronized依赖于底层的操作系统的Mutex Lock来实现的， JDK1.6之后做了较大的优化-锁升级机制。2、锁的内存语义3、锁释放和锁获取的内存语义4、synchronized用法5、扩展4、线程间通信1、volatile一、基础1、多线程的优势和问题1. 优势
复制链接

扫一扫