JUC详解（各种乱七八糟的锁）

已于 2022-04-13 17:37:36 修改
阅读量2.5k 收藏 14
点赞数
分类专栏： 基础学习 文章标签： java 开发语言 后端
于 2022-02-19 16:22:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qdyones/article/details/122816400
版权
本文详细介绍了Java并发编程中的JUC（Java Util Concurrency）库，包括Lock锁、并发集合（如CopyOnWriteArrayList、ConcurrentHashMap）、线程计数器（CyclicBarrier、CountDownLatch）、线程池（ThreadPoolExecutor）以及并发问题解决方案，如死锁排查。还探讨了Volatile的可见性、非原子性以及避免指令重排，以及CAS和ABA问题。
摘要由CSDN通过智能技术生成

文章目录

1JUC

在这里插入图片描述

2回顾多线程知识

进程和线程：
进程：一个进程可以包含多个线程，至少是一个线程，java默认2个线程——main、GC（垃圾回收）
线程：开了一个软件，写字的时候也会有自动保存的线程在进行，Thread、Runnable、Callable
java开启不了线程，java操作的是底层的C++，java无法操作，用的是虚拟机
并发与并行：
并发：多线程操作同一个资源（假设cpu只有一核的时候，模拟多线程，快速交替处理线程）
并行：CPU多核情况下才有，多个线程同时执行

并发编程的本质：充分利用电脑的CPU
线程有几种状态：6种：new(创建)、runnable（运行）、blocked（阻塞）、wait（等待）、timed_waiting（超时等待）
terminated（终止）

wait与sleep的区别：
1.来自不同的类——wait（Object）、sleep（Thread）
2.关于锁——wait会释放锁，而sleep不会释放
3.适用范围不一样——wait必须在同步代码块中执行，sleep则不用
4.w捕获异常——wait不需要捕获异常、sleep需要捕获异常

3Lock锁（重点）

传统Synchronized解决有顺序卖票问题

package JUC;
/*基本的卖票的例子
线程是一个单独的资源类
* */
public class Demo02SaleTicket {
   
    public static void main(String[] args) {
   
        Ticket ticket = new Ticket();

        new Thread(()->{
   
            for (int i = 0; i < 60; i++) {
   
                ticket.sale();
            }

        },"A").start();
        new Thread(()->{
   
            for (int i = 0; i < 60; i++) {
   
                ticket.sale();
            }

        },"B").start();
        new Thread(()->{
   
            for (int i = 0; i < 60; i++) {
   
                ticket.sale();
            }
        },"C").start();
    }
}

class Ticket{
   
    private int num=30;
    public synchronized void sale(){
   
        if (num>0){
   
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(num--)+"票，剩余"+num);
        }
    }
}

4Lock锁

package JUC;

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

public class Demo03Lock {
   
    public static void main(String[] args) {
   
        Ticket1 ticket1 = new Ticket1();

    }
}

//Lock锁————三步骤——1.new ReentrantLock 2.加锁 3.解锁
class Ticket1{
   
    private int num=30;
    //ReentrantLock---java默认非公平锁，也就是默认可以插队（比较合理，3秒的不需要等待3小时的线程）
    Lock lock=new ReentrantLock();
    public void sale(){
   
        lock.lock();//加锁
        try {
   
            //业务代码
            if (num>0){
   
                System.out.println(Thread.currentThread().getName()+"卖出了第"+(num--)+"票，剩余"+num);
            }
        } catch (Exception e) {
   
            e.printStackTrace();
        }finally {
   
            lock.unlock();//解锁
        }


    }

}

5JUC版的生产者与消费者问题(虚假唤醒)

package JUC;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*JUC版的生产者与消费者问题
通过Lock可以找到Condition
以下的是无序的随机的状态结果，JUC的优势还没有体现出来
ReentrantLock是可重入的意思
* */
public class Demo05JUC1 {
   
