JUC基础知识点(一)

已于 2022-04-26 15:47:26 修改
阅读量624 收藏 2
点赞数 2
分类专栏： Java后端 多线程 文章标签： java
于 2022-04-04 21:24:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57469718/article/details/123960831
版权

1、JUC概述

1.1 什么是JUC

在Java中，线程部分是一个重点，本篇文章说的JUC是关于线程的。JUC就是java.util.concurrent工具包的简称。这是一个处理线程的工具包，JDK1.5开始出现的

1.2 线程和进程的概念

  1. 进程(Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。程序是指令、数据及其组织形式的描述，进程是程序的实体。

  2. 线程(thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

  3. 总结：

    1. 进程：指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程——资源分配的最小单位

    2. 线程：系统分配处理器时间资源的基本单元，或者说进程内独立执行的一个单元执行流。线程——程序执行的最小单位

1.3 线程的状态

线程状态枚举类(Thread.State): NEW(新建)、RUNNABLE(准备就绪)、BLOCKED(阻塞)、WAITING(不见不散)、TIMED_WAITING(过时不候)、TERMINATED(终结)

wait和sleep的区别

  1. sleep是Thread的静态方法，wait是Object的方法，任何对象实例都能调用

  2. sleep不会释放锁，它也不需要占用锁。wait会释放锁，但调用它的前提是当前线程占有锁(即代码要在synchronized中)

  3. 它们都可以被interrupted方法中断

并发与并行

  1. 并发：多个线程在访问同一个资源(线程频繁切换)，多个线程对一个点

    1. 例子：春运抢票、电商秒杀，一个医生给多个病人轮流看病

  2. 并行：多项工作一起执行(同时)，之后再汇总

    1. 多个医生同时给病人看病

管程： Monitor监视器 就是我们所说的锁 是一种同步机制，保证同一个时间，只有一个线程访问被保护数据或者代码。JVM同步基于进入和退出，使用管程对象实现的。

用户线程和守护线程

  1. 用户线程：自定义线程 主线程结束了，用户线程还在运行，jvm存活

  2. 守护线程：比如垃圾回收 没有用户线程了，都是守护线程，jvm结束

public class Main {
    public static void main(String[] args){
        Thread aa = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "::" + Thread.currentThread().isDaemon());
            while(true){
                
            }
        }, "aa");
        //设置守护线程(注意要在start()方法之前设置)
        aa.setDaemon(true);
        aa.start();
        System.out.println(Thread.currentThread().getName() + "over");
    }
}
//第一次输出结果 main over aa::false  表示是用户线程
//设置守护线程之后 main over

2、Lock接口

2.1 复习Synchronized

synchronized 是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

  1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象

  2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法作用的对象是调用这个方法的对象

  3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象

  4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主要的对象是这个类的所有对象

2.2 什么是Lock接口

Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的Condition对象

所有已知实现类：ReentrantLock、ReentrantReadWriteLock.ReadLock、ReentrantReadWriteLock.WriteLock

Lock与Synchronized区别：

  1. Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现

  2. synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock()时需要在finally块中释放锁

  3. Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断

  4. 通过Lock可以知道有没有成功获取锁，而synchronized却无法办到

  5. Lock可以提高多个线程进行读操作的效率

  6. Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；

  7. Lock则必须要用户去手动释放锁，如果没有手动释放锁，就有可能出现死锁现象

2.3 创建线程的多种方式

  1. 继承Thread类创建线程

  2. 实现Runnable接口创建线程

  3. 使用Callable和Future创建线程

  4. 使用线程池例如用Executor框架

多线程编程步骤：

  1. 第一步：创建资源类，在资源类创建属性和操作方法(例子：空调)

  2. 第二步：创建多个线程，调用资源类的操作方法

2.4 使用Lock实现卖票例子

