JUC使用总结

最新推荐文章于 2022-04-21 21:03:13 发布
最新推荐文章于 2022-04-21 21:03:13 发布
阅读量594 收藏 2
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XY1790026787/article/details/104106137
版权

1、前言

这篇博客是对 Java 并发包（java.util.concurrent）以及多线程的一些总结，记录一些常用用法和个人理解。由于目前还没有接触过真正的并发场景且，而且还缺少一些内容的铺垫，所以仅仅一些浅层面的使用，有问题的地方还请多多指正！

1.1 记录规划

JUC 包下的内容相对来说还是很多的，提供了各种各样的对并发编程的支持，这篇博客里要记录的大致有四类：

  • atomic包里是一些原子类。
  • locks包里是一些锁。
  • 一些辅助类，比如CountDownLatch、CycliBarrier、Semaphore。
  • 一些并发集合。



2、多线程下的问题

2.1 多线程回顾

线程状态

在这里插入图片描述

常用方法

Thread 类
Thread.yield()静态方法。暂停当前正在执行的线程对象，并执行其他线程
Thread.sleep()静态方法。让当前正在执行的线程休眠（暂停执行）
Thread.currentThread().getName()静态方法。返回对当前正在执行的线程名
thread.start()使该线程开始执行；JAVA虚拟机调用该线程的run()方法
thread.join(millis)等待该线程终止的时间最长为 millis 毫秒
Object 类WARNING：需要在同步方法或同步代码块中调用
o.wait()使当前线程等待，直到另一个线程调用notify()或notifyAll()
o.notify()唤醒正在此对象的监视器上等待的单个线程
o.notifyAll()唤醒此对象的监视器上正在等待的所有线程
2.2 Java 内存模型（JMM）

简介

QUOTE

Java虚拟机规范中定义了Java内存模型（Java Memory Model，JMM），用于屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的并发效果，JMM规范了Java虚拟机与计算机内存是如何协同工作的：规定了一个线程如何和何时可以看到由其他线程修改过后的共享变量的值，以及在必须时如何同步的访问共享变量。

内容

QUOTE

JMM规定了所有的变量都存储在主内存（Main Memory）中。每个线程还有自己的工作内存（Working Memory）,线程的工作内存中保存了该线程使用到的变量的主内存的副本拷贝，线程对变量的所有操作（读取、赋值等）都必须在工作内存中进行，而不能直接读写主内存中的变量（volatile变量仍然有工作内存的拷贝，但是由于它特殊的操作顺序性规定，所以看起来如同直接在主内存中读写访问一般）。不同的线程之间也无法直接访问对方工作内存中的变量，线程之间值的传递都需要通过主内存来完成。

2.3 误区

JMM 本身只是一层 Java 虚拟机（JVM）的规范，是由具体的 JVM 实现的。目前对 JVM 还不了解也不清楚具体的实现。但是对于 JMM 的理解上的一些误区却可能存在。

WARNING

比如“工作内存”和“主内存”这两个描述，所以引入知乎的一条帖子：

2.4 概扩
  • 多线程之间的通信方式：共享内存、消息传递。
  • 大多数情况下都需要以共享内存来进行多线程之间的通信（暂时只讨论这种方式）。
  • 具体方式：多线程操作同一个共享变量（线程操作资源类）。
  • 保证线程安全的指标：原子性、可见性、有序性。
  • 保证线程安全的具体方式：加锁同步。
2.5 并发编程特性
  • 原子性：操作中途不应被其他线程干扰，对参与不变性约束的变量的操作要么都成功，要么都不成功。
  • 可见性：某个线程修改了共享变量，能够立即让其他线程知晓。
  • 有序性：为了保证多线程并行的串行语义，需要禁止指令重排。

QUOTE

指令重排：编译器和 CPU 在满足数据依赖性的前提下会进行一些指令重排来提高效率。



3、volatile

3.1 可见性问题

如下代码中，main 线程对 sharedVar 的修改， t1 线程不能及时可见，故 t1 线程会一直死循环。

public class Test {
    private static int sharedVar = 0;

    public static void main(String[] args) {
        new Thread(() -> {
            while (sharedVar == 0) { }
            System.out.println(sharedVar);
        }, "t1").start();

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

        sharedVar = 1;
    }
}

