Java SE高级-JUC并发编程三

最新推荐文章于 2024-04-24 20:52:08 发布
最新推荐文章于 2024-04-24 20:52:08 发布
阅读量233 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangzilong_2019/article/details/108087760
版权

JMM
Volatile
深入理解CAS
Unsafe类
各种锁的理解
面试、工作排查问题

JMM
  • Java内存模型，不存在的东西，概念，约定。
关于JMM同步的约定
  • 线程解锁前，必须把共享变量立即刷回主存
  • 线程加锁前，必须读取主存中的最新值到工作内存中
  • 加锁和解锁是同一把锁
8种操作

在这里插入图片描述
在这里插入图片描述

Volatile

Volatile是Java虚拟机提供轻量级的同步机制

  • 不保证可见性
  • 不保证原子性
  • 禁止指令重排
不保证可见性
import java.util.concurrent.TimeUnit;

public class JMMDemo {
    //不加volatile程序就会死循环
    //加 volatile 可以保证可见性
    private volatile static int num = 0;
    public static void main(String[] args) {
        new Thread(()->{  //线程一对主内存的变化不知道
            while (num == 0) {

            }
        }).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        num = 1;
        System.out.println(num);
    }
}
原子性：不可分割
  • 线程A在执行任务的时候，不能被打扰，也不能被分割，要么同时成功，要么同时失败
如果不加lock和 synchronized 无法保证原子性

在这里插入图片描述

使用原子类解决原子性
  • 这些类的底层都直接和操作系统挂钩，在内存中修改值，Unsafe类十一额特殊的存在
import java.util.concurrent.atomic.AtomicInteger;

public class VDemo02 {
    //volatile 不保证原子性
    private volatile static AtomicInteger num = new AtomicInteger();

    public static void add() {
        num.getAndIncrement();  //加1操作 CAS
    }
    public static void main(String[] args) {
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        if (Thread.activeCount() > 2) {  //main gc
            Thread.yield();
        }
        System.out.println(num);
    }

}
指令重排
  • 程序员写的程序并不是按照写的那样取执行
  • 处理在进行指令重排的时候，会考虑数据的依赖性关系
  • volatile可以避免指令重排

内存屏障、CPU指令作用：

  • 保证特定的操作执行顺序
  • 可以保证某些变量的内存可见性（利用这些特性volatile实现了可见性）
  • 源代码->编译器的优化重排->指令并行也可能会重排->内存系统一定会重排->执行
    在这里插入图片描述
彻底玩转单例模式
深入理解CAS
  • CAS：比较当前内存中的值和主内存中的值，如果这个值是期望的，则执行操作，如果不是则一直循环
  • 缺点：因为底层实自旋锁，循环会耗时
  • 一次只能保证一个共享变量的原子性
  • ABA问题
import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {
    //CAS  比较并交换
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);

        //期望更新
        //如果期望值正确则更新，否则不更新
        System.out.println(atomicInteger.compareAndSet(2020, 2021));;
        System.out.println(atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(2020, 2021));;
        System.out.println(atomicInteger.get());
    }
}
ABA问题（狸猫换太子）

在这里插入图片描述

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo02 {
    //CAS  比较并交换
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);

        //期望更新
        //如果期望值正确则更新，否则不更新
        // ======== 捣乱的线程= =======
        System.out.println(atomicInteger.compareAndSet(2020, 2021));;
        System.out.println(atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(2021, 2020));;
        System.out.println(atomicInteger.get());

        //========= 期望的的线程 =========
        System.out.println(atomicInteger.compareAndSet(2020, 2022));;
        System.out.println(atomicInteger.get());
    }
}
  • 泛型是包装类，注意对象引用问题

在这里插入图片描述

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class CASDemo03 {
    public static void main(String[] args) {
        //注意如果泛型是包装类，注意对象的引用问题
        AtomicStampedReference<Integer> atomicInteger = new AtomicStampedReference<>(1, 1);

        new Thread(()->{
            int stamp = atomicInteger.getStamp();  //获取当前版本号
            System.out.println("a1=" + stamp);

            //加延迟保证版本号是同一个
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            atomicInteger.compareAndSet(1, 2,
                    atomicInteger.getStamp(), atomicInteger.getStamp() + 1);

            System.out.println("a2=" + atomicInteger.getStamp());

            atomicInteger.compareAndSet(2, 1,
                    atomicInteger.getStamp(), atomicInteger.getStamp() + 1);

            System.out.println("a3=" + atomicInteger.getStamp());
        }, "a").start();

        new Thread(()->{
            int stamp = atomicInteger.getStamp();  //获取当前版本号
            System.out.println("b1=" + stamp);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            atomicInteger.compareAndSet(1, 6, stamp, stamp + 1);
            System.out.println("b1=" + atomicInteger.getStamp());

        }, "b").start();

    }
}
Unsafe类

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