//第一步 创建资源类，定义属性和操作方法
class Ticket{
    //票数
    private int number = 30;
    //操作方法：卖票
    public synchronized void sale(){
        //判断：是否有票
        if(number > 0){
            System.out.println(Thread.currentThread().getName()+":卖出:" +(number--)+"剩下:"+number);
        }
    }
}
public class SaleTicket {
    //第二步 创建多个线程，调用资源类的操作方法
    public static void main(String[] args){
        //创建Ticket对象
        Ticket ticket = new Ticket();
        //创建三个线程
        new Thread(new Runnable(){
            @Override
            public void run(){
                //调用卖票方法
                for(int i = 0; i < 40; i++){
                    ticket.sale();
                }
            }
        },"AA").start();
        new Thread(new Runnable(){
            @Override
            public void run(){
                //调用卖票方法
                for(int i = 0; i < 40; i++){
                    ticket.sale();
                }
            }
        },"BB").start();
        new Thread(new Runnable(){
            @Override
            public void run(){
                //调用卖票方法
                for(int i = 0; i < 40; i++){
                    ticket.sale();
                }
            }
        },"CC").start();
    }
}
//第一步 创建资源类，定义属性和操作方法
class LTicket{
    //票数量
    private int number = 30;
    //创建可重入锁
    private final ReentrantLock lock = new ReentrantLock();
    //卖票方法
    public void sale(){
        //上锁
        lock.lock();
        try{
        //判断是否有票
        if(num > 0){
            System.out.println(Thread.currentThread().getName()+":卖出:" +(number--)+"剩余:"+number);
        }
        }finally{
            //解锁
        lock.unlock();
        }       
    }
}
​
public class LSaleTicket(){
    //第二步 创建多个线程，调用资源类的操作方法
    //创建三个线程
    public static void main(String[] args){
        LTicket ticket = new LTicket();
        
        new Thread(() -> {
            for(int i = 0; i < 40; i++){
                ticket.sale();
            }
        }, "AA").start();
        new Thread(() -> {
            for(int i = 0; i < 40; i++){
                ticket.sale();
            }
        }, "BB").start();
        new Thread(() -> {
            for(int i = 0; i < 40; i++){
                ticket.sale();
            }
        }, "CC").start();
    }
}

3、线程间通信