使用 volatile关键字修饰共享变量sharedVar后，t1 线程及时可见 sharedVar的修改，会跳出循环。



4、 synchronized

4.1 原子性问题

如下代码中，add()方法里的 ++ 操作并不是一个原子性操作，10 条线程各加 1000 次结果并不能达到 10000。

public class Test {
    private static int sharedVar = 0;

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

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

        System.out.println(sharedVar);
    }

    private static void add() {
        sharedVar++;
    }
}

使用synchronized同步add()方法后，保证了代码块的原子性，结果可以加到 10000。



5、辅助工具

5.1 CoutDownLatch（减法计数器）

团灭了才能越泉：

public class Test {
    public static void main(String[] args) throws InterruptedException {
        int total = 5;
        CountDownLatch countDownLatch = new CountDownLatch(total);

        for (int i = 1; i <= total; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " has been slayed!");
                countDownLatch.countDown();
            }, "t" + i).start();
        }

        countDownLatch.await();

        System.out.println("execute!");
    }
}
5.2 CycliBarrier（加法计数器）

人齐了才能开团：

public class Test {
    public static void main(String[] args) {
        int total = 5;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(total, () -> {
            System.out.println("发起进攻！");
        });

        for (int i = 1; i <= total; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "大招已经好了！");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }, "t" + i).start();
        }
    }
}
5.3 Semaphone（信号量）

只有 4 个 buff：

public class SemaphoreDemo {
    public static void main(String[] args) {
        int total = 10;
        int bufTotal = 2;
        Semaphore semaphore = new Semaphore(bufTotal);

        for (int i = 1; i <= total; i++) {
            new Thread(() -> {
                try {
                    // acquire 得到
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + " got buff");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName() + " lost buff");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // release 释放
                    semaphore.release();
                }
            }, "t" + i).start();
        }
    }
}



6、原子类

3.1 原子整型
public class Test {
    private static AtomicInteger atomicInteger = new AtomicInteger(0);

    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }, "t" + i).start();
        }
        try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }

        System.out.println(atomicInteger.get());
    }

    private static void add() {
        atomicInteger.incrementAndGet();
    }
}



7、并发集合

多线程下使用普通的集合可能会造成并发修改异常（ConcurrentModificationException），需要使用一些同步的集合。

7.1 CopyOnWriteArrayList
public class Test {
    public static void main(String[] args) {
        List<String> list = new CopyOnWriteArrayList<>();
        for (int i = 1; i <= 10; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString());
            }).start();
        }
        
        try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }

        list.forEach(System.out::println);
    }
}
7.2 ConcurrentHashMap
public class Test {
    public static void main(String[] args) {
        Map<String, String> map = new ConcurrentHashMap<>();
        for (int i = 1; i <= 10; i++) {
            final int temp = i;
            new Thread(() -> {
                map.put(String.valueOf(temp), UUID.randomUUID().toString());
            }).start();
        }
        
        try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }

        System.out.println(map);
    }
}



8、锁

8.1 从“问题——解决方案”看各种锁

QUOTE 《java中的各种锁详细介绍》

在这里插入图片描述

8.2 ReentrantLock

使用 ReentrantLock 和 Condition 实现线程的精准通知唤醒：

  • 三个线程分别循环任务 10 次，都按照 ta、tb、tc 的顺序执行。

  • ta 线程精准通知唤醒 tb 线程，tb 线程唤醒 tc 线程，tc 线程 通知唤醒 ta 线程。

资源类

class Data {
    private int       var        = 1;
    private Lock      lock       = new ReentrantLock();
    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();
    private Condition conditionC = lock.newCondition();

    public void printA() {
        lock.lock();
        try {
            // 等待
            while (var != 1) { conditionA.await(); }

            System.out.println(Thread.currentThread().getName() + "  var=" + var);

            var = 2;
            
            // 唤醒
            conditionB.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB() {
        lock.lock();
        try {
            while (var != 2) { conditionB.await(); }
            System.out.println(Thread.currentThread().getName() + "  var=" + var);
            var = 3;
            conditionC.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC() {
        lock.lock();
        try {
            while (var != 3) { conditionC.await(); }
            System.out.println(Thread.currentThread().getName() + "  var=" + var);
            var = 1;
            conditionA.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

main

    public static void main(String[] args) {
        Data data = new Data();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) { data.printA(); }
        }, "ta").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) { data.printB(); }
        }, "tb").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) { data.printC(); }
        }, "tc").start();
    }
}