各种锁的理解
公平锁
  • 非常公平，不能够插队，必须先来后到
非公平锁
  • 非常不公平，可以插队（默认都是非公平的）
    public ReentrantLock() {
        this.sync = new ReentrantLock.NonfairSync();
    }
    public ReentrantLock(boolean fair) {
        this.sync = (ReentrantLock.Sync)(fair ? new ReentrantLock.FairSync() : new ReentrantLock.NonfairSync());
    }
可重入锁

在这里插入图片描述

可重入锁synchronized版本
public class Demo01 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(()->{
            phone.sms();
        }, "a").start();

        new Thread(()->{
            phone.call();
        }, "b").start();
    }
}

class Phone{
    public synchronized void sms() {
        System.out.println(Thread.currentThread().getName() + "sms");
        //这里也有锁
        call();
    }

    public synchronized void call() {
        System.out.println(Thread.currentThread().getName() + "call");
    }
}
可重入锁Lock版本
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Demo02 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();

        new Thread(()->{
            phone.sms();
        }, "a").start();

        new Thread(()->{
            phone.call();
        }, "b").start();
    }
}

class Phone2{
    Lock lock = new ReentrantLock();

    public void sms() {
        lock.lock();  //细节问题，锁必须配对
        try {
            System.out.println(Thread.currentThread().getName() + "sms");
            //这里也有锁
            call();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void call() {

        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "call");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
自旋锁

在这里插入图片描述

import java.util.concurrent.atomic.AtomicReference;

/**
 * 自旋锁
 */
public class SpinLockDemo {
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    //加锁
    public void myLock() {
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName() + "==> myLock");

        //自旋锁
        while (!atomicReference.compareAndSet(null, thread)) {

        }
    }

    //解锁
    public void unLock() {
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName() + "==> myUnLock");
        atomicReference.compareAndSet(thread, null);
    }

}

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class TestSpinLock {
    public static void main(String[] args) throws InterruptedException {
        //ReentrantLock lock = new ReentrantLock();

        //底层使用的CAS自旋锁
        SpinLockDemo lock = new SpinLockDemo();

        new Thread(()->{
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unLock();
            }
        }, "t1").start();
        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unLock();
            }
        }, "t2").start();
    }
}
死锁

在这里插入图片描述

import java.util.concurrent.TimeUnit;

public class DeadLockDemo {
    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";

        new Thread(new MyThread(lockA, lockB), "t1").start();
        new Thread(new MyThread(lockA, lockB), "t2").start();
    }
}

class MyThread implements Runnable {
    private String lockA;
    private String lockB;

    public MyThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA) {
            System.out.println(Thread.currentThread().getName() + "lock:" + lockA + "->get" + lockB);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB) {
                System.out.println(Thread.currentThread().getName() + "lock:" + lockB+ "->get" + lockA);
            }
        }
    }
}
死锁的排查
  • 使用 jps -1 定位进程号
    在这里插入图片描述
  • 使用 jstack 进程号 找到死锁问题
    在这里插入图片描述
面试，工作种排查问题
  1. 日志
  2. 堆栈
