初识JUC——day01&&lock接口&&线程间通信

已于 2022-03-01 12:26:34 修改
阅读量227 收藏
点赞数
分类专栏： # JUC 文章标签： java 开发语言 后端
于 2022-02-18 17:31:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45483328/article/details/123008050
版权

文章目录

1. JUC简介

JUC是java.unti.concurrent包的简称，在Java中是处理线程的工具包，JDK1.5出现。

1.1 进程与线程

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

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

我们打开的QQ，他就是一个进程，但是QQ存在多个组件共同工作，我们可以理解为一个个的线程

总结来说:

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

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

1.2 线程的状态

public enum State {
        NEW,//新建
        RUNNABLE, //准备就绪
        BLOCKED, //阻塞
        WAITING, //等待,死等
        TIMED_WAITING, //定时等待，过时不候
        TERMINATED;//终结
    }

1.3 wait/sleep的区别

  • sleep 是 Thread 的静态方法，wait 是 Object 的方法，任何对象实例都能调用。
  • sleep 不会释放锁，它也不需要占用锁。wait 会释放锁，但调用它的前提是当前线程占有锁(即代码要在 synchronized 中)。
  • 它们都可以被 interrupted 方法中断。

1.4并发与并行

  • 串行模式：所有任务都一一按先后顺序进行。
  • 并发模式：交替做不同事的能力（不同代码块交替执行）
  • 并行模式：同时做不同事的能力（不同代码块同时执行）

2. Lock接口

2.1 Synchronized

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

  1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{} 括起来的代码，作用的对象是调用这个代码块的对象；
  2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用 的对象是调用这个方法的对象；
    • 虽然可以使用 synchronized 来定义方法，但 synchronized 并不属于方法定 义的一部分，因此，synchronized 关键字不能被继承。如果在父类中的某个方 法使用了 synchronized 关键字，而在子类中覆盖了这个方法，在子类中的这 个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上 synchronized 关键字才可以。当然，还可以在子类方法中调用父类中相应的方 法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此， 子类的方法也就相当于同步了。
  1. 修饰一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象

结合synchronized多线程的编程步骤主要是：（高内聚低耦合）

1.创建资源类，在资源类中定义属性和操作方法

class Ticket {
    private int number = 30;

    synchronized void sale() throws InterruptedException { //在这里直接抛出的原因是，单个线程出现的问题自己去处理，不要影响后面的任务
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出1，还剩" + --number);
            wait(100);
        }
    }
}

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