9、待更新

  • 指令
  • 同步算法
  • 阻塞队列
  • 线程池
十二翼堕落天使
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程如何实现阻塞与唤醒（下）
seaboat——a free boat on the sea.（公众号：远洋号）
10-16 270
跟着作者的65节课彻底搞懂Java并发原理专栏，一步步彻底搞懂Java并发原理。 作者简介：笔名seaboat，擅长工程算法、人工智能算法、自然语言处理、计算机视觉、架构、分布式、高并发、大数据和搜索引擎等方面的技术，大多数编程语言都会使用，但更擅长Java、Python和C++。平时喜欢看书写作、运动、画画。崇尚技术自由，崇尚思想自由。出版书籍：《Tomcat内核设计剖析》、《图解数据结构与算法》、《图解Java并发原理》、《人工智能原理科普》。 wait与notify 上一节说到suspend与.
工作中需要用到的Java知识(JUC锁学习篇)
虚心学习，和气编码
02-06 1308
JUC这部分在工作中我使用的不是很多，但是无可奈何面试经常会问到这些内容，所以今天就来学习一下JUC。 JUC全称为Java.util.concurrent包，是Java的一个工具包，那么为什么JUC是面试经常问的内容呢，因为JUC包括了多线程、原子性、锁等重量级内容，可以用来考察一个程序员对Java技术的了解程度。 1.回顾多线程 面试1：Java可以创建线程么？ 答：不可以，Java创建线程是调用底层的本地native方法，调用C++去创建线程的。 查询电脑CPU核数 package co
Java 并发包(JUC多线程)下面的工具类，在实际工作中都有哪些应用场景呢？
Java后端技术栈
11-09 798
下面可以主要分几类： 1. 线程间通信工具类，如Semaphore ,、CountDownLatch、Future等等，这种也经常用，特别是在写多线程高并发的程序时，结合通信工具和锁把线程编排的符合你的预期执行 2. 锁，JUC提供了各种在某些场景下比synchronized更合适的高级锁实现，包括读写锁，互斥锁等等，因其多数基于CAS这种乐观锁实现，性能一般要由于synchronized内置锁，而且结合Cdondition更灵活可控。 不过个人觉得，这些锁除了jdk以及一些知名框架中使用外，我们日常工
Java volatile详解
杨宇昌的博客
04-21 1677
Java 并发 - volatile详解
JUC基础知识(个人总结)
hellosrc的博客
03-04 8700
    声明: 1. 本文为我的个人复习总结, 并非那种从零基础开始普及知识 内容详细全面, 言辞官方的文章               2. 由于是个人总结, 所以用最精简的话语来写文章            