Dragon Prince
关注
Java-JUC包中的锁-概述（一）
keep_trying的专栏
12-31 2654
根据锁的添加到Java中的时间，Java中的锁，可以分为”同步锁”和”JUC包中的锁”。一、同步锁　　即通过synchronized关键字来进行同步，实现对竞争资源的互斥访问的锁。Java 1.0版本中就已经支持同步锁了。 　　同步锁的原理是，对于每一个对象，有且仅有一个同步锁；不同的线程能共同访问该同步锁。但是，在同一个时间点，该同步锁能且只能被一个线程获取到。这样，获取到同步锁的线程就能进行C
Java SE高级-JUC并发编程一
wangzilong_2019的博客
08-20 429
JUC并发编程 什么是JUC 线程和进程 进程 一个程序，例如：QQ.EXE 程序的集合 一个进程可以包含多个线程，至少包括一个 Java默认有2个线程 线程 开一个进程Yypore，写字，自动保存（进程负责的） Java无法直接开启线程，只能通过调用本地方法开启 并发与并行 并发 CPU 一核，在同一时间段内交替执行 并行 CPU多核，多个线程同时执行 public class Test01 { public static void main(String[] args) {
Java SE高级-JUC并发编程二
wangzilong_2019的博客
08-20 332
线程池 运行程序的本质，占用系统资源。优化资源的使用->池化技术 三大方法、七大参数、四种拒绝策略 池化技术 实现准备一些资源，有人要用，从这里拿出去，用完后放回来 线程池技术 降低资源消耗 提高响应速度 方便管理 线程复用，可以控制最大并发数，管理线程 线程池3大方法 源码分析 //核心线程数 //最大线程数 //超时等待 //超时等待时间单位 //阻塞队列（候客区） //线程工厂 //拒绝策略 public ThreadPoolExecutor(int corePoolSize
JUC-java并发编程的艺术
HBryce24的博客
02-06 957
java并发编程
Java JUC详解：深入理解并发编程工具包
suqieer的博客
04-24 1934
java.util.concurrent：核心并发工具类，如ExecutorService、Semaphore、CountDownLatch等。java.util.concurrent.atomic：原子变量类，如AtomicInteger、AtomicLong、AtomicReference等。java.util.concurrent.locks：锁和同步器类，如ReentrantLock、ReadWriteLock、Condition等。
Java JUC 源码分析 - 并发编程线程基础
qq_33240556的博客
04-24 325
Java JUC（Java Util Concurrency）是Java平台标准版（Java SE）的一部分，包含在。包中，它提供了丰富的并发API和工具类，用于简化多线程环境下的并发编程，并确保程序在高并发场景下的正确性和性能。深入研究JUC源码有助于理解上述组件的工作原理和内部机制，这对于高效、安全地编写并发代码至关重要。的源码能够揭示其工作队列、线程生命周期管理、饱和策略等方面的设计细节。
java并发编程笔记整理（juc)(全）
m0_60264772的博客
07-09 2309
​✅作者简介：我是18shou，一名即将秋招的java实习生🔥系列专栏：牛客面经专栏📃推荐一款八股、面经、模拟面试、刷题神器👉 超级无敌牛逼之牛客耗时数小时从牛客整理的面经以及笔记 ​ java.util.concurrent工具包的简称就是juc，jdk1.5之后出现的进程：指在运行中的程序，程序一旦运行就是进程，同时进程也是是线程的容器，是系统进行资源分配和调度的单元，是资源分配的最小单元。是一个动态的过程：有它自身的产生，存在和消亡的过程。–生命周期线程（thread）是操作系统能够进行运算调度...
【JUC并发编程】
蛋饼吧的博客
06-19 1488
JUC是Java Util Concurrent的缩写,是Java SE 5.0中新增的一个包,主要提供了在并发编程中使用的工具类和框架。JUC包含了许多用于多线程编程的工具类和接口,如锁、原子变量、线程池、阻塞队列等。这些工具类和接口可以帮助开发者更方便地进行多线程编程,从而提高程序的并发性能和可靠性。JUC包中的工具类和接口都是线程安全的,可以在多线程环境下安全地使用。它们的设计和实现都是基于并发编程的最佳实践和原则,可以有效地避免线程安全问题的发生。
并发编程——JUC并发面试问题
庄小焱
05-10 3095
现如今，不管是应届毕业生还是工作三五年的工程师，在面试招聘的时候JUC并发编程是必须掌握的一个技能，否者你的面试结果可能会很差。本博文主要是整理JUC相关面试问题和答案。帮助大家在面试过程中能够回答面试官问题。本人将不断更新的JUC并发编程的相关面试问题。帮助小伙伴更好通过面试。
java高并发源码-java-concurrent:Java高并发，JUC，相关源码。1、马士兵高并发视频源码（听课时练习）
05-24
JUC，全称Java Util Concurrency，是Java平台标准版（Java SE）的一部分，提供了丰富的并发工具类，用于构建高效、可扩展的多线程应用。 首先，我们来了解下Java并发编程的基础知识。在Java中，多线程主要通过...
JUC并发编程介绍，聊聊单线程和多线程
2301_77899321的博客
05-23 146
JUC并发编程介绍，聊聊单线程和多线程
Java 高并发编程详解：多线程与架构设计
GitChat
12-10 6898
内容简介 本书主要包含四个部分： 部分主要阐述 Thread 的基础知识，详细介绍线程的 API 使用、线程安全、线程间数据通信，以及如何保护共享资源等内容，它是深入学习多线程内容的基础。 第二部分引入了 ClassLoader，这是因为 ClassLoader 与线程不无关系，我们可以通过 synchronized 关键字，或者 Lock 等显式锁的方式在代码的编写阶段对共享资源进行数据一致...
有没有接触过JUC高并发编程，说一说
06-13
JUC是Java Util Concurrent的缩写，它是Java SE 5中新引入的一组并发编程的工具类库，主要用于解决多线程并发访问共享数据时的线程安全问题。JUC提供了很多实用的工具类，例如CountDownLatch、CyclicBarrier、...
智慧旅游景区解决方案PPT(50页).pptx
最新发布
09-21
智慧旅游解决方案利用云计算、物联网和移动互联网技术，通过便携终端设备，实现对旅游资源、经济、活动和旅游者信息的智能感知和发布。这种技术的应用旨在提升游客在旅游各个环节的体验，使他们能够轻松获取信息、规划行程、预订票务和安排食宿。智慧旅游平台为旅游管理部门、企业和游客提供服务，包括政策发布、行政管理、景区安全、游客流量统计分析、投诉反馈等。此外，平台还提供广告促销、库存信息、景点介绍、电子门票、社交互动等功能。 智慧旅游的建设规划得到了国家政策的支持，如《国家中长期科技发展规划纲要》和国务院的《关于加快发展旅游业的意见》，这些政策强调了旅游信息服务平台的建设和信息化服务的重要性。随着技术的成熟和政策环境的优化，智慧旅游的时机已经到来。 智慧旅游平台采用SaaS、PaaS和IaaS等云服务模式，提供简化的软件开发、测试和部署环境，实现资源的按需配置和快速部署。这些服务模式支持旅游企业、消费者和管理部门开发高性能、高可扩展的应用服务。平台还整合了旅游信息资源，提供了丰富的旅游产品创意平台和统一的旅游综合信息库。 智慧旅游融合应用面向游客和景区景点主管机构，提供无线城市门户、智能导游、智能门票及优惠券、景区综合安防、车辆及停车场管理等服务。这些应用通过物联网和云计算技术，实现了旅游服务的智能化、个性化和协同化，提高了旅游服务的自由度和信息共享的动态性。 智慧旅游的发展标志着旅游信息化建设的智能化和应用多样化趋势，多种技术和应用交叉渗透至旅游行业的各个方面，预示着全面的智慧旅游时代已经到来。智慧旅游不仅提升了游客的旅游体验，也为旅游管理和服务提供了高效的技术支持。
智慧旅游实景三维智慧景区建设方案PPT(70页).pptx
09-21
智慧旅游解决方案利用云计算、物联网和移动互联网技术，通过便携终端设备，实现对旅游资源、经济、活动和旅游者信息的智能感知和发布。这种技术的应用旨在提升游客在旅游各个环节的体验，使他们能够轻松获取信息、规划行程、预订票务和安排食宿。智慧旅游平台为旅游管理部门、企业和游客提供服务，包括政策发布、行政管理、景区安全、游客流量统计分析、投诉反馈等。此外，平台还提供广告促销、库存信息、景点介绍、电子门票、社交互动等功能。 智慧旅游的建设规划得到了国家政策的支持，如《国家中长期科技发展规划纲要》和国务院的《关于加快发展旅游业的意见》，这些政策强调了旅游信息服务平台的建设和信息化服务的重要性。随着技术的成熟和政策环境的优化，智慧旅游的时机已经到来。 智慧旅游平台采用SaaS、PaaS和IaaS等云服务模式，提供简化的软件开发、测试和部署环境，实现资源的按需配置和快速部署。这些服务模式支持旅游企业、消费者和管理部门开发高性能、高可扩展的应用服务。平台还整合了旅游信息资源，提供了丰富的旅游产品创意平台和统一的旅游综合信息库。 智慧旅游融合应用面向游客和景区景点主管机构，提供无线城市门户、智能导游、智能门票及优惠券、景区综合安防、车辆及停车场管理等服务。这些应用通过物联网和云计算技术，实现了旅游服务的智能化、个性化和协同化，提高了旅游服务的自由度和信息共享的动态性。 智慧旅游的发展标志着旅游信息化建设的智能化和应用多样化趋势，多种技术和应用交叉渗透至旅游行业的各个方面，预示着全面的智慧旅游时代已经到来。智慧旅游不仅提升了游客的旅游体验，也为旅游管理和服务提供了高效的技术支持。
基于深度学习实现的半监督学习例子.zip
09-21
深度学习是机器学习的一个子领域，它基于人工神经网络的研究，特别是利用多层次的神经网络来进行学习和模式识别。深度学习模型能够学习数据的高层次特征，这些特征对于图像和语音识别、自然语言处理、医学图像分析等应用至关重要。以下是深度学习的一些关键概念和组成部分： 1. **神经网络（Neural Networks）**：深度学习的基础是人工神经网络，它是由多个层组成的网络结构，包括输入层、隐藏层和输出层。每个层由多个神经元组成，神经元之间通过权重连接。 2. **前馈神经网络（Feedforward Neural Networks）**：这是最常见的神经网络类型，信息从输入层流向隐藏层，最终到达输出层。 3. **卷积神经网络（Convolutional Neural Networks, CNNs）**：这种网络特别适合处理具有网格结构的数据，如图像。它们使用卷积层来提取图像的特征。 4. **循环神经网络（Recurrent Neural Networks, RNNs）**：这种网络能够处理序列数据，如时间序列或自然语言，因为它们具有记忆功能，能够捕捉数据中的时间依赖性。 5. **长短期记忆网络（Long Short-Term Memory, LSTM）**：LSTM 是一种特殊的 RNN，它能够学习长期依赖关系，非常适合复杂的序列预测任务。 6. **生成对抗网络（Generative Adversarial Networks, GANs）**：由两个网络组成，一个生成器和一个判别器，它们相互竞争，生成器生成数据，判别器评估数据的真实性。 7. **深度学习框架**：如 TensorFlow、Keras、PyTorch 等，这些框架提供了构建、训练和部署深度学习模型的工具和库。 8. **激活函数（Activation Functions）**：如 ReLU、Sigmoid、Tanh 等，它们在神经网络中用于添加非线性，使得网络能够学习复杂的函数。 9. **损失函数（Loss Functions）**：用于评估模型的预测与真实值之间的差异，常见的损失函数包括均方误差（MSE）、交叉熵（Cross-Entropy）等。 10. **优化算法（Optimization Algorithms）**：如梯度下降（Gradient Descent）、随机梯度下降（SGD）、Adam 等，用于更新网络权重，以最小化损失函数。 11. **正则化（Regularization）**：技术如 Dropout、L1/L2 正则化等，用于防止模型过拟合。 12. **迁移学习（Transfer Learning）**：利用在一个任务上训练好的模型来提高另一个相关任务的性能。 深度学习在许多领域都取得了显著的成就，但它也面临着一些挑战，如对大量数据的依赖、模型的解释性差、计算资源消耗大等。研究人员正在不断探索新的方法来解决这些问题。
关于APx测试耳机音频的参数设置及步骤 关于APx测试耳机音频的参数设置及步骤
09-21
关于APx测试耳机音频的参数设置及步骤 关于APx测试耳机音频的参数设置及步骤
jQuery背景可滑动的导航菜单代码，鼠标经过导航时导航背景可滑动，兼容主流浏览器
09-21
jQuery背景可滑动的导航菜单代码，鼠标经过导航时导航背景可滑动，兼容主流浏览器 使用方法： 1、引入reset.css、index.css、jquery-1.7.2.min.js库文件，及jquery.movebg.js插件 2、在文件中加入<!-- 代码 开始 --><!-- 代码 结束 -->区域代码 3、移动的滑动可根据需要自由修改外观
狂神说java-juc并发编程
09-23
JUC是Java中用于处理并发编程的三个包之一，它包含了一系列的并发工具类和线程安全的集合类。其中，java.util.concurrent.atomic包提供了一些原子性操作的类，可以保证线程安全地对变量进行操作；java.util....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值