15.JUC原子类

文章目录

  • JUC原子类
    • 1.JUC中的Atomic原子操作包
      • 1.1. 基本原子类（Basic Atomic Classes）
      • 1.2. 数组原子类（Array Atomic Classes）
      • 1.3. 引用原子类（Reference Atomic Classes）
      • 4. 字段更新原子类（Field Updater Atomic Classes）
    • 2.基础原子类(Atomic Integer)
      • 2.1.基本方法
      • 2.2.案例代码
    • 3.数组原子类
      • 3.1.基本方法
      • 3.2.案例代码
    • 4.AtomicInteger线程安全原理
    • 5.对象操作原子性
      • 5.1引用类型原子类
      • 5.2.案例代码
    • 6.属性更新原子类
      • 6.1.属性更新原子类
      • 6.2.案例代码

JUC原子类

在多线程并发执行过程中，例如++ ，–，这类运算符都是不具备原子性的，通常我们会使用synchronized将其变为同步操作，但是这样会导致性能上的下降。JDK为这些不安全的操作提供了一些原子类，JDK原子类基于CAS轻量级原子操作实现，使得运行效率变得很高。

1.JUC中的Atomic原子操作包

Java中的java.util.concurrent.atomic包提供了一系列的原子操作类，用于在多线程环境下进行原子操作。这些类通常用于实现线程安全的计数器、标志位、引用等，并且比使用synchronized关键字或者volatile变量实现的方式更高效。

在这里插入图片描述

根据操作目标的数据类型，可以将JUC包的原子类分为以下4类，基本原子类，数组原子类，引用原子类，字段更新原子类

1.1. 基本原子类（Basic Atomic Classes）

这些类用于对基本数据类型进行原子操作，如int、long、boolean等。

  • AtomicBoolean：提供了对boolean类型值的原子更新操作，使用CAS算法来保证原子性。

    AtomicBoolean atomicBoolean = new AtomicBoolean(true);
atomicBoolean.getAndSet(false); // 设置新值并返回旧值

  • AtomicInteger：提供了对int类型值的原子更新操作，同样使用CAS算法。

    AtomicInteger atomicInteger = new AtomicInteger(0);
atomicInteger.incrementAndGet(); // 原子地将当前值加一，并返回增加后的值

  • AtomicLong：提供了对long类型值的原子更新操作。

    AtomicLong atomicLong = new AtomicLong(0L);
atomicLong.compareAndExchange(0L, 1L); // 如果当前值等于预期值，则更新为新值

1.2. 数组原子类（Array Atomic Classes）

这些类用于对数组中的元素进行原子操作。

  • AtomicIntegerArray：提供了对int数组中元素的原子更新操作。

    AtomicIntegerArray atomicIntArray = new AtomicIntegerArray(5);
atomicIntArray.getAndIncrement(0); // 原子地将指定索引位置的元素加一，并返回原值

  • AtomicLongArray：提供了对long数组中元素的原子更新操作。

    AtomicLongArray atomicLongArray = new AtomicLongArray(5);
atomicLongArray.addAndGet(0, 10L); // 原子地将指定索引位置的元素加上给定的值，并返回增加后的值

  • AtomicReferenceArray：提供了对引用类型数组中元素的原子更新操作。

    AtomicReferenceArray<String> atomicRefArray = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});
atomicRefArray.compareAndSet(1, "b", "new_value"); // 如果当前值等于预期值，则更新为新值

1.3. 引用原子类（Reference Atomic Classes）

这些类用于对引用类型数据进行原子操作。

  • AtomicReference：提供了对引用类型值的原子更新操作。

    AtomicReference<String> atomicReference = new AtomicReference<>("initial_value");
atomicReference.getAndSet("new_value"); // 设置新值并返回旧值

4. 字段更新原子类（Field Updater Atomic Classes）