java工程师必备JUC总结
最新发布
11-27
重点处理高并发问题
Java JUC包 思维导图总结1
03-25
自己学习过程对Java JUC包知识的总结，看完并理解基本能应付各种基本的问题点，墙裂推荐分享 博客跳转链接： https://blog.csdn.net/qq_35642036/article/details/82767070
大数据JUC总结.md
03-17
大数据JUC总结.md
Java并发编程JUC知识点梳理总结
06-01
JUC并发编程知识点梳理思维导图
JUC思维导图.emmx
01-29
个人整理的JUC知识总结
源码解析：JUC及使用场景
yilvi的博客
02-28 1347
本文当用于帮助读者从功能性上理解JUC的功能场景 * 阅读之前请先确定了解集合相关的基础知识 * 一、Collections工具类 该类应用工厂及静态内部类的形式为已有数据结构进行加工，赋予dynamically(checked) 、empty 、immutable(singleton) 、synchronized.所有读写都加对象锁、unmodifiable view(unmodifiable).final修饰对象，写操作throw new UnsupportedOperationException.
juc下常用的五个高并发工具
鱼获飞的博客
03-09 2643
1、CountDownLatch:同步计数器 当CountDownLatch的count计数&gt;0时，await()会造成线程阻塞，当使用countDown()让count-- == 0时，线程结束阻塞。 如果想让其他线程执行完指定程序，其他所有程序都执行结束后再执行，这时可以用CountDownLatch，但计数无法被重置，如果需要重置计数，请考虑使用 CyclicBarrier。下面dem...
JUC深入浅出，第一篇！！！！！
weixin_46455069的博客
09-09 612
1、 什么是JUC 2、线程和进程 3、并发和并行 4、Lock锁（重点） synchronized、传统锁 1、 什么是JUC juc 就是java.util.concurrent java.uti工具包、包、分类 业务：普通的线程代码 Thread Runable 没有返回值、效率相比 Callable 相对较低！ 2、进程和线程: 线程、进程、解释； 进程:—个程序，QQ.exe Music.exe程序的集合; 一个进程往往可以包含多个线程，至少包含—个! Java默认有几
Promise.all 并发限制
左手121
12-24 3249
Promise.all 并发限制 参考链接 简介 Promise.all 可以保证，promises 数组中所有 promise 对象都达到 resolve 状态，才执行 then 回调。 这时候考虑一个场景：如果你的 promises 数组中每个对象都是 http 请求，或者说每个对象包含了复杂的调用处理。而这样的对象有几十万个。 那么会出现的情况是，你在瞬间发出几十万 http 请求（tcp ...
浅层看promise.all异步(并发)执行，和为啥能按序返回
weixin_38291260的博客
07-22 535
直接看一个示例： Promise.all([ new Promise(function(resolve, reject) { resolve(1) }), new Promise(function(resolve, reject) { resolve(2) }), new Promise(function(resolve, reject) { resolve(3) }) ]).then(arr => { console.log(arr) // [
Java关键字volatile全面解析和实例讲解
壹升茉莉清的博客
08-03 726
Java关键字volatile全面解析和实例讲解简介java内存模型JMM介绍——可见性volatile——可见性volatile——不保证原子性volatile——不保证原子性问题解决volatile——指令重排双重锁式单例模式总结 简介 volatile是JVM提供的一种轻量级的同步机制。相比于synchronized关键字volatile更轻量级（乞丐版的synchronized），因为它不会引起线程上下文的切换和调度。但是volatile 变量的同步性较差（有时它更简单并且开销更低），而且其使用也更
深度学习完全攻略！（连载一：GPU加速技术指南）
Aoulun的博客
04-14 1640
本系列文章根据Intel开源GPU加速技术整理而得。 前言 在深度学习大行其道的今天，很少有人再关注底层GPU加速的实现。也许是因为实现起来太复杂，但更多的应该是无法快速编程，实现几亿个求解参数的快速实现，而用python接口只需要几行代码。 不可否认的是，在一些场合，如果想实现GPU的加速，比如图像增强，图像去噪等，那么就必须要DIY一个加速代码。如果不具备这些知识，将很影响效率。或者说，...
什么是Volatile关键字？
qq_24047659的博客
02-28 8785
一、Java的内存模型(JMM) 在仔细讲解Java的volatile关键字之前有必要先了解一下【Java的内存模型】 Java的内存模型简称JMM(Java Memory Model)，是Java虚拟机所定义的一种抽象规范用来屏蔽【不同硬件】和【操作系统】的【内存访问差异】。 让Java程序在各种平台下都能达到一致的内存访问效果。...
JAVA基础篇-多线程一定快吗
随便起个不重复的名字
06-22 1341
下面的代码演示串行和并发执行并累加操作的时间，请分析：下面的代码并发执行一定比串行执行快吗？ package chapter01; //并发和单线程执行测试 public class ConcurrencyTest { /** 执行次数 */ private static final long count=10000l; public static void main(Stri...
Java(各个方面)面试题
08-31
对于Java面试题的总结主要包括ArrayList和LinkedList的区别、JUC（Java Util Concurrent）并发包的相关知识、JVM（Java Virtual Machine）的工作原理、多线程编程的注意事项和常见问题、以及MySQL数据库的使用等内容...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值