//线程间通信 —— synchronized实现
//第一步 创建资源类，定义属性和操作方法
class Share{
    //初始值
    private int number = 0;
    //+1的方法
    public synchronized void incr() throws InterruptedException{
        //第二步 判断 干活 通知
        while(number != 0){//判断num是否是0，如果不是，等待
            this.wait();//在哪里睡，就会在哪里醒
            //前面判断如果用if就会有虚假唤醒问题
        }
        //如果number值是0，就+1操作
        number++;
        System.out.println(Thread.currentThread().getName()+"::"+number);
        //通知其他线程
        this.notifyAll();
    }
    //-1的方法
    public synchronized void decr(){
        while(number != 1){//判断
            this.wait();
        }
        number--;//干活
         System.out.println(Thread.currentThread().getName()+"::"+number);
        //通知其他线程
        this.notifyAll();
    }
}
//第三步 创建多个线程，调用资源类的操作方法
public class ThreadDemo1{
    public static void main(String[] args){
        Share share = new Share();
        //创建线程
        new Thread(() -> {
            for(int i = 1; i <= 10; i++){
                try{
                    share.incr();//调用+1方法
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
        }, "AA").start();
        new Thread(() -> {
            for(int i = 1; i <= 10; i++){
                try{
                    share.decr();//调用-1方法
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
        }, "BB").start();
        new Thread(() -> {
            for(int i = 1; i <= 10; i++){
                try{
                    share.incr();//调用+1方法
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
        }, "CC").start();
        new Thread(() -> {
            for(int i = 1; i <= 10; i++){
                try{
                    share.decr();//调用-1方法
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
        }, "DD").start();
    }
}
//线程间通信 —— lock实现
//第一步 创建资源类，定义属性和操作方法
class Share {
    private int number = 0;
    //创建Lock
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    
    //+1
    public void incr() throws InterruptedException{
        //上锁
        lock.lock();
        try{
            //判断
            while(num != 0){
                condition.await();
            }
            number++;//干活
            System.out.println(Thread.currentThread().getName()+"::"+number);
            //通知
            condition.signalAll();
        }finally{
            //解锁
            lock.unlock();
        }
    }
    //-1
    public void decr(){
        lock.lock();
        try{
            while(number != 1){
                aondition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"::"+number);
            condition.signalAll();
        }finally{
            lock.unlock();
        }
    }
}
public class ThreadDenm2{
   public static void main(String[] args){
       Share share = new Share();
       new Thread(()->{
           for(int i = 1; i < 10; i++){
               try{
                   share.incr();
               }catch(InterruptedException e){
                   e.printStackTrace();
               }
           }
       }, "AA").start();
       new Thread(()->{
           for(int i = 1; i < 10; i++){
               try{
                   share.decr();
               }catch(InterruptedException e){
                   e.printStackTrace();
               }
           }
       }, "BB").start();
       new Thread(()->{
           for(int i = 1; i < 10; i++){
               try{
                   share.incr();
               }catch(InterruptedException e){
                   e.printStackTrace();
               }
           }
       }, "CC").start();
       new Thread(()->{
           for(int i = 1; i < 10; i++){
               try{
                   share.decr();
               }catch(InterruptedException e){
                   e.printStackTrace();
               }
           }
       }, "DD").start();
   } 
}

4、线程间定制化通信

//线程间定制化通信 —— 通过标志位
//第一步 创建资源类
class ShareResource{
    //定义标志位
    private int flag = 1;//1 AA  2 BB  3 CC
    //创建Lock锁
    private lock lock = new ReentrantLock();
    
    //创建三个condition
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();
    
    //打印5次，参数第几轮
    public void print5(int loop){
        //上锁
        lock.lock();
        try{
            //判断
            while(flag != 1){
                //等待
                c1.await();
            }
            for(int i = 1; i <= 5; i++){//干活
                System.out.println(Thread.currentThread().getName()+"::"+" : 轮数 :"+loop)
            }
            flag = 2;//修改标志位2
            c2.signal();//通知
        }finally{
            //释放锁
            lock.unlock();
        }
    }
    //打印10次，参数第几轮
    public void print15(int loop){
        //上锁
        lock.lock();
        try{
            //判断
            while(flag != 2){
                //等待
                c2.await();
            }
            for(int i = 1; i <= 5; i++){//干活
                System.out.println(Thread.currentThread().getName()+"::"+" : 轮数 :"+loop)
            }
            flag = 3;//修改标志位2
            c2.signal();//通知
        }finally{
            //释放锁
            lock.unlock();
        }
    }
    //打印15次，参数第几轮
    public void print15(int loop){
        //上锁
        lock.lock();
        try{
            //判断
            while(flag != 3){
                //等待
                c3.await();
            }
            for(int i = 1; i <= 5; i++){//干活
                System.out.println(Thread.currentThread().getName()+"::"+" : 轮数 :"+loop)
            }
            flag = 1;//修改标志位2
            c3.signal();//通知
        }finally{
            //释放锁
            lock.unlock();
        }
    }
}
public class ThreadDemo3{
    ShareResource shareResource = new ShareResource();
    new Thread(() -> {
       for(int i = 1; i <= 10; i++){
           try{
               shareRource.print5(i);
           } catch (InterruptedException e){
               e.printStackTrace();
           }
       }
    },"AA").start();
    new Thread(() -> {
       for(int i = 1; i <= 10; i++){
           try{
               shareRource.print10(i);
           } catch (InterruptedException e){
               e.printStackTrace();
           }
       }
    },"BB").start();
    new Thread(() -> {
       for(int i = 1; i <= 10; i++){
           try{
               shareRource.print15(i);
           } catch (InterruptedException e){
               e.printStackTrace();
           }
       }
    },"CC").start();
}

5、集合的线程安全

5.1 集合线程不安全演示

//list集合线程不安全
public class ThreadDemo4{
    public static void main(String[] args){
        //创建ArrayList集合
        List<String> list = new ArrayList<>();
        for(int i = 1; i <= 30; i++){
            new Thread(() -> {
                //向集合添加内容
                list.add(UUID.randomUUID().toString().substring(0, 8));
                //从集合中获取内容
                System.out.print(list);
            }, String.valueOf(i)).start();
        }
    }
}

解决方案-Vector

将List<String> list = new ArrayList<>();

改成
List<String> list = new Vector();即可   （很古老的方案——不常用）

解决方案-Collections

List<String> list = Collections.synchronizedList(new ArrayList());

解决方案-CopyOnWriteArrayList ——常用

List<String> list = new CopyOnWriteArrayList<>();

写时复制技术，读的时候支持并发读，写是独立写，写之前先复制内容，在新的地址写入新的内容之后合并，后面再读取新的内容 —— 例如签到

首先将当前容器复制一份，然后在新副本上执行写操作，结束之后再将原容器的引用指向新容器

5.2 HashSet线程不安全

public class ThreadDemo4{
    public static void main(String[] args){
        //创建HashSet集合
        //Set<String> set = new HashSet<>();
        //解决方案
        Set<String> set = new CopyOnWriteArraySet<>();
        for(int i = 1; i <= 30; i++){
            new Thread(() -> {
                //向集合添加内容
                set.add(UUID.randomUUID().toString().substring(0, 8));
                //从集合中获取内容
                System.out.print(set);
            }, String.valueOf(i)).start();
        }
    }
}

5.3 HashMap线程不安全

public class ThreadDemo4{
    public static void main(String[] args){
        //Map<String, String> map = new HashMap<>();
        Map<String, String> map = new ConcurrentHashMap<>();
        for(int i = 1; i <= 30; i++){
            new Thread(() -> {
                //向集合添加内容
                map.put(key,UUID.randomUUID().toString().substring(0, 8));
                //从集合中获取内容
                System.out.print(map);
            }, String.valueOf(i)).start();
        }
    }
}

慢慢敲吧
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AQS和JUC知识点讲解
05-23
《AQS和JUC知识点详解》 在Java并发编程领域，AbstractQueuedSynchronizer（AQS）和Java Util Concurrency（JUC）是两个至关重要的概念。它们为开发高效、线程安全的多线程程序提供了强大的工具。本文将深入解析这...
【JUC基础学习笔记】
sixteen_16的博客
03-24 2919
JUC基础学习笔记一、JUC概述1. JUC是什么2. 进程与线程3. 并发与并行4. sleep() 和 wait()等方法二、Lock1. Synchronized2. Lock接口与方法3. 两者异同4. Lock接口重要实现类三、线程通信 / 线程同步1. Synchronized同步块2. Lock锁四、线程安全1. 阻塞同步2. 非阻塞同步3. 非同步五、集合的线程安全1. 并发集合 ArrayList2. Vector3. Collections4. JUC.CopyOnWriteList..
工作中需要用到的Java知识(JUC锁学习篇)
虚心学习，和气编码
02-06 1309
JUC这部分在工作中我使用的不是很多，但是无可奈何面试经常会问到这些内容，所以今天就来学习一下JUC。 JUC全称为Java.util.concurrent包，是Java的一个工具包，那么为什么JUC是面试经常问的内容呢，因为JUC包括了多线程、原子性、锁等重量级内容，可以用来考察一个程序员对Java技术的了解程度。 1.回顾多线程 面试1：Java可以创建线程么？ 答：不可以，Java创建线程是调用底层的本地native方法，调用C++去创建线程的。 查询电脑CPU核数 package co
JUC(5): 各种锁重点汇总
BaiHang111的博客
07-08 514
各种锁重点汇总：公平锁、自旋锁、死锁、乐观悲观锁、锁升级、锁粗化、读写锁、锁降级、邮戳锁
JUC基础知识(个人总结)
hellosrc的博客
03-04 8709
    声明: 1. 本文为我的个人复习总结, 并非那种从零基础开始普及知识 内容详细全面, 言辞官方的文章               2. 由于是个人总结, 所以用最精简的话语来写文章            
JUC 知识点
weixin_44311939的博客
06-28 311
写在前面 本文在学习JUC过程中，自己总结的一份JUC知识点，涵盖知识点，代码Demo 源码 GITHUB 地址：源码地址 将会持续更新 如果有什么地方总结的不完善或出现错误，欢迎留言补充和改正，共同进步！ JUC目录写在前面JUC 基础1. 什么是线程和进程？举例说明2. 线程的状态有哪些？3. wait 和 sleep 的区别？4. 什么是并发，什么是并行？5. JUC 常见异常JUC Lock接口1. Lock 和 Synchronized 区别在哪？2. 经典买票问题JUC 线程间通信1. .
Thread基础知识点笔记总结
10-18
Thread 基础知识点笔记总结 Thread 是 Java 中最基本的并发编程单元，用于实现多线程编程。下面是 Thread 基础知识点的笔记总结： 1. Volatile Volatile 是 Java 中的一种轻量级同步机制，用于保证可见性。在多...
【学习笔记】JUC基础基础程序
02-24
本学习笔记将深入探讨JUC的基础知识，帮助你理解和掌握Java并发编程的核心概念。 在Java中，多线程是实现并发的主要方式。一个线程是程序执行的一个流，多线程则意味着一个程序内可以同时执行多个线程。Java提供了...
redis、activemq、juc、jvm、gc等知识点的脑图.rar
05-04
JVM（Java Virtual Machine）是Java程序运行的基础，它负责解析字节码并执行。JVM的内存模型包括堆、栈、方法区、程序计数器和本地方法栈。其中，堆内存存放对象实例，栈内存处理方法调用。垃圾回收（GC）是JVM自动...
个人学习-JUC-笔记
最新发布
02-25
通过尚硅谷周阳老师的JUC课程，我们可以系统地学习这些知识点，并通过实践提升自己的并发编程能力，为解决复杂的并发问题打下坚实基础。在实际开发中，合理利用JUC工具可以显著提高程序的并发性能和可维护性。
Java JUC包 思维导图总结1
03-25
自己学习过程对Java JUC包知识的总结，看完并理解基本能应付各种基本的问题点，墙裂推荐分享 博客跳转链接： https://blog.csdn.net/qq_35642036/article/details/82767070
常见的Java笔试题-JVM-JUC-Core:JUCJVM核心知识点
06-02
常见的Java笔试题 JUC、JMM核心知识点笔记 尚硅谷周阳老师课程——笔记。 / / JUC知识点 JMM volatile关键字 可见性 原子性 有序性 哪些地方用到过volatile？ 单例模式的安全问题 CAS CAS底层原理 CAS缺点 ABA问题 AtomicReference AtomicStampedReference和ABA问题的解决 集合类不安全问题 List CopyOnWriteArrayList Set HashSet和HashMap Map Java锁 公平锁/非公平锁 可重入锁/递归锁 锁的配对 自旋锁 读写锁/独占/共享锁 Synchronized和Lock的区别 CountDownLatch/CyclicBarrier/Semaphore CountDownLatch 枚举类的使用 CyclicBarrier Semaphore 阻塞队列 SynchronousQueue Callable接口 阻塞队列的应用——生产者消费者 传统模式 阻塞队列模式 阻塞队列的应用——线程池 线程池基本概念 线程池三种常用创建方式 线程池创建的七个参数 线程池底层原理
JUC知识点汇总
weixin_42610002的博客
03-08 653
JUC汇总总结： 总结： 通常说的并发包即java.util.concurrent及其子包，集中了Java并发的各种基础工具类，具体： 提供了比Synchronized更高级的各种同步结构：CountDownLatch、CyclicBarrier、Semaphore等，可实现更丰富的多线程操作，例如用Semaphore作为资源控制器，限制同时工作的线程数量。 JUC之各种同步结构(Semapho...
JUC 重点总结
che_j的博客
10-20 260
目录WWH？？？JUC概述1.进程与线程2.并发与并行3.线程的6种状态4.管程5.用户线程和守护线程Lock 接线程间通信线程间定制化通信集合的线程安全多线程锁Callable 接口JUC 三大辅助类ReentrantReadWriteLock读写锁BlockingQueue阻塞队列ThreadPool 线程池Fork/Join 分支合并框架CompletableFuture 异步回调 WWH？？？ JUC是什么？ 为什么要用？ 学了会怎么样？ JUC概述 在Java中，线程部分是一个重点。 JUC就是
实现线程的四种方式
qq_41854180的博客
09-17 387
进程 进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能 线程 线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序 程序 程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。 主线程 jvm启动后，必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束，这个线程在java中称之为主线程。
Java JUC之Atomic系列12大类实例讲解和原理分解
iteye_14356的博客
02-20 232
在java6以后我们不但接触到了Lock相关的锁，也接触到了很多更加乐观的原子修改操作，也就是在修改时我们只需要保证它的那个瞬间是安全的即可，经过相应的包装后可以再处理对象的并发修改，以及并发中的ABA问题，本文讲述Atomic系列的类的实现以及使用方法，其中包含： 基本类：AtomicInteger、AtomicLong、AtomicBoolean； 引用类型：AtomicReference...
JUC知识点总结
Novice_guy的博客
03-26 353
JUC juc->java.util.concurrent:并发编程中的工具类 三个包：concurrent，atomic，locks 进程和线程 进程：后台运行的一个程序，是操作系统分配资源的基本单位 线程：进程内部使用进程分配到的资源的，实现的某些功能，就是线程。 并发和并行 并发：而并发是指两个或多个事件在同一时间间隔发生。 并行：并行是指两个或者多个事件在同一时刻发生。 ...
阻塞队列（BlockingQueue）图解，以及实现类的简述
qq_40823802的博客
08-03 1001
阻塞队列：顾名思义，首先他是一个队列，而一个阻塞队列在数据结构中所起的作用大致如图所示 相当于“生产者和消费者问题”。 当阻塞队列是空时：从队列中获取元素的操作将会被阻塞。 当阻塞队列是满时：往队列里添加元素的操作将会被阻塞。 试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他线程往空队列插入新的元素。同样， 试图往已满的阻塞队列添加新元素的线程同样也会被阻塞，直到其他的线程从列中移除一个或多...
【Java之多线程】JUC常见知识点全面总结
沐北的博客
10-18 1886
JUC全称为import java.util.concurrent，其中，concurrent这个包里包含了很多和多线程并发相关的操作，同样也是面试中的高频考点，下面博主就带大家学习学习这部分内容吧！ JUC一. ReentrantLock（1）理解（2）用法（3）区别（3）总结二级目录三级目录 一. ReentrantLock （1）理解 之前我们讨论的可重入锁，翻译成英文就是ReentrantLock，大部分情况下这个英文单词要理解成这一锁特性，但少数情况下要理解成一个类 和和 synchron.
2023java面试宝典
02-16
"这是一份2023年的Java面试准备指南，涵盖了广泛的Java相关面试主题，包括基础、JVM、MySQL、SpringBoot、SpringCloud、算法和框架等。提供了多个专题链接，针对不同领域的面试题进行深入讲解，并且持续更新，旨在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值