这些类用于对指定类的指定字段进行原子更新操作，通常用于性能优化。

  • AtomicIntegerFieldUpdater：用于对指定类的指定volatile int字段进行原子更新操作。

    AtomicIntegerFieldUpdater<MyClass> updater = AtomicIntegerFieldUpdater.newUpdater(MyClass.class, "fieldName");
updater.incrementAndGet(instance); // 原子地将指定实例的字段值加一，并返回增加后的值

  • AtomicLongFieldUpdater：用于对指定类的指定volatile long字段进行原子更新操作。

    AtomicLongFieldUpdater<MyClass> updater = AtomicLongFieldUpdater.newUpdater(MyClass.class, "fieldName");
updater.compareAndSet(instance, 0L, 1L); // 如果当前值等于预期值，则更新为新值

  • AtomicReferenceFieldUpdater：用于对指定类的指定volatile引用字段进行原子更新操作。

    AtomicReferenceFieldUpdater<MyClass, String> updater = AtomicReferenceFieldUpdater.newUpdater(MyClass.class, String.class, "fieldName");
updater.getAndSet(instance, "new_value"); // 设置新值并返回旧值

这些原子类提供了一系列的原子操作方法，可以确保在多线程环境下的操作是线程安全的，避免了使用synchronized关键字或者volatile变量所带来的性能开销。

2.基础原子类(Atomic Integer)

2.1.基本方法

  1. get(): 获取当前的值。
  2. set(int newValue): 设置为指定的值。
  3. getAndSet(int newValue): 设置为指定的值，并返回旧值。
  4. incrementAndGet(): 将当前值加 1，并返回增加后的值。
  5. decrementAndGet(): 将当前值减 1，并返回减少后的值。
  6. getAndIncrement(): 返回当前值，并将其加 1。
  7. getAndDecrement(): 返回当前值，并将其减 1。
  8. compareAndSet(int expect, int update): 如果当前值等于期望值，则设置为新值，并返回 true，否则返回 false。

2.2.案例代码

通过调用Atomict提供的API 实现了原子性 修改数据

@Test
@DisplayName("测试AtomicInteger")
public void testAtomicInteger() {log.info("当前值: {}", counter.get());counter.set(10);log.info("设置值为 10");int oldValue = counter.getAndSet(20);log.info("旧值: {}, 新值: {}", oldValue, counter.get());log.info("增加后的值: {}", counter.incrementAndGet());log.info("减少后的值: {}", counter.decrementAndGet());oldValue = counter.getAndIncrement();log.info("旧值: {}, 新值: {}", oldValue, counter.get());oldValue = counter.getAndDecrement();log.info("旧值: {}, 新值: {}", oldValue, counter.get());boolean success = counter.compareAndSet(18, 30);log.info("CAS 结果: {}, 当前值: {}", success, counter.get());}

在这里插入图片描述

上面的操作是在单线程的环境下，下面我通过多线程来实现 数据的一个自增操作