public static void main(String[] args) {
    Ticket ticket = new Ticket();

    for (int i = 0; i < 3; i++) {
        new Thread(()->{
            for (int i1 = 0; i1 < 40; i1++) {
                try {
                    ticket.sale();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, String.valueOf(i)).start();
    }
}

2.2 Lock接口

那既然有了synchronized关键词，为啥需要lock呢？

  • Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；
  • Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

synchronized的局限性与lock的优点

如果一个代码块被synchronized关键字修饰，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待直至占有锁的线程释放锁。事实上，占有锁的线程释放锁一般会是以下三种情况之一：

  1. 占有锁的线程执行完了该代码块，然后释放对锁的占有；
  2. 占有锁线程执行发生异常，此时JVM会让线程自动释放锁；
  3. 占有锁线程进入 WAITING 状态从而释放锁，例如在该线程中调用wait()方法等。

试考虑这三种情况：

  1. 在使用synchronized关键字的情形下，假如占有锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，那么其他线程就只能一直等待，别无他法。这会极大影响程序执行效率。因此，就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间 (解决方案：tryLock(long time, TimeUnit unit)) 或者 能够响应中断 (解决方案：lockInterruptibly())），这种情况可以通过 Lock 解决。
  2. 我们知道，当多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作也会发生冲突现象，但是读操作和读操作不会发生冲突现象。但是如果采用synchronized关键字实现同步的话，就会导致一个问题，即当多个线程都只是进行读操作时，也只有一个线程在可以进行读操作，其他线程只能等待锁的释放而无法进行读操作。因此，需要一种机制来使得当多个线程都只是进行读操作时，线程之间不会发生冲突。同样地，Lock也可以解决这种情况 (解决方案：ReentrantReadWriteLock) 。
  3. 我们可以通过Lock得知线程有没有成功获取到锁 (解决方案：ReentrantLock) ，但这个是synchronized无法办到的。

上面提到的三种情形，我们都可以通过Lock来解决，但synchronized 关键字却无能为力。事实上，Lock 是 java.util.concurrent.locks包下的接口，Lock 实现提供了比 synchronized 关键字 更广泛的锁操作，它能以更优雅的方式处理线程同步问题。也就是说，Lock提供了比synchronized更多的功能。

lock的编程步骤与synchronized 相同

//第一步  创建资源类，定义属性和和操作方法
class LTicket {
    private int number = 30;

    private final ReentrantLock lock = new ReentrantLock(); //创建可重入锁

    void sale() throws InterruptedException {
        lock.lock();//上锁

        try {
            //条件判断
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出1，还剩" + --number);
                TimeUnit.SECONDS.sleep(1);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); //解锁,需要放在try--finally块中
        }
    }
}
public class LSaleTicket {
    //第二步 创建多个线程，调用资源类的操作方法
    public static void main(String[] args) {
        LTicket lTicket = new LTicket();
        for (int i = 0; i < 3; i++) {
            new Thread(()-> {
                for (int i1 = 0; i1 < 40; i1++) {
                    try {
                        lTicket.sale();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, i + "").start();
        }
    }
}

2.3 Lock方法

// 获取锁  
void lock()   

// 如果当前线程未被中断，则获取锁，可以响应中断  
void lockInterruptibly()   

// 返回绑定到此 Lock 实例的新 Condition 实例  
Condition newCondition()   

// 仅在调用时锁为空闲状态才获取该锁，可以响应中断  
boolean tryLock()   

// 如果锁在给定的等待时间内空闲，并且当前线程未被中断，则获取锁 
boolean tryLock(long time, TimeUnit unit)   

// 释放锁  
void unlock()

lock()、tryLock()、tryLock(long time, TimeUnit unit) 和 lockInterruptibly()都是用来获取锁的。unLock()方法是用来释放锁的。newCondition() 返回 绑定到此 Lock 的新的 Condition 实例 ，用于线程间的协作

  1. lock()

    如果锁被其他线程获取，则必须等待

    发生异常不会主动释放锁，需要放在try…catch块中使用.

    lock.lock();
try{
	//处理任务
}catch(Exception e){
}finally{
	lock.unlock(); //释放锁
}

  2. tryLock() & tryLock(long time, TimeUnit unit)

    tryLock()有返回值,作用是尝试获取锁,获取成功返回true,否则返回false.

    tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false，同时可以响应中断。如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。

    if(lock.tryLock()) {
     try{
         //处理任务
     }catch(Exception ex){

     }finally{
         lock.unlock();   //释放锁
     } 
}else {
    //如果不能获取锁，则直接做其他事情
}

  3. lockInterruptibly()

    lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够 响应中断，即中断线程的等待状态。例如，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。

    由于lockInterruptibly()的声明中抛出了异常，所以lock.lockInterruptibly()必须放在try块中或者在调用lockInterruptibly()的方法外声明抛出 InterruptedException，但推荐使用后者.

    public void method() throws InterruptedException {
    lock.lockInterruptibly();
    try {  
        //.....
    }
    finally {
        lock.unlock();
    }  
}

    注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的。因为interrupt()方法只能中断阻塞过程中的线程而不能中断正在运行过程中的线程。因此，当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，那么只有进行等待的情况下，才可以响应中断的。与 synchronized 相比，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。

  4. newCondition() 获得Condition对象.

    Condition 是一个多线程协调通信的工具类，可以让某些线程一起等待某个条件（condition），只有满足条件时，线程才会被唤醒.Condition常用的两个方法:

    • await()会使当前线程等待,同时会释放锁,当其他线程调用 signal()时,线程会重新获得锁并继续执行
    • signal()用于唤醒一个等待的线程

    注意：在调用 Condition 的 await()/signal()方法前，也需要线程持有相关 的 Lock 锁，调用 await()后线程会释放这个锁，在 singal()调用后会从当前 Condition 对象的等待队列中，唤醒 一个线程，唤醒的线程尝试获得锁， 一旦 获得锁成功就继续执行。

2.4 ReentrantLock

ReentrantLock,可重入锁,是唯一实现了Lock接口的类,并且提供了更多的方法.

简单解释:A线程和B线程同时对资源加锁，A线程获取锁之后，B线程只好等待，直到A线程释放锁B线程才获得锁。

2.5 ReadWriteLock

ReadWriteLock 接口只有两个方法：

Lock readLock()   //返回用于读取操作的锁  
Lock writeLock() //返回用于写入操作的锁

ReadWriteLock 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有 writer，读取锁可以由多个 reader 线程同时保持，而写入锁是独占的。

假设有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁，反之同理

2.6 比较synchronized和lock

  • synchronized是java关键字，内置，而lock不是内置，是一个类，可以实现同步访问且比synchronized中的方法更加丰富
  • synchronized不会手动释放锁，而lock需手动释放锁（不解锁会出现死锁，需要在 finally 块中释放锁）
  • lock等待锁的线程会相应中断，而synchronized不会相应，只会一直等待
  • 通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到
  • Lock 可以提高多个线程进行读操作的效率（当多个线程竞争的时候）

3.线程间通信

线程间通信的模型有两种：共享内存和消息传递.

线程间同学的具体步骤:

1.创建资源类,在资源类中定义属性和方法

2.在资源类操作方法中:判断 ,操作, 通知

3.创建多个线程,调用资源类的操作问题

4.防止虚拟唤醒

题目:两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1,要求用线程间通信

3.1 使用synchronized

package com.shang.sync;
//1.创建资源类
class Share{
    private int number = 0;

    public synchronized void add() throws InterruptedException {
        if (number != 0) {
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "::" + number);
        notifyAll();
    }

    public synchronized void dec() throws InterruptedException {
        //1.判断
        if (number != 1) {
            this.wait();
        }
        //2.干活
        number--;
        //3.通知
        System.out.println(Thread.currentThread().getName() + "::" + number);
        notifyAll();
    }
}

public class ThreadCom {

    public static void main(String[] args) {
        Share share = new Share();
        new Thread(()-> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.add();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "AA").start();

        new Thread(()-> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.dec();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "BB").start();
    }
}

结果如图

在这里插入图片描述

如果是四个线程对他进行更改呢?

Share share = new Share();
        new Thread(()-> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.add();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "AA").start();

        new Thread(()-> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.dec();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "BB").start();

        new Thread(()-> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.add();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "CC").start();

        new Thread(()-> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.dec();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "DD").start();

在这里插入图片描述

怎么会这样!!!

主要是虚拟唤醒导致：如果一个线程执行完毕后，通知其他线程，该线程又进入等待睡眠，可能会因为某些原因被唤醒后，if结构的语句就不会判断了，一直往下执行，所以需要将if换成while结构，每次都判断。因为wait在哪里睡眠就在哪里被唤醒，结果被某个异常唤醒了后回不去了，if结构不会在判断了，需要更改为while

while(number != 0) { //判断number值是否是0，如果不是0，等待
    this.wait(); //在哪里睡，就在哪里醒
}

3.2 使用lock

使用lock先要创建锁的对象以及通知的对象,并将其放在资源类中

package com.shang.lock;

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

class Share {
    private int number = 0;
    //创建lock
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    //+1
    public void incr() {
        lock.lock();

        try {
            while (number != 0) {
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "::" + number);
            condition.signalAll(); //唤醒所有等待线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //-1
    public void decr() {
        lock.lock();
        try {
            while (number!=1) {
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "::" + number);
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
public class LThreadCom {
    public static void main(String[] args) {
        Share share = new Share();

        new Thread(()-> {
            for (int i = 0; i < 10; i++) {
                share.incr();
            }
        }, "AA").start();

        new Thread(()-> {
            for (int i = 0; i < 10; i++) {
                share.decr();
            }
        }, "BB").start();
    }
}

4.线程间定制化通信

所谓定制化,就是顺序化,我要你如何执行,你就如何执行.

题目:启动三个线程，按照如下要求：AA打印5此，BB打印10次，CC打印15次，一共进行10轮

思路: 每个线程添加一个标志位，是该标志位则执行操作，并且修改为下一个标志位，通知下一个标志位的线程.

package com.shang.lock;

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

/**
 * 控制顺序进行输出
 */
class Task{
    private int number = 0;
    private Lock lock = new ReentrantLock();

    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();
    private Condition conditionC = lock.newCondition();

    void print5(int loop) throws InterruptedException {
        lock.lock();

        //判断标志
        try {
            while (number != 0) {
                conditionA.await();
            }

            System.out.println(Thread.currentThread().getName() + "输出A，第" + loop + "轮开始");
            for (int i = 0; i < 5; i++) {
                System.out.println("A");
            }
            number = 1; //修改标志
            conditionB.signal(); //唤醒下一个执行的
        } finally {
            lock.unlock();
        }
    }

    void print10(int loop) throws InterruptedException {
        lock.lock();

        try {
            while (number != 1) {
                conditionB.await();
            }

            System.out.println(Thread.currentThread().getName() + "输出B，第" + loop + "轮开始");
            for (int i = 0; i < 10; i++) {
                System.out.println("B");
            }
            number = 2;
            conditionC.signal();
        } finally {
            lock.unlock();
        }
    }

    void print15(int loop) throws InterruptedException {
        lock.lock();

        try {
            while (number != 2) {
                conditionC.await();
            }

            System.out.println(Thread.currentThread().getName() + " 输出C，第" + loop + "轮开始");
            for (int i = 0; i < 15; i++) {
                System.out.println("C");
            }
            number = 0;
            conditionA.signal();
        } finally {
            lock.unlock();
        }
    }
}

public class LThreadTimCom {
    public static void main(String[] args) {
        Task task = new Task();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    task.print5(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"AA").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    task.print10(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"BB").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    task.print15(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"CC").start();
    }
}

参考资料

  1. java 锁 Lock接口详解
  2. JUC高并发编程从入门到精通（全）
有什么奇怪！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程以及juc,lock
07-20
多线程以及juc,lock
JUC多线程学习个人笔记
07-08
Lock接口支持可重入锁，可以精确控制线程的等待和唤醒，而Condition则可以实现线程间的条件等待和通知。 5. **并发工具类**：JUC还包含了一些并发编程的实用工具，如Semaphore（信号量，用于限制同时访问某个资源的...
day02 juc 初识Lock与AbstractQueuedSynichronizer(AQS)
weixin_44021708的博客
03-28 77
1. concurrent包的结构层次 在针对并发编程中，Doug Lea大师为我们提供了大量实用，高性能的工具类，针对这些代码进行研究会让我们队并发编程的掌握更加透彻也会大大提升我们队并发编程技术的热爱。这些代码在java.util.concurrent包下。如下图，即为concurrent包的目录结构图。 其中包含了两个子包：atomic以及lock，另外在concurrent下的阻塞队列以及executors,这些就是concurrent包中的精华，之后会一一进行学习。而这些类的实现主要是依.
JavaSE——Day12
qq_41256473的博客
08-25 178
初识Java多线程 1、什么是线程，Java中的多线程是什么意思。 线程不是进程，但其行为很像进程，线程是更小的执行单位。每个线程都有自己的生命周期（新建、运行、中断、死亡）。 在Java语言中有一个重大特性就是内置对多线程的支持，多线程指的是一个应用程序内有多个执行体存在，按照几条不同的执行线索共同工作的情况，在计算机中因为执行速度过快会给人一个错觉——“多个执行体同时在工作”，真实情况是Java虚拟机会快速地把控制从一个线程转到另一个线程中，使得所有线程都能有机会使用CPU资源。 进程：是指一个内存中运
synchronized实现和原理分析
阿飞云漫步
03-29 1225
大家好，我是阿飞云怕什么真理无穷，进一步有近一步的欢喜本文大致梳理相关的内容：synchronized的使用方式？synchronized 加载静态方法和加载普通方法上面有什么区别？synchronized 在jdk1.6 加锁流程是怎样的？知道Java对象头吗？在synchronized有什么用？synchronized初识synchronized是Java多线程中元老...
JUC总结
Gracener的博客
07-21 211
个人JUC学习总结
Day 17
weixin_68354747的博客
07-20 857
多线程
java自学笔记（day10）归纳总结自：B站狂神说java
weixin_46083893的博客
03-06 151
多线程详解 进程(Process)和线程(Thread) 说起进程，就不得不说一下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。 而进程则是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位 通常一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义，线程是CPU调度和执行的单位 注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一时间点，CPU只能执行
Java基础
热门推荐
m0_59709514的博客
03-12 1万+
最新Java路线图谱 第一章 初识Java入门基础 文章目录最新Java路线图谱前言1、我们为什么学Java1.1、Java是什么？1.2、为什么选择Java1.3、Java主要特性2、关于Java那些事3、Java基础3.1、标识符和关键字3.2、数据类型3.2.1基本类型（primitive type）3.2.2引用类型（reference type）3.3、什么是字节3.4、类型转换3.5、变量、常量、作用域、命名规范3.6、运算符3.6.1、自增自减运算符3.6.2、幂运算 2^3 2*2
JavaSE总结笔记
今天你学Java了吗
06-01 319
跟着楠哥学Java Java基础笔记
Java架构师，大数据架构师，高并发设计模式，机器学习知识点分享
u014033218的专栏
09-14 6653
第一章：java精品课程目录大全 1、亿级流量电商详情页系统的大型高并发与高可用缓存架构实战 1课程介绍以及高并发高可用复杂系统中的缓存架构有哪些东西？32分钟 2基于大型电商网站中的商品详情页系统贯穿的授课思路介绍7分钟 3小型电商网站的商品详情页的页面静态化架构以及其缺陷11分钟
juc多线程交替打印ABC、熟悉lock的唤醒机制
07-10
现场交替访问、等待和唤醒
8、读写锁ReentrantReadWriteLock&StampLock详解.pdf
02-28
6.JUC并发工具类在大厂的应用场景详解 (1).pdf 7、深入理解 AQS 独占锁之 Reentrantlock 源码分析 (1).pdf 8、读写锁ReentrantReadWriteLock&StampLock详解.pdf 9、并发容器 (Map、List、Set） 实战及其原理.pdf 10...
JUC代码演示 Java多线程并发
05-03
JUC代码演示 Java多线程并发 源于B站https://www.bilibili.com/video/BV1Kw411Z7dF/?p=32&spm_id_from=333.1007.top_right_bar_window_history.content.click课程自我项目记录。 适合有一定基础的朋友。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 450
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 249
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 621
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
最新发布
wehpd的博客
07-30 280
集合之Map
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值