Java并发编程知识点梳理

最新推荐文章于 2024-04-11 02:12:31 发布

Maravilloso

最新推荐文章于 2024-04-11 02:12:31 发布

阅读量183

点赞数 1

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/weixin_47460244/article/details/131858332

版权

何为线程

线程与进程相似，但线程是一个比进程更小的执行单位。
同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈。
注意：一个 Java 程序的运行是 main 线程和多个其他线程同时运行。
总结：
线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。线程执行开销小，但不利于资源的管理和保护；而进程正相反。
程序计数器私有主要是为了线程切换后能恢复到正确的执行位置。
为了保证线程中的局部变量不被别的线程访问到，虚拟机栈和本地方法栈是线程私有的。
堆和方法区是所有线程共享的资源。新建的对象存储在堆区，已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

使用多线程带来的问题

并发编程可能会遇到很多问题。比如：内存泄漏、死锁、线程不安全等。
对于同一份数据，不管有多少个线程同时访问，都要保证这份数据的正确性与一致性。

线程的状态转换

对于操作系统，线程通过抢占式调用CPU资源。线程的状态分为RUNNING和Ready。对于Java系统，这两种状态都是runnable。
线程执行wait（）方法之后，线程进入WAITING（等待）状态。进入等待状态的线程需要依靠其他线程的通知才能返回到运行状态。
TIMED_WAITING(超时等待)
sleep(long millis）方法或 wait（long millis）方法可以使线程出于超时等待的状态。时间结束，线程会返回runnable状态。
线程在执行完了 run()方法之后将会进入到 TERMINATED（终止）状态。
当线程进入 synchronized 方法/块或者调用 wait 后（被 notify）重新进入 synchronized 方法/块，但是锁被其它线程占有，这个时候线程就会进入 BLOCKED（阻塞）状态。

线程上下文切换

当出现如下情况，线程会从占用CPU状态中退出。
在这里插入图片描述

线程死锁

在这里插入图片描述死锁产生的四个必要条件
预防死锁
注意：sleep（）方法和wait（）方法都可以停止对应线程的运行，sleep方法位于Thread类中，wait()方法位于Object类中。sleep（）方法不会释放获取的对象锁；而wait（）方法要释放对象锁。

可以直接调用 Thread 类的 run 方法吗？

volatile关键字

将变量声明为volatile，这个变量是共享的且不稳定。每次使用它都到主存中进行读取。
volatile 关键字能保证数据的可见性，但不能保证数据的原子性。synchronized 关键字两者都能保证。
volatile 关键字除了可以保证变量的可见性，还有一个重要的作用就是防止 JVM 的指令重排序。但是，不能保证对变量的操作是原子性的。
双重检验锁方式实现单例模式的原理（线程安全）


    private volatile static Singleton uniqueInstance;

    private Singleton() {
    }

    public  static Singleton getUniqueInstance() {
       //先判断对象是否已经实例过，没有实例化过才进入加锁代码
        if (uniqueInstance == null) {
            //类对象加锁
            synchronized (Singleton.class) {
                if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}

注意：在多线程环境下指令重排会导致一个线程获得还没有初始化的实例。
利用synchronized（修饰方法）、Lock（ReentrantLock）或者AtomicInteger使变量自增的操作（如：inc++）具有原子性。

乐观锁和悲观锁

共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程。
像 Java 中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。
注意：高并发场景下，激励的锁竞争会导致线程阻塞。阻塞线程会导致系统的上下文切换，增加系统的性能开销。悲观锁会存在死锁问题。

    synchronized (this) {
        // 需要同步的操作
    }
}

private Lock lock = new ReentrantLock();
lock.lock();
try {
   // 需要同步的操作
} finally {
    lock.unlock();
}

乐观锁

在提交修改的时候去验证对应的资源（也就是数据）是否被其它线程修改了（具体方法可以使用版本号机制或 CAS 算法）
乐观锁通常多于写比较少的情况下（多读场景，竞争较少），这样可以避免频繁加锁影响性能。

// 代价就是会消耗更多的内存空间（空间换时间）
LongAdder sum = new LongAdder();
sum.increment();

乐观锁的实现机制
1.版本号机制
提交版本必须等于当前版本才能执行更新的乐观锁策略。
2.CAS算法（Compare And Swap）比较与交换
在这里插入图片描述当且仅当 V 的值等于 E 时，CAS 通过原子方式用新值 N 来更新 V 的值。如果不等，说明已经有其它线程更新了 V，则当前线程放弃更新。
Java 语言并没有直接实现 CAS，CAS 相关的实现是通过 C++ 内联汇编的形式实现的（JNI 调用）。因此， CAS 的具体实现和操作系统以及 CPU 都有关系。
sun.misc包下的Unsafe类提供了compareAndSwapObject、compareAndSwapInt、compareAndSwapLong方法来实现的对Object、int、long类型的 CAS 操作。

	*  CAS
  * @param o         包含要修改field的对象
  * @param offset    对象中某field的偏移量
  * @param expected  期望值
  * @param update    更新值
  * @return          true | false
  */
public final native boolean compareAndSwapObject(Object o, long offset,  Object expected, Object update);

public final native boolean compareAndSwapInt(Object o, long offset, int expected,int update);

public final native boolean compareAndSwapLong(Object o, long offset, long expected, long update);

乐观锁存在的问题（ABA问题

ABA 问题的解决思路是在变量前面追加上版本号或者时间戳。
DK 1.5 以后的 AtomicStampedReference 类就是用来解决 ABA 问题的，其中的 compareAndSet() 方法就是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志。
乐观锁会导致的其他问题：
1.不断通过自旋的方式进行重试，从而增加CPU开销。
2.CAS 只对单个共享变量有效，当操作涉及跨多个共享变量时 CAS 无效。
解决方法：
从 JDK 1.5 开始，提供了AtomicReference类，可以把多个变量放在一个对象里来进行 CAS 操作。所以我们可以使用锁或者利用AtomicReference类把多个共享变量合并成一个共享变量来操作。

synchronized关键字

在早期版本中，synchronized是重量级锁。
这是因为监视器锁（monitor）是依赖于底层的操作系统的 Mutex Lock 来实现的。
在 Java 6 之后， synchronized 引入了大量的优化如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。
synchronized的使用方法
1.修饰实例方法（锁当前对象实例）
2.修饰静态方法（锁当前类）
3.修饰代码块（锁指定对象/类）
synchronized(object) 表示进入同步代码库前要获得给定对象的锁。
synchronized(类.class) 表示进入同步代码前要获得给定 Class 的锁。
在这里插入图片描述 构造方法不能使用 synchronized 关键字修饰。
因为构造方法本身就属于线程安全的，不存在同步的构造方法一说。

synchronized底层实现原理

1.synchronized 同步语句块的情况
实现monitor监视器（基于C++实现的），其依赖于操作系统的mutex锁。每个对象中都内置了一个ObjectMonitor对象。
在这里插入图片描述 2.synchronized 修饰方法的的情况
JVM 通过该 ACC_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。
如果是实例方法，JVM 会尝试获取实例对象的锁。如果是静态方法，JVM 会尝试获取当前 class 的锁。

两者的本质都是对对象监视器 monitor 的获取。
JDK1.6之后的synchronized底层做了哪些优化？
锁主要存在四种状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。

synchronized 和 volatile 有什么区别？

synchronized 关键字和 volatile 关键字是两个互补的存在，而不是对立的存在！
在这里插入图片描述

公平锁与非公平锁

在这里插入图片描述注意：非公平锁可能会导致线程饥饿的问题。ReentrantLock默认是实现非公平锁，但是可通过构造方法中的布尔类型的参数（ReentrantLock(boolean fair)）设置为公平锁；而synchronized只能是非公平锁。

ReentrantLock

ReentrantLock默认使用非公平锁，也可以通过构造器来显式的指定使用公平锁。

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

可中断锁与不可中断锁

在这里插入图片描述 ReentrantLock属于可中断锁，而Synchronized属于不可中断锁。
ReentrantLock与Synchronized都属于可重入锁。如果是不可重入锁，就会造成死锁。

    public synchronized void method1() {
        System.out.println("方法1");
        method2();
    }

    public synchronized void method2() {
        System.out.println("方法2");
    }
}

注意：
synchronized 是依赖于 JVM 实现的，虚拟机团队在 JDK1.6 为 synchronized 关键字进行了很多优化；ReentrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock() 方法配合 try/finally 语句块来完成）。

ReentrantLock 比 synchronized 增加了一些高级功能

1.等待可中断：lock.lockInterruptibly()实现能够中断等待锁的线程的机制
2.可实现公平锁
3.可实现选择性通知（锁可以绑定多个条件）：需要借助于Condition接口与newCondition()方法。

在这里插入图片描述

ReentrantReadWriteLock

ReentrantReadWriteLock是两把锁，一把是写锁，一把是读锁。读锁是共享锁，写锁是独占锁。
ReentrantReadWriteLock支持公平锁和非公平锁，可以通过构造器来显示的指定。

public ReentrantReadWriteLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
    readerLock = new ReadLock(this);
    writerLock = new WriteLock(this);
}

读锁不能升级为写锁，写锁可以降级为读锁

ThreadLocal

ThreadLocal类主要解决的就是让每个线程绑定自己的值，可以将ThreadLocal类形象的比喻成存放数据的盒子，盒子中可以存储每个线程的私有数据。
ThreadLocal数据结构：
在这里插入图片描述

线程池

线程池就是管理一系列线程的资源池。当有任务要处理时，直接从线程池中获取线程来处理，处理完之后线程并不会立即被销毁，而是等待下一个任务。
池化技术的思想主要是为了减少每次获取资源的消耗，提高对资源的利用率。
使用线程池的好处
1.降低资源消耗
2.提高响应速度
3.提高线程的可管理性

创建线程池的方法

1.通过ThreadPoolExecutor构造函数来创建（推荐）。
例子：

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5,10,10, TimeUnit.SECONDS,new LinkedBlockingDeque<>(100));

2.通过 Executor 框架的工具类 Executors 来创建
在这里插入图片描述线程池各个参数的关系

线程池的饱和策略

当线程池中的同时运行的线程数达到最大线程数并且队列也被放满了任务时，ThreadPoolExecutor默认调用ThreadPoolExecutor.AbortPolicy（抛出 RejectedExecutionException来拒绝新任务的处理。）；
如果不想丢弃任务的话，可以使用CallerRunsPolicy。
CallerRunsPolicy 和其他的几个策略不同，它既不会抛弃任务，也不会抛出异常，而是将任务回退给调用者，使用调用者的线程来执行任务。

