详解多线程的重要概念

最新推荐文章于 2024-08-23 15:54:50 发布

知春路SpideMan

最新推荐文章于 2024-08-23 15:54:50 发布

阅读量168

点赞数

分类专栏：多线程文章标签： java 多线程面试 juc

本文链接：https://blog.csdn.net/weixin_43889339/article/details/113730134

版权

多线程专栏收录该内容

2 篇文章 0 订阅

订阅专栏

序言
首先问自己一个问题，Java在支持多线程方面做了哪些努力？
第一，JVM屏蔽了各种平台差别，结合处理器层面，提供并发源语的支持，例如synchronized、volatile；
第二，JDK的编写者提供了并发工具包（java.util.concurrent），例如JUC锁实现线程同步的轻量方式；
第三，支持开发者对线程、线程池的状态管理，例如线程开启、休息、停止。

多线程的优点
多线程的目标
并发源语、JUC锁
使用例子经验总结

1、多线程的优点

压榨处理器性能
首先，单核CPU通过时钟频率的缩短来提升性能已经到了瓶颈，主流厂商都已支持多核CPU，如果还是单线程程序的话，那就是只能使用一个CPU，存在资源浪费；
其次，即使面对单核CPU，线程存在挂起、阻塞的机制，而且学过操作系统的同学都知道，阻塞时候CPU可以被分配给其他线程使用，就比如你喝茶的同时不影响看报纸。

2、多线程的目标

安排合理的调度机制
在提升CPU使用率的同时，降低线程上下文切换的频率，这需要Doug Lea和诸位程序员的共同努力。

3、Java对多线程的支持、并发源语、JUC锁

我将顺序介绍以下知识点，

线程阻塞的含义、线程的状态切换
并发源语、并发工具包的使用
JUC包底层原理探究

第一，线程阻塞是指线程挂起，广义上讲，“夯住”也算是挂起的一种。当前线程阻塞后，CPU才能分配时间片给下一个线程。而本质上有两种方式让线程阻塞，第一，自旋式获取状态；第二，使用等待、唤醒机制。第一种对于CPU很不友好，所以我们着重说第二种。等待在JAVA实现上是调用Object.wait()的方法和Unsafe.park()的两种方式，对应的都是Native方法实现，鉴于本人C++能力薄弱，暂时只研究到JNI层面。
线程的状态切换主流程图片：
线程状态流转
特别注明：当线程被中断后，可从waiting、waiting_timeout、blocked直接到terminate，非主要流程，本图不再赘述

第二，并发源语和并发工具包，在Java1.5之前，只有synchronized和volatile两种并发源语，Java1.5以后，配合处理器支持CAS操作，诞生了JUC的工具包，以ReentranLock、Semaphore、CylicBarrier、阻塞队列（LinkedBlockQueue）为代表，下面详解使用流程

volatile

特性	解释
可见性	及时刷新到进程主存，置其他线程内存过期
禁止重排序	程序顺序、内存、处理器指令禁止重排序（lock cmpExange）
原子性	不保证原子性，不能做有状态依赖的操作，比如计数
实现方式	处理器插入内存屏障
具体规则	volatile写之前的任何操作，不会排到之后；volatile读之后的操作，不会排到之前

Semaphore ：信号量

特性	解释
semaphore.acquire()	尝试获取1个信号量，获取不到就阻塞
Semaphore.release()	增加1个信号量
场景	控制多个线程在特定情况下的有序执行，比如红灯停，绿灯亮，红灯是一个信号量A ,绿灯是信号量B，两个线程同时执行时候，如果执行完A，减A信号量，给B一个信号量；执行完B，减B信号量，给A一个信号量
经验	可以使用信号量的地方，使用ReentranLock+condition+volatile变量也可以搞定

/**
 *实现A线程打印0，B线程打印1，各循环40次
**/
public static void main(String[] args) {
        Semaphore semaphoreA = new Semaphore(1);
        Semaphore semaphoreB = new Semaphore(0);

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    try {
                        semaphoreA.acquire();
                        System.out.print("0");
                        semaphoreB.release();

                    } catch (Exception e) {

                    }
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    try {
                        semaphoreB.acquire();
                        System.out.print("1");
                        semaphoreA.release();

                    } catch (Exception e) {

                    }
                }
            }
        });
        t2.start();
        t1.start();
        }

队列：linkedBlockQueue

实现：使用reentranLock的两个condition实现生产者、消费者模式，若队列为空，阻塞消费者；队列已满，阻塞生产者

        putLock.lockInterruptibly();
        try {
            // 每次检查队列满，则让线程在notFull处等待，加入等待队列
            while (count.get() == capacity) {
                notFull.await();
            }
            enqueue(node);
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            putLock.unlock();
        }

CyclicBarrier：栅栏

cyclicBarrier.await()：实现线程等待，计数到顶时候开始执行线程
优点是计数可自动恢复，这个也是区分countDownLatch的特性

 // 1、实现的关键，让线程在trip处等待
 /** The lock for guarding barrier entry */
    private final ReentrantLock lock = new ReentrantLock();
    /** Condition to wait on until tripped */
    private final Condition trip = lock.newCondition();

// 2、当达到线程数量时候，index=0
            int index = --count;
            if (index == 0) {  // tripped
                boolean ranAction = false;
                try {
                    final Runnable command = barrierCommand;
                    if (command != null)
                        command.run();
                    ranAction = true;
                    // 这里会将计数重置，开始下一轮
                    nextGeneration();
                    return 0;
                } finally {
                    if (!ranAction)
                        breakBarrier();
                }
            }

// 唤醒阻塞在trip的线程，重置计数
private void nextGeneration() {
        // signal completion of last generation
        trip.signalAll();
        // set up next generation
        count = parties;
        generation = new Generation();
    }

第三，对于JUC底层的探究，JUC的实现依赖于AQS

特性	含义
同步队列（CLH）	FIFO的双向链表
队列构建	线程尝试CAS更新状态值，更新成功，则代表获取到锁；更新失败则作为node加入同步队列的尾部
队列出队	每个结点做CAS自旋，当头结点释放锁之后；公平锁保证头结点的后续结点，通过CAS更新状态值，获取到锁；非公平锁是所有同步队列的结点均参与CAS更新状态值；若线程调用lock.await()时候，从同步队列头结点移除，加入等待队列

在这里插入图片描述