@Test
@DisplayName("多线程实现自增运算")
public void test() throws InterruptedException {ArrayList<Thread> threads = new ArrayList<>();CountDownLatch latch = new CountDownLatch(10);for (int i = 0; i < 10; i++) {threads.add(new Thread(()->{// 每个线程进行 100次自增运算for (int j = 0; j < 100; j++) {counter.incrementAndGet();}latch.countDown();}));}// 全部启动线程threads.forEach(Thread::start);// 等待全部线程执行结束latch.await();//打印最终结果log.error("10个线程执行自增后的结果为：{}", counter.get());
}

在这里插入图片描述

3.数组原子类

3.1.基本方法

  1. get(int index): 获取指定索引处的值。
  2. set(int index, int newValue): 设置指定索引处的值。
  3. getAndSet(int index, int newValue): 设置指定索引处的值，并返回旧值。
  4. incrementAndGet(int index): 将指定索引处的值加 1，并返回增加后的值。
  5. decrementAndGet(int index): 将指定索引处的值减 1，并返回减少后的值。
  6. addAndGet(int index, int delta): 将指定索引处的值加上给定的增量，并返回增加后的值。
  7. compareAndSet(int index, int expect, int update): 如果指定索引处的值等于期望值，则设置为新值，

3.2.案例代码

// 数组原子类
private static final AtomicIntegerArray array = new AtomicIntegerArray(5);@Test
@DisplayName("测试数组原子类")
public void testAtomicIntegerArray() {// 1. get(int index)log.info("当前数组值: {}", array.toString());// 2. get(int index)log.info("索引为 0 的值: {}", array.get(0));// 3. set(int index, int newValue)array.set(1, 10);log.info("将索引为 1 的值设置为 10");// 4. getAndSet(int index, int newValue)int oldValue = array.getAndSet(2, 20);log.info("索引为 2 的旧值: {}, 新值: {}", oldValue, array.get(2));// 5. incrementAndGet(int index)log.info("索引为 0 的值自增后的值: {}", array.incrementAndGet(0));// 6. decrementAndGet(int index)log.info("索引为 1 的值自减后的值: {}", array.decrementAndGet(1));// 7. addAndGet(int index, int delta)log.info("索引为 2 的值加上 5 后的值: {}", array.addAndGet(2, 5));// 8. compareAndSet(int index, int expect, int update)boolean success = array.compareAndSet(3, 18, 30);log.info("CAS 结果: {}, 当前值: {}", success, array.get(3));
}

运行以上程序，结果如下：

在这里插入图片描述

4.AtomicInteger线程安全原理

基础原子类（以AtomicInteger为例），主要是通过CAS自旋 + volatile相结合的方案实现，既保证了变量操作线程的原子性，有避免了synchronized重量级锁的开销，使得Java程序的效率得到大幅度提升。

下面简单 以AtomicInteger源码 分析一下 原子类的CAS自旋 + volatile相结合的方案（JDK 17发生 了变化）

public class AtomicInteger extends Number implements java.io.Serializable {private static final long serialVersionUID = 6214790243416807050L;// 使用Unsafe类获取Unsafe实例，用于执行CAS操作private static final Unsafe U = Unsafe.getUnsafe();// VALUE字段的偏移量private static final long VALUE = U.objectFieldOffset(AtomicInteger.class, "value");// 使用volatile关键字保证多线程间的可见性private volatile int value;// 构造方法，初始化AtomicInteger的值public AtomicInteger(int initialValue) {value = initialValue;}// 构造方法，默认初始值为0public AtomicInteger() {}// 获取当前值public final int get() {return value;}// 设置新值public final void set(int newValue) {value = newValue;}// 延迟设置新值，使用setRelease方法public final void lazySet(int newValue) {U.putIntRelease(this, VALUE, newValue);}// 获取并设置新值，返回旧值public final int getAndSet(int newValue) {return U.getAndSetInt(this, VALUE, newValue);}// 比较并设置新值，如果当前值等于期望值，则设置为新值，返回设置前的值public final boolean compareAndSet(int expectedValue, int newValue) {return U.compareAndSetInt(this, VALUE, expectedValue, newValue);}// 下面的方法实现了自增、自减、加法运算，并返回相应的结果，以及更新当前值的功能，使用CAS操作保证原子性// 自增并获取当前值public final int getAndIncrement() {return U.getAndAddInt(this, VALUE, 1);}// 自减并获取当前值public final int getAndDecrement() {return U.getAndAddInt(this, VALUE, -1);}// 加上指定的值并获取当前值public final int getAndAdd(int delta) {return U.getAndAddInt(this, VALUE, delta);}// 自增并获取更新后的值public final int incrementAndGet() {return U.getAndAddInt(this, VALUE, 1) + 1;}// 自减并获取更新后的值public final int decrementAndGet() {return U.getAndAddInt(this, VALUE, -1) - 1;}// 加上指定的值并获取更新后的值public final int addAndGet(int delta) {return U.getAndAddInt(this, VALUE, delta) + delta;}// 下面的方法为类型转换方法，用于转换为其他基本数据类型// 返回int值public final String toString() {return Integer.toString(get());}// 返回当前值的int表示public int intValue() {return get();}// 返回当前值的long表示public long longValue() {return (long)get();}// 返回当前值的float表示public float floatValue() {return (float)get();}// 返回当前值的double表示public double doubleValue() {return (double)get();}// JDK 9之后的新增方法，使用plain、opaque、acquire、release等方法增加了对内存操作的控制// 返回当前值，使用非volatile内存语义public final int getPlain() {return U.getInt(this, VALUE);}// 设置新值，使用非volatile内存语义public final void setPlain(int newValue) {U.putInt(this, VALUE, newValue);}// 返回当前值，使用opaque内存语义public final int getOpaque() {return U.getIntOpaque(this, VALUE);}// 设置新值，使用opaque内存语义public final void setOpaque(int newValue) {U.putIntOpaque(this, VALUE, newValue);}// 返回当前值，使用acquire内存语义public final int getAcquire() {return U.getIntAcquire(this, VALUE);}// 设置新值，使用release内存语义public final void setRelease(int newValue) {U.putIntRelease(this, VALUE, newValue);}// 使用compareAndExchange方法实现CAS操作，设置新值，返回旧值public final int compareAndExchange(int expectedValue, int newValue) {return U.compareAndExchangeInt(this, VALUE, expectedValue, newValue);}// 使用compareAndExchangeAcquire方法实现CAS操作，设置新值，返回旧值public final int compareAndExchangeAcquire(int expectedValue, int newValue) {return U.compareAndExchangeIntAcquire(this, VALUE, expectedValue, newValue);}// 使用compareAndExchangeRelease方法实现CAS操作，设置新值，返回旧值public final int compareAndExchangeRelease(int expectedValue, int newValue) {return U.compareAndExchangeIntRelease(this, VALUE, expectedValue, newValue);}// 使用weakCompareAndSetInt方法实现CAS操作，设置新值，返回操作是否成功public final boolean weakCompareAndSetVolatile(int expectedValue, int newValue) {return U.weakCompareAndSetInt(this, VALUE, expectedValue, newValue);}// 使用weakCompareAndSetIntAcquire方法实现CAS操作，设置新值，返回操作是否成功public final boolean weakCompareAndSetAcquire(int expectedValue, int newValue) {return U.weakCompareAndSetIntAcquire(this, VALUE, expectedValue, newValue);}// 使用weakCompareAndSetIntRelease方法实现CAS操作，设置新值，返回操作是否成功public final boolean weakCompareAndSetRelease(int expectedValue, int newValue) {return U.weakCompareAndSetIntRelease(this, VALUE, expectedValue, newValue);}
}// 其中自旋操作在UnSafe中实现 /*** Atomically adds the given value to the current value of a field* or array element within the given object {@code o}* at the given {@code offset}.** @param o object/array to update the field/element in* @param offset field/element offset* @param delta the value to add* @return the previous value* @since 1.8*/@IntrinsicCandidatepublic final int getAndAddInt(Object o, long offset, int delta) {int v;do {v = getIntVolatile(o, offset);} while (!weakCompareAndSetInt(o, offset, v, v + delta));return v;}@IntrinsicCandidatepublic native int     getIntVolatile(Object o, long offset);// 比较期望值 并设置@IntrinsicCandidatepublic final boolean weakCompareAndSetInt(Object o, long offset,int expected,int x) {return compareAndSetInt(o, offset, expected, x);}

5.对象操作原子性

基础原子类型 只能保证一个变量的原子操作，但是当需要对多个变量操作时，CAS无法保证原子性操作，这个时候可以使用AtomicReference(原子引用类型)，保证对象引用的原子性。

简单来说，如果需要同时保证多个变量操作原子性，可以把多个变量放入一个对象中进行操作

5.1引用类型原子类

  • AtomicReference ：基础引用原子类

    • get()：获取当前存储在AtomicReference中的对象。
    • set()：设置AtomicReference中的对象为指定值。
    • compareAndSet()：如果当前存储在AtomicReference中的对象等于预期值，则将AtomicReference中的对象设置为新值。
    • getAndSet()：获取当前存储在AtomicReference中的对象，并设置AtomicReference中的对象为新值。

  • AtomicStampedReference：原子更新带有整数标记的引用。此类可以用于解决CAS操作的ABA问题。ABA问题是指在使用CAS进行原子更新时，如果被更新的数据从A变成了B，然后又变回了A，这样的状态变化可能会导致误判。AtomicStampedReference通过引入版本号（或时间戳）来解决这个问题，它将每次更新都与一个标记相关联，以便在比较时不仅考虑引用对象的值，还要考虑其标记。

    主要方法：

    • boolean compareAndSet(V expectedReference, V newReference, int expectedStamp, int newStamp)：如果当前引用和标记都与预期值匹配，则原子地将引用和标记的值设置为新值。

  • AtomicMarkableReference：原子更新带有标记位的引用。与AtomicStampedReference类似，但是标记是一个布尔值，只有两种状态（true或false）。这个类通常用于简单的标记，而不需要额外的版本信息。

    主要方法：

    • boolean compareAndSet(V expectedReference, V newReference, boolean expectedMark, boolean newMark)：如果当前引用和标记都与预期值匹配，则原子地将引用和标记的值设置为新值。

下面主要介绍一下AtomicReference

5.2.案例代码

    @Test@DisplayName("测试基础引用原子类型")public void test2() {// 创建一个初始值为null的AtomicReference对象AtomicReference<Student> atomicReference = new AtomicReference<>(null);Student student = new Student("张三",21);// 设置AtomicReference中的对象值为atomicReference.set(student);log.error("当前AtomicReference中的对象值为: " + atomicReference.get());// 比较并设置操作，如果当前对象值等于"student"，则设置为"新的student"boolean success = atomicReference.compareAndSet(student,new Student("李四",21));if (success) {log.error("对象值成功被修改为: " + atomicReference.get());} else {log.error("对象值未被修改，当前值为: " + atomicReference.get());}// 获取并设置操作，获取当前对象值并设置为"王五 32"Student studentOld = atomicReference.getAndSet(new Student("王五", 32));log.error("获取到的旧对象值为: " + studentOld);log.error("当前AtomicReference中的对象值为: " + atomicReference.get());}@Getter@Setter@ToStringclass Student{private String name;private int age;public Student(String name, int age) {this.name = name;this.age = age;}}

在这里插入图片描述

注意：使用原子应用类型AtomicReference操作包装了Student，只能保证Student引用的原子的操作，对被包装的Student对象的字段修改时并不能保证原子性（说白了，student.setName() 这种是不具备原子性的 new Student(“xxx”,232) 这种 通过包装统一更新的 是具备原子性的）

6.属性更新原子类

属性更新原子类是Java并发包提供的一组类，用于原子性地更新对象中的属性值。这些类通常用于保证多线程环境下的线程安全性，避免竞态条件和数据不一致性问题。

6.1.属性更新原子类

属性类更新原子类有以下三个

  1. AtomicIntegerFieldUpdater：原子更新整型字段的值。
    1. static <T> AtomicIntegerFieldUpdater<T> newUpdater(Class<T> tClass, String fieldName)：创建一个新的原子整型字段更新器。
    2. int get(T obj)：获取指定对象中字段的当前值。
    3. void set(T obj, int newValue)：设置指定对象中字段的值为指定的新值。
    4. int getAndSet(T obj, int newValue)：获取并设置指定对象中字段的值为指定的新值。
  2. AtomicLongFieldUpdater：原子更新长整型字段的值。
    1. static <T> AtomicLongFieldUpdater<T> newUpdater(Class<T> tClass, String fieldName)：创建一个新的原子长整型字段更新器。
    2. long get(T obj)：获取指定对象中字段的当前值。
    3. void set(T obj, long newValue)：设置指定对象中字段的值为指定的新值。
    4. long getAndSet(T obj, long newValue)：获取并设置指定对象中字段的值为指定的新值。
  3. AtomicReferenceFieldUpdater<T, V>：原子更新引用类型字段的值。
    1. static <T,V> AtomicReferenceFieldUpdater<T,V> newUpdater(Class<T> tClass, Class<V> vClass, String fieldName)：创建一个新的原子引用类型字段更新器。
    2. V get(T obj)：获取指定对象中字段的当前值。
    3. void set(T obj, V newValue)：设置指定对象中字段的值为指定的新值。
    4. V getAndSet(T obj, V newValue)：获取并设置指定对象中字段的值为指定的新值。

使用属性更新原子类保障安全性的主要流程 大致分为两部

  1. 更新的对象的属性必须是 public volatile修饰符
  2. 因为对象的属性修改类型原子类都是抽象类，所以每次每次使用都必须使用静态方法

6.2.案例代码

    @Test@DisplayName("属性更新原子类")public void test3() {AtomicIntegerFieldUpdater<Data> updater = AtomicIntegerFieldUpdater.newUpdater(Data.class, "value");Data data = new Data(10);// 获取并输出当前值log.error("初始值：{}",updater.get(data));// 尝试原子性地将值更新为20updater.set(data, 20);log.error("更新后的值：{}",updater.get(data));// 尝试原子性地获取并更新值为30int oldValue = updater.getAndSet(data, 30);log.error("原来的值：{}", oldValue);log.error("更新后的值：{}", updater.get(data));}class Data {public volatile int value; // 要更新的字段必须是 volatile 的public Data(int value) {this.value = value;}}

在这里插入图片描述

这个代码了如何使用AtomicIntegerFieldUpdater类来原子性地更新Data对象中的整型字段value的值。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/698131.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【LAMMPS学习】八、基础知识(6.5)PyLammps 教程

【LAMMPS学习】八、基础知识(6.5)PyLammps 教程

8. 基础知识 此部分描述了如何使用 LAMMPS 为用户和开发人员执行各种任务。术语表页面还列出了 MD 术语&#xff0c;以及相应 LAMMPS 手册页的链接。 LAMMPS 源代码分发的 examples 目录中包含的示例输入脚本以及示例脚本页面上突出显示的示例输入脚本还展示了如何设置和运行各…
阅读更多...
记录一次 vue2 前端项目整合过程

记录一次 vue2 前端项目整合过程

整合成功效果图 具体说明&#xff1a; 项目A是现在的vue2前端项目&#xff0c;项目B是一个开源的工作流前端&#xff0c;项目后端代码已经整合了&#xff0c;就不多提了。这里主要记录下前端整合的过程和思路。 1、开源工作流里面的功能&#xff0c;拷贝到自己对应的vue2项目里…
阅读更多...
傻瓜化备份/恢复K8S集群Etcd数据

傻瓜化备份/恢复K8S集群Etcd数据

前言&#xff1a; 备份重要数据&#xff0c;简化重复操作&#xff0c;让一指禅、点点点也能完成运维任务。 脚本呈现界面如下&#xff1a; 1、查看Etcd版本 rootmaster:~# cat /etc/kubernetes/manifests/etcd.yaml | grep image: | awk {print $2} registry.aliyuncs.com/goo…
阅读更多...
享元模式详解

享元模式详解

享元模式 1 概述 定义&#xff1a; ​ 运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似对象的开销&#xff0c;从而提高系统资源的利用率。 2 结构 享元&#xff08;Flyweight &#xff09;模式中存…
阅读更多...
论文翻译及部分笔记：LANDMARC: Indoor Location Sensing Using Active RFID

论文翻译及部分笔记：LANDMARC: Indoor Location Sensing Using Active RFID

LANDMARC: Indoor Location Sensing Using Active RFID 摘要 移动计算设备和嵌入式技术的日益融合引发了“上下文感知”应用的发展和部署&#xff0c;其中位置是最重要的上下文。在本文中&#xff0c;我们介绍了一种名为LANDMARC的定位感知原型系统&#xff0c;该系统使用射频识…
阅读更多...
归档文件整理规则，一键按扩展名归类，轻松打造有序文档世界！

归档文件整理规则，一键按扩展名归类，轻松打造有序文档世界！

我们的电脑里充斥着各种各样的文件&#xff1a;图片、文档、视频、音频……它们如同一座座无序的小山&#xff0c;让人眼花缭乱&#xff0c;难以找到所需。你是否曾为了找一个文件而翻遍整个电脑&#xff1f;是否曾因为文件混乱而错失了重要信息&#xff1f;别担心&#xff0c;…
阅读更多...
Spring AI开发前期开发指导(maven依赖下载问题解决)

Spring AI开发前期开发指导(maven依赖下载问题解决)

文章目录 说明开发条件网络环境准备本地环境准备开发工具准备 特殊说明maven配置项目jar一致下载错误解决可行的版本搭配 说明 动力节点视频教程地址&#xff0c;本文章学习该教程&#xff0c;同时说明的maven配置问题导致的项目依赖下载失败的问题和其他问题的记录。 开发条…
阅读更多...
网络安全快速入门（十一）vi/vim

网络安全快速入门（十一）vi/vim

11.1 了解vi 前面我i们已经在基础命令中大致了解了vi&#xff0c;本章我们针对vi来细讲一下&#xff0c;vi和vim 11.1.1 什么是vi/vim&#xff1f; vi和vim&#xff0c;都是一个模块化的文本编辑工具&#xff0c;换句话讲&#xff0c;通过vi下的一系列的命令&#xff0c;可以实…
阅读更多...
微服务部署不迷茫：4大部署模式深度解析，轻松驾驭云原生时代

微服务部署不迷茫：4大部署模式深度解析，轻松驾驭云原生时代

微服务部署最全详解(4种常见部署模式) 微服务多实例部署 每个微服务都独立部署在自己的运行环境中&#xff0c;这是微服务架构的核心思想。 一般会采用每个主机多个服务实例&#xff0c;如下所示&#xff1a; 这是一种传统的应用部署方法&#xff0c;每个服务实例在一个或多个…
阅读更多...
算法day05

算法day05

第一题 1004. 最大连续1的个数 III 题目如下所示&#xff1a; 如上题所示&#xff1a; 题目本意是在一个数组中只有1和0&#xff0c;给定一个k值&#xff0c;将小于k个0翻转成1&#xff0c;然后返回最终得到最长的1的个数&#xff1b; 我们将这到题的意思转化为另外一种意思&…
阅读更多...
Web3 Tools - Base58

Web3 Tools - Base58

Base58编码 Base58编码是一种用于表示数字的非常见的编码方法。它通常用于加密货币领域&#xff0c;例如比特币和其他加密货币的地址表示。 什么是Base58编码&#xff1f; Base58编码是一种将数字转换为人类可读形式的编码方法。与常见的Base64编码不同&#xff0c;Base58编码…
阅读更多...
uniapp小程序：大盒子包裹小盒子但是都有点击事件该如何区分？

uniapp小程序：大盒子包裹小盒子但是都有点击事件该如何区分？

在开发过程中我们会遇到这种情况&#xff0c;一个大盒子中包裹这一个小盒子&#xff0c;两个盒子都有点击事件&#xff0c;例如&#xff1a; 这个时候如果点击评价有可能会点击到它所在的大盒子&#xff0c;如果使用css中的z-index设置层级的话如果页面的盒子多的话会混乱&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023