线程池常用的阻塞队列

FixedThreadPool和SingleThreadExecutor采用的是LinkedBlockingQueue(无界队列)。由于队列永远不会被放满，因此FixedThreadPool最多只能创建核心线程数的线程。
CachedThreadPool采用的是SynchronousQueue（同步队列）。同步队列没有容量。CachedThreadPool 的最大线程数是 Integer.MAX_VALUE ，可以理解为线程数是可以无限扩展的，可能会创建大量线程，从而导致 OOM。
ScheduledThreadPool和SingleThreadScheduledExecutor采用的是DelayedWorkQueue(延迟阻塞队列)。延迟阻塞队列采用的是堆结构，可以保证每次出队的任务都是当前队列中执行时间最靠前的。
DelayedWorkQueue 添加元素满了之后会自动扩容原来容量的 1/2，即永远不会阻塞，最大扩容可达 Integer.MAX_VALUE，所以最多只能创建核心线程数的线程。
线程池处理任务流程
在这里插入图片描述

给线程池命名

1.利用 guava 的 ThreadFactoryBuilder。
2.自己实现 ThreadFactory。

如何设定线程池的大小

线程数量过多会增加上下文切换的成本。
注意：任务从保存到再加载的过程就是一次上下文切换。
一个简单并且适用面比较广的公式：
1.CPU 密集型任务(N+1)
当某个线程发生缺页中断，或者其他原因导致任务暂停，使CPU出于空闲状态，在这种情况下多出来的一个线程就可以充分利用 CPU 的空闲时间。
2.I/O 密集型任务(2N)
如何判断是 CPU 密集任务还是 IO 密集任务？
CPU密集型：比如在内存中对大量数据进行排序。
IO密集型：比如网络读取、文件读取。
线程数更严谨的计算的方法应该是：最佳线程数 = N（CPU 核心数）∗（1+WT（线程等待时间）/ST（线程计算时间）），其中 WT（线程等待时间）=线程运行总时间 - ST（线程计算时间）。

动态修改线程池的参数

在这里插入图片描述

Future类

异步思想的典型运用。当执行某一耗时任务时，可以将这个耗时任务交给一个子线程去异步执行。
等我们的事情干完后，我们再通过 Future 类获取到耗时任务的执行结果。

这其实就是多线程中经典的 Future 模式，你可以将其看作是一种设计模式，核心思想是异步调用，主要用在多线程领域，并非 Java 语言独有。

在 Java 中，Future 类只是一个泛型接口，位于 java.util.concurrent 包下，其中定义了== 5 个方法==，主要包括下面这 4 个功能：取消任务；判断任务是否被取消;判断任务是否已经执行完成;获取任务执行结果。

Future和Callable之间的关系