    public static void main(String[] args) {
   
        Date1 date1 = new Date1();

        new Thread(()->{
   for (int i = 0; i < 10; i++) {
   
            try {
   
                date1.increment();
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        }
        },"A").start();
        new Thread(()->{
   for (int i = 0; i < 10; i++) {
   
            try {
   
                date1.decrement();
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        }
        },"B").start();
        new Thread(()->{
   for (int i = 0; i < 10; i++) {
   
            try {
   
                date1.increment();
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        }
        },"C").start();
        new Thread(()->{
   for (int i = 0; i < 10; i++) {
   
            try {
   
                date1.decrement();
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        }
        },"D").start();
    }


}
class Date1{
   
    private int num=0;
    Lock lock=new ReentrantLock();
    Condition condition = lock.newCondition();


    public  void increment() throws InterruptedException {
   
        lock.lock();
        try {
   
            while (num!=0){
   
                //等待
                //this.wait();JUC之前普通的
                condition.await();
            }
                num++;
                System.out.println(Thread.currentThread().getName()+"=="+num);
                //通知线程B，我+1完毕了this.notifyAll();JUC之前普通的
                condition.signalAll();//唤醒全部

        } catch (InterruptedException e) {
   
            e.printStackTrace();
        } finally {
   
            lock.unlock();
        }

    }


    public  void decrement() throws InterruptedException {
   
        lock.lock();
        try {
   
            while (num==0){
   
                //等待
                //this.wait();
                condition.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName()+"=="+num);
            //通知线程B，我-1完毕了 JUC之前的this.notifyAll();
            condition.signalAll();//唤醒全部
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        } finally {
   
            lock.unlock();
        }
    }
}

6有序线程

package JUC;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*实现生产者与消费者的有序JUC执行
三条线程按照循环顺序执行
* */
public class Demo06JUC2 {
   
    public static void main(String[] args) {
   
        new Thread(()->{
   },"A").start();
        new Thread(()->{
   },"B").start();
        new Thread(()->{
   },"C").start();

    }
}

//资源类
class Date3{
   
    private Lock lock=new ReentrantLock();
    private Condition condition = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int num=1;

    public void print1(){
   
        lock.lock();
        try {
   //业务代码，判断-执行-通知
        if (num!=1){
   
            condition.await();
        }
        System.out.println(Thread.currentThread().getName()+"1111");
        //通知唤醒
            num=2;
            condition2.signal();
        } catch (Exception e) {
   
            e.printStackTrace();
        } finally {
   
            lock.unlock();
        }
    }
    public void print2(){
   
        lock.lock();
        try {
   
            if (num!=2){
   
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"2222");
            num=3;
            condition3.signal();
        } catch (Exception e) {
   
            e.printStackTrace();
        } finally {
   
            lock.unlock();
        }
    }
    public void print3(){
   
        lock.lock();
        try {
   
            if (num!=3){
   
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"3333");

            num=1;
            condition.signal();
        } catch (Exception e) {
   
            e.printStackTrace();
        } finally {
   
            lock.unlock();
        }
    }
}

7八锁问题

package JUC;

import java.util.concurrent.TimeUnit;

/*什么是锁，锁的对象是谁——查看自己的收藏笔记
8锁，就是关于锁的8个问题
1.标准情况下，线程先执行哪个？————先发短信再打电话（原因：锁的存在）
2.发短信延迟4秒的情况下————还是先短信再电话，先执行发短信，因为有同步锁
3.增加了一个普通方法后，是执行发短信还是hello，限制性普通方法，普通方法不受锁的限制
4.两个对象的情况下，先执行发短信还是打电话——————打电话，因为两把锁不一样，打电话的锁有延迟
5.静态方法的时候，两个线程先执行哪个？——————加了static以后锁的就是class对象，类的模板只有一个所以和原先锁的是对象没有关系

* */
public class Demo07suo1 {
   
    public static void main(String[] args) {
   
        Phone phone = new Phone();
        Phone phone1 = new Phone();
        //第一条线程
        new Thread(()->{
   
            phone.send();
        },"A").start(
最低0.47元/天 解锁文章
qdyones
关注
专栏目录
Java——聊聊JUC中的锁（synchronized & Lock & ReentrantLock）
java_lujj的博客
09-12 382
这篇文章是关于锁的，是入门级别的文章，后续还会有更深入、更底层的JUC，我会慢慢更新的。。。
JUC锁详解
qq_63353796的博客
07-11 1032
JUC锁详解
JUC全面解析-一文带你掌握JUC
最新发布
weixin_67796933的博客
09-19 1305
本文深入解析了Java并发工具包（JUC）的核心概念和实践应用。从线程池的创建与管理到原子操作类，再到锁机制和并发集合的使用，每个部分都通过详实的讲解帮助读者全面掌握JUC的关键知识点。我们将通过对CAS机制、AQS（抽象队列同步器）、各种同步工具（如CountDownLatch、CyclicBarrier、Semaphore）、ForkJoin框架等的讲解
juc详解
csvbdd的博客
07-21 996
juc并发包的详解
java juc_JUC
weixin_39934085的博客
02-12 175
前言：在Java中，线程部分是一个重点，本篇文章说的JUC也是关于线程的。JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包，JDK 1.5开始出现的。下面一起来看看它怎么使用。欢迎大家关注我的公众号 javawebkf，目前正在慢慢地将简书文章搬到公众号，以后简书和公众号文章将同步更新，且简书上的付费文章在公众号上将免费。一、volatile关键字与内存可...
JUC详解
weixin_30699235的博客
12-02 329
一、Java多线程 -- JUC包源码分析1 -- CAS/乐观锁 　　乐观锁其实就是不加锁，用CAS + 循环重试，实现多个线程/多个客户端，并发修改数据的问题 　　使用AtomicStampedReference类下的 　　public boolean compareAndSet(V expectedReference, //旧值 V newReference, //新值 int ex...
juc之基本概念详解分析
幻想波普星
09-08 600
基本概念 中断 boolean interrupted() 返回当前调用线程，不是调用该方法的实例对象是否中断，若是中断，清除中断标志位 boolean isinterrupted() 返回调用线程是否中断**，若是中断，恢复中断标志位** void interupt() 将调用线程中断标志为true public static boolean interrupted() { ...
JUC详解 | JUC概述
蕤荥的成长博客
11-01 5891
JUC就是在 Java 5.0 提供了 `java.util.concurrent`(简称JUC)包，在此包中增加了在并发编程中很常用的工具类。此包包括了几个小的、已标准化的可扩展框架，并提供一些功能实用的类，没有这些类，一些功能会很难实现或实现起来冗长乏味。
JUC AQS的加解锁.pdf
02-25
Java的并发编程是多线程和多任务处理的核心技术之一，而在Java并...开发者可以基于AQS创建复杂的同步结构，满足各种并发场景的需求。理解AQS的工作原理，对于使用Java并发包以及开发高性能的多线程应用具有重要的意义。
JUC详解1
qq_41510551的博客
10-23 500
JUC详解 JUC：java.util.concurrent 线程和进程 1、进程是指的一个程序，如一个qq.exe、IDEA.exe等 2、线程指打开一个进程后，如qq可打字发消息，这就是线程 一个进程往往含有多个线程（最少一个） java默认含有2个线程：main、GC java的三种开线程的方式：Thread、Runable、Callable 并发、并行 并发：多个线程操作同一个自由 CPU一核：通过模拟多个线程，交替进行 并行：多个线程同时执行 CPU多核：多个线程同时执行 //查询自己电脑
Java多线程深入-----JUC详解
Zero摄氏度的博客
03-22 785
多线程进阶----JUC并发编程详解 1、什么是JUC 1、java.util工具包、包、分类 业务：普通的线程代码 Thread Runnable：没有返回值，效率相比Callable相对较低 2、线程和进程 1、进程：一个程序，程序的集合； 一个进程往往可以包含多个线程，至少包含一个 Java默认有2个线程：main、GC 2、线程：开了一个进程（Typora），写字、自动保存（线程负责） 对于Java而言，开启线程的三种方式：Thread、Runnable、Callable Java无法开启线
JUC之各种锁
Y_Ace的博客
04-15 630
公平锁和非公平锁 回头看一下之前的一个多线程买票案例 public class LockSaleTicket { public static void main(String[] args) { LockTicket lockTicket = new LockTicket(); new Thread(()->{ for (int i = 0; i < 20; i++) { lockTicket.sal
JUC相关知识详解
prefect_start的博客
04-06 555
JUC和JVM相关 1、JMM （java 内存模型） 1.1、什么是JMM？ ​ JMM 本身是一种抽象的概念并不真实存在,它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式 1.2、JMM关于同步的规定： 线程解锁前，必须把共享变量的值刷新回主内存 线程加锁前，必须读取主内存的最新值到自己的工作内存 加锁解锁是同一把锁 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jjPZhKaS-16177039571
JUC中的锁
独行侠的守望の博客
07-26 196
★、不同角度的锁的理解： #1、公平锁、非公平锁 　　公平锁：eg: ReentrantLock 　　　　关键词：先来先服务。 加锁前检查是否有排队等锁的线程，若有，当前线程参与排队，先排的线程优先获取锁。相对没有 非公平锁 效率高。　　 　　非公平锁：eg：Synchronized ReentrantLock 　　　　与公平锁相反，不考虑排队问题，一旦资源释放，不考虑线程先来还...
JUC 第1章JUC简介
尚硅谷铁杆粉丝的博客
06-28 1486
JUC简介 是什么 java.util.concurrent在并发编程中使用的工具类 2.进程/线程回顾 2.1进程/线程 进程：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。 线程：通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有...
JUC详解 | JUC Lock
蕤荥的成长博客
11-03 485
锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。它们允许更灵活的结构，可能具有非常不同的属性，并且可能支持多个关联的条件对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值