FutureTask 有两个构造函数，可传入 Callable 或者 Runnable 对象。实际上，传入 Runnable 对象也会在方法内部转换为Callable 对象。
在这里插入图片描述

CompletableFuture 类的作用

CompletableFuture 除了提供了更为好用和强大的 Future 特性之外，还提供了函数式编程、异步任务编排组合（可以将多个异步任务串联起来，组成一个完整的链式调用）等能力。

AQS

AQS 的全称为 AbstractQueuedSynchronizer ，翻译过来的意思就是抽象队列同步器。这个类在 java.util.concurrent.locks 包下面。
使用AQS能简单高效地构造处应用广泛地大量同步器。
比如：ReentrantLock，Semaphore，ReentrantReadWriteLock，SynchronousQueue。
CLH 队列锁：将暂时获取不到锁的线程加入到队列中。
CLH队列地结构
在这里插入图片描述 AQS的核心原理图
AQS 使用 int 成员变量 state （利用volatile修饰保证线程可见性）表示同步状态，通过内置的线程等待队列来完成获取资源线程的排队工作。
状态信息 state 可以通过 protected 类型的getState()、setState()和compareAndSetState() 进行操作。并且，这几个方法都是final修饰的，在子类中无法被重写。

例子
在这里插入图片描述

Semaphore

synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，而Semaphore(信号量)可以用来控制同时访问特定资源的线程数量。
semaphore有两种模式：
公平模式：调用 acquire() 方法的顺序就是获取许可证的顺序，遵循 FIFO；
非公平模式：抢占式的。
Semaphore默认为非公平模式。
例子：
Semaphore 通常用于那些资源有明确访问数量限制的场景比如限流（仅限于单机模式，实际项目中推荐使用 Redis +Lua 来做限流）。

Semaphore的原理
Semaphore 是共享锁的一种实现，它默认构造 AQS 的 state 值为 permits。
1.调用semaphore.acquire() ，线程尝试获取许可证，如果 state >= 0 的话，则表示可以获取成功。如果获取成功的话，使用 CAS 操作去修改 state 的值 state=state-1。如果 state<0 的话，则表示许可证数量不足。此时会创建一个 Node 节点加入阻塞队列，挂起当前线程。
2.**调用semaphore.release(); **，线程尝试释放许可证，并使用 CAS 操作去修改 state 的值 state=state+1。释放许可证成功之后，同时会唤醒同步队列中的一个线程。被唤醒的线程会重新尝试去修改 state 的值 state=state-1 ，如果 state>=0 则获取令牌成功，否则重新进入阻塞队列，挂起线程。

CountDownLatch的原理

CountDownLatch 允许 count 个线程阻塞在一个地方，直至所有线程的任务都执行完毕。
CountDownLatch 是共享锁的一种实现,它默认构造 AQS 的 state 值为 count。
例子

public class CountDownLatchExample1 {
    // 处理文件的数量
    private static final int threadCount = 6;

    public static void main(String[] args) throws InterruptedException {
        // 创建一个具有固定线程数量的线程池对象（推荐使用构造方法创建）
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            final int threadnum = i;
            threadPool.execute(() -> {
                try {
                    //处理文件的业务操作
                    //......
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //表示一个文件已经被完成
                    countDownLatch.countDown();
                }

            });
        }
        countDownLatch.await();
        threadPool.shutdown();
        System.out.println("finish");
    }
}

CyclicBarrier

CountDownLatch 的实现是基于 AQS 的，而 CycliBarrier 是基于 ReentrantLock(ReentrantLock 也属于 AQS 同步器)和 Condition 的。
CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。
作用
让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。
原理
构造方法中的parties 就代表了有拦截的线程的数量，当拦截的线程数量达到这个值的时候就打开栅栏，让所有线程通过。

CompletableFuture的使用

在这里插入图片描述

Maravilloso

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java并发编程知识点梳理

释放许可证成功之后，同时会唤醒同步队列中的一个线程。被唤醒的线程会重新尝试去修改 state 的值 state=state-1 ，如果 state>=0 则获取令牌成功，否则重新进入阻塞队列，挂起线程。注意：sleep（）方法和wait（）方法都可以停止对应线程的运行，sleep方法位于Thread类中，wait()方法位于Object类中。：最佳线程数 = N（CPU 核心数）∗（1+WT（线程等待时间）/ST（线程计算时间）），其中 WT（线程等待时间）=线程运行总时间 - ST（线程计算时间）。
复制链接

扫一扫