CAS-比较并交换

news2024/11/13 7:54:53

CAS-比较并交换

原子类

何为原子类

image-20221203185613775

没有CAS之前

  • 多线程环境不使用原子类保证线程安全i++(基本数据类型)

常用synchronized锁,但是它比较重 ,牵扯到了用户态和内核态的切换,效率不高。

public class T3 {
    volatile int number = 0;

    //读取
    public int getNumber() {
        return number;
    }

    //写入加锁保证原子性
    public synchronized void setNumber() {
        number++;
    }
}

使用CAS之后

  • 多线程情况下使用原子类保证线程安全(基本数据类型)
//使用原子类保证线程安全
public class T3 {
    AtomicInteger atomicInteger = new AtomicInteger();

    public int getAtomicInteger() {
        return atomicInteger.get();
    }

    public void setAtomicInteger() {
        //先读再加
        atomicInteger.getAndIncrement();
    }
}
  • 类似于乐观锁

CAS是什么

CAS基本知识

compare and swap的缩写,中文翻译成比较并交换,实现并发算法时常用到的一种技术。它包含三个操作数——内存位置、预期原值及更新值。

执行CAS操作的时候,将内存位置的值与预期原值比较:
如果相匹配,那么处理器会自动将该位置值更新为新值,
如果不匹配,处理器不做任何操作,多个线程同时执行CAS操作只有一个会成功。

CAS原理

CAS (CompareAndSwap)
CAS有3个操作数,位置内存值V,旧的预期值A,要修改的更新值B
当且仅当旧的预期值A和内存值V相同时,将内存值V修改B,否则什么都不做或重来*

当它重来重试的这种行为称为—自旋!

  • eg

线程A读取了值为5,想要更新为6,想要将值写回的时候发现线程B和C都进行了操作,已经变成了7,这个时候A不能成功,可能会发生自旋

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J2DQIQwI-1670068482739)(E:\我的笔记\imgs\image-20221203190335770.png)]

CASDemo代码

多线程情况下使用原子类保证线程安全(基本数据类型)

public class CASDemo {
    public static void main(String[] args) throws InterruptedException {
        //初始值为5
        AtomicInteger atomicInteger = new AtomicInteger(5);

        //如果atomicInteger的旧的预期值为5,如果期望值和预期值相同,则将值修改为2020
        System.out.println(atomicInteger.compareAndSet(5, 2020) + "\t" + atomicInteger.get());
        //这里atomicInteger的旧的预期值为2020,因此修改失败
        System.out.println(atomicInteger.compareAndSet(5, 1024) + "\t" + atomicInteger.get());
    }
}
//true 2022
//false 2022

硬件级别保证

对总线加锁,效率比synchronized效率高。

CAS是JDK提供的非阻塞原子性操作,它通过硬件保证了比较-更新的原子性。

它是非阻塞的且自身原子性,也就是说这玩意效率更高且通过硬件保证,说明这玩意更可靠。

CAS是一条CPU的原子指令cmpxchg指令),不会造成所谓的数据不一致问题,Unsafe提供的CAS方法(如compareAndSwapXXX)底层实现即为CPU指令cmpxchg。

执行cmpxchg指令的时候,会判断当前系统是否为多核系统,如果是就给总线加锁,只有一个线程会对总线加锁成功,加锁成功之后会执行cas操作,也就是说CAS的原子性实际上是CPU实现的, 其实在这一点上还是有排他锁的,只是比起用synchronized, 这里的排他时间要短的多, 所以在多线程情况下性能会比较好

源码分析

//compareAndSet
//发现它调用了Unsafe类
public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

//compareAndSwapInt
//发现它调用了native方法
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
//这三个方法是类似的
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

上面三个方法都是类似的,主要对4个参数做一下说明。
var1:表示要操作的对象
var2:表示要操作对象中属性地址的偏移量
var4:表示需要修改数据的期望的值
var5/var6:表示需要修改为的新值

引出来一个问题:Unsafe类是什么?

CAS底层原理?如果知道,谈谈你对UnSafe的理解

UnSafe

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
	//保证变量修改后多线程之间的可见性
    private volatile int value;
}

1.Unsafe

CAS这个理念 ,落地就是Unsafe类

它是CAS的核心类,由于Java方法无法直接访问底层系统,需要通过本地(native)方法来访问,Unsafe相当于一个后门 ,基于该类可以直接操作特定内存\ 的数据 。Unsafe类存在于sun.misc包中,其内部方法操作可以像C的指针一样直接操作内存,因为Java中CAS操作的执行依赖于Unsafe类的方法。

注意Unsafe类中的所有方法都是 \修饰的,也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务 。

打开rt.jar包(最基本的包)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9vgqaYs3-1670068482739)(E:\我的笔记\imgs\image-20221203191315395.png)]

2.变量valueOffset,表示该变量值在内存中的偏移地址,因为Unsafe就是根据内存偏移地址获取数据的。

 public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
 }

3.变量value用volatile修饰

我们知道i++线程不安全的,那atomicInteger.getAndIncrement()为什么是线程安全的呢?

CAS的全称为Compare-And-Swap,它是一条CPU并发原语。
它的功能是判断内存某个位置的值是否为预期值,如果是则更改为新的值,这个过程是原子的。
AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作,从而避免 synchronized 的高开销,执行效率大为提升。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z39yWDWe-1670068482740)(E:\我的笔记\imgs\image-20221203191601933.png)]

CAS并发原语体现在JAVA语言中就是sun.misc.Unsafe类中的各个方法。调用UnSafe类中的CAS方法,JVM会帮我们实现出CAS汇编指令 。这是一种完全依赖于硬件的功能,通过它实现了原子操作。再次强调,由于CAS是一种系统原语 ,原语属于操作系统用语范畴,是由若干条指令组成的,用于完成某个功能的一个过程,并且原语的执行必须是连续的,在执行过程中不允许被中断,也就是说CAS是一条CPU的原子指令,不会造成所谓的数据不一致问题。

源码分析

new AtomicInteger().getAndIncrement();


//AtomicInteger.java
public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }


//Unsafe.class
public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

//Unsafe.class
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
  • 若在OpenJDK源码中查看Unsafe.java

    • 这里while体现了自旋的思想

    • 假如是ture,取反false退出循环;假如是false,取反true要继续循环。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oNNIjEa2-1670068482740)(E:\我的笔记\imgs\image-20221203191909693.png)]

  • 原理

假设线程A和线程B两个线程同时执行getAndAddInt操作(分别跑在不同CPU上):

1.AtomicInteger里面的value原始值为3,即主内存中AtomicInteger的value为3,根据JMM模型,线程A和线程B各自持有一份值为3的value的副本分别到各自的工作内存。

2.线程A通过getIntVolatile(var1, var2)拿到value值3,这时线程A被挂起。

3.线程B也通过getIntVolatile(var1, var2)方法获取到value值3,此时刚好线程B没有被挂起并执行compareAndSwapInt方法比较内存值也为3,成功修改内存值为4,线程B打完收工,一切OK。

4.这时线程A恢复,执行compareAndSwapInt方法比较,发现自己手里的值数字3和主内存的值数字4不一致,说明该值已经被其它线程抢先一步修改过了,那A线程本次修改失败,只能重新读取重新来一遍了。

5.线程A重新获取value值,因为变量value被volatile修饰,所以其它线程对它的修改,线程A总是能够看到,线程A继续执行compareAndSwapInt进行比较替换,直到成功。

底层汇编

  • Unsafe类中的compareAndSwapInt,是一个本地方法,该方法的实现位于unsafe.cpp
  • 核心(Atomic::cmpxchg(x, addr, e)) == e;
 UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv* env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
      UnsafeWrapper("Unsafe_CompareAndSwapInt");
      oop p = JNIHandles::resolve(obj);
    // 先想办法拿到变量value在内存中的地址,根据偏移量valueOffset,计算 value 的地址
      jint* addr = (jint* ) index_oop_from_field_offset_long(p, offset);
    // 调用 Atomic 中的函数 cmpxchg来进行比较交换,其中参数x是要交换的值,e是要比较的值
    //cas成功,返回期望值e,等于e,此方法返回true;
    //cas失败,返回内存中的value值,不等于e,此方法返回false
      return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
    UNSAFE_END
    //-------------核心(Atomic::cmpxchg(x, addr, e)) == e;
    //JDK提供的CAS机制,在汇编层级会禁止变量两侧的指令优化,然后使用cmpxchg指令比较并更新变量值(原子性)
  • 再看看cmpxchg里面是什么
// 调用 Atomic 中的函数 cmpxchg来进行比较交换,其中参数x是即将更新的值,参数e是原内存的值
  return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
    unsigned Atomic::cmpxchg(unsigned int exchange_value,volatile unsigned int* dest, unsigned int compare_value) {
        assert(sizeof(unsigned int) == sizeof(jint), "more work to do");
 //根据操作系统类型调用不同平台下的重载函数,这个在预编译期间编译器会决定调用哪个平台下的重载函数
        return (unsigned int)Atomic::cmpxchg((jint)exchange_value, (volatile jint*)dest, (jint)compare_value);
    }
  • 不同的操作系统下会调用不同的compxchg重载函数,例如win10
inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint compare_value) {
  //判断是否是多核CPU
  int mp = os::is_MP();
  __asm {
    //三个move指令表示的是将后面的值移动到前面的寄存器上
    mov edx, dest
    mov ecx, exchange_value
    mov eax, compare_value
    //CPU原语级别,CPU触发
    LOCK_IF_MP(mp)
    //比较并交换指令
    //cmpxchg: 即“比较并交换”指令
    //dword: 全称是 double word 表示两个字,一共四个字节
    //ptr: 全称是 pointer,与前面的 dword 连起来使用,表明访问的内存单元是一个双字单元 
    //将 eax 寄存器中的值(compare_value)与 [edx] 双字内存单元中的值进行对比,
    //如果相同,则将 ecx 寄存器中的值(exchange_value)存入 [edx] 内存单元中
    cmpxchg dword ptr [edx], ecx
  }
}
  • 总结

CAS是靠硬件实现的从而在硬件层面提升效率,最底层还是交给硬件来保证原子性和可见性

实现方式是基于硬件平台的汇编指令,在intel的CPU中(X86机器上),使用的是汇编指令cmpxchg指令。

核心思想就是:比较要更新变量的值V和预期值E(compare),相等才会将V的值设为新值N(swap)如果不相等自旋再来。

自定义原子引用

  • 譬如AtomicInteger原子整型,可否有其他原子类型?比如AtomicBook、AtomicOrder
  • 可以!
  • 丢入泛型中Class AtomicReference<V>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LhLhKtor-1670068482741)(E:\我的笔记\imgs\image-20221203192254346.png)]

  • eg
class User {
    String userName;
    int age;

    public User(String userName, int age) {
        this.userName = userName;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", age=" + age +
                '}';
    }
}


public class AtomicReferenceDemo {
    public static void main(String[] args) {
        User z3 = new User("z3", 24);
        User li4 = new User("li4", 26);
        //将类型丢入泛型即可
        AtomicReference<User> atomicReferenceUser = new AtomicReference<>();

        //将这个原子类设置为张三
        atomicReferenceUser.set(z3);
        //张三换位李四
        System.out.println(atomicReferenceUser.compareAndSet(z3, li4) + "\t" + atomicReferenceUser.get().toString());
        //true   User(userName=li4,age=28)
        System.out.println(atomicReferenceUser.compareAndSet(z3, li4) + "\t" + atomicReferenceUser.get().toString());
        //false   User(userName=li4,age=28)
    }
}
//true	User{userName='li4', age=26}
//false	User{userName='li4', age=26}

CAS与自旋锁,借鉴CAS思想

CAS落地的重要应用-自旋锁

是什么

自旋锁(spinlock)

是指尝试获取锁的线程不会立即阻塞,而是采用循环的方式去尝试获取锁,

当线程发现锁被占用时,会不断循环判断锁的状态,直到获取。这样的好处是减少线程上下文切换的消耗,缺点是循环会消耗CPU。

若在OpenJDK源码中查看Unsafe.java

这里while体现了自旋的思想

假如是ture,取反false退出循环;假如是false,取反true要继续循环。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bD1jpCAG-1670068482741)(E:\我的笔记\imgs\image-20221203192639775.png)]

自己实现一个自旋锁SpinLockDemo

  • 题目

实现一个自旋锁 自旋锁好处:循环比较获取没有类似wait的阻塞。 通过CAS操作完成自旋锁,A线程先进来调用myLock方法自己持有锁5秒钟,B随后进来后发现 当前有线程持有锁,不是null,所以只能通过自旋等待,直到A释放锁后B随后抢到。

//利用cas实现自旋锁
public class SpinLockDemo {
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void Lock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "\t" + "-----come in");
        //用这个循环实现自旋
        //atomicReference.compareAndSet(null, thread) 如果是空的,那我们把thread放进去
        while (!atomicReference.compareAndSet(null, thread))
        {

        }


    }

    public void UnLock() {
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread, null);//把当前线程踢出去,置为null
        System.out.println(Thread.currentThread().getName() + "\t" + "-------task over,unLock.....");
    }

    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();
        new Thread(() -> {
            //线程A第一次进来期望值为null,将线程放入
            spinLockDemo.Lock();
            try {
                //休眠5秒
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.UnLock();
        }, "A").start();

        //暂停一会儿线程,保证A线程先于B线程启动并完成
        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            //线程A处于休眠中,此时线程B执行Lock方法,期望值为线程A与旧的期望值null不相符,
            //!atomicReference.compareAndSet(null, thread)=true,B线程处于循环等待状态
            //B  -----come in  B只是尝试去抢锁,但是一直在自旋。
            spinLockDemo.Lock();

            //线程A休眠结束后执行了UnLock方法,将期望值有改为了null,而此时B立马抢到锁,然后马上结束了
            spinLockDemo.UnLock();
        }, "B").start();

    }
}
//A  -----come in
//B  -----come in
//A  -------task over,unLock.....
//B  -------task over,unLock.....

CAS缺点

1 循环时间长开销很大

do while 如果它一直自旋会一直占用CPU时间,造成较大的开销

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VcD7CeCN-1670068482742)(E:\我的笔记\imgs\image-20221203193610526.png)]

如果CAS失败,会一直进行尝试。如果CAS长时间一直不成功,可能会给CPU带来很大的开销。

2 引出来ABA问题

  • 什么是ABA问题

CAS会导致“ABA问题”。

CAS算法实现一个重要前提需要取出内存中某时刻的数据并在当下时刻比较并替换,那么在这个时间差类会导致数据的变化。

比如说一个线程one从内存位置V中取出A,这时候另一个线程two也从内存中取出A,并且线程two进行了一些操作将值变成了B,

然后线程two又将V位置的数据变成A,这时候线程one进行CAS操作发现内存中仍然是A,然后线程one操作成功。

尽管线程one的CAS操作成功,但是不代表这个过程就是没有问题的。

ABA问题图示

小明有女朋友A,一天小明出差了,老王和A在其一起了,A变成了B成了老王的女朋友。等小明出差回来之前

老王和B分手了,B又变成了A

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LqB91Yhf-1670068482743)(E:\我的笔记\imgs\image-20221203195043446.png)]

  • 如何解决

AtomicStampedReference版本号 (注意区分前面的Class AtomicReference<V>

Class AtomicStampedReference<V> 相关API

AtomicStampedReference(V initialRef, int initialStamp) 创建一个新的 AtomicStampedReference与给定的初始值。

public boolean weakCompareAndSet(V expectedReference,//旧值
                                 V newReference,//新值
                                 int expectedStamp,//旧版本号
                                 int newStamp)//新版本号
  • eg

正常情况

class Book {
    private int id;
    private String bookName;

    public Book(int id, String bookName) {
        this.id = id;
        this.bookName = bookName;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", bookName='" + bookName + '\'' +
                '}';
    }
}

public class AtomicStampedDemo {
    public static void main(String[] args) {
        Book javaBook = new Book(1, "javaBook");
        AtomicStampedReference<Book> stampedReference = new AtomicStampedReference<>(javaBook, 1);
        System.out.println(stampedReference.getReference() + "\t" + stampedReference.getReference());
        Book mysqlBook = new Book(2, "mysqlBook");
        boolean b;
        b = stampedReference.compareAndSet(javaBook, mysqlBook, stampedReference.getStamp(), stampedReference.getStamp() + 1);
        System.out.println(b + "\t" + stampedReference.getReference() + "\t" + stampedReference.getStamp());
    }
}
//Book(id=1, bookName=javaBook)  Book(id=1, bookName=javaBook)
//true  Book(id=2, bookName=mysqlBook)  2

ABA复现(单线程情况下)

class Book {
    private int id;
    private String bookName;

    public Book(int id, String bookName) {
        this.id = id;
        this.bookName = bookName;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", bookName='" + bookName + '\'' +
                '}';
    }
}

public class AtomicStampedDemo {
    public static void main(String[] args) {
        Book javaBook = new Book(1, "javaBook");
        AtomicStampedReference<Book> stampedReference = new AtomicStampedReference<>(javaBook, 1);
        System.out.println(stampedReference.getReference() + "\t" + stampedReference.getReference());
        Book mysqlBook = new Book(2, "mysqlBook");
        boolean b;
        b = stampedReference.compareAndSet(javaBook, mysqlBook, stampedReference.getStamp(), stampedReference.getStamp() + 1);
        System.out.println(b + "\t" + stampedReference.getReference() + "\t" + stampedReference.getStamp());
        b = stampedReference.compareAndSet(mysqlBook, javaBook, stampedReference.getStamp(), stampedReference.getStamp() + 1);
        System.out.println(b + "\t" + stampedReference.getReference() + "\t" + stampedReference.getStamp());
    }
}
//Book(id=1, bookName=javaBook)  Book(id=1, bookName=javaBook) --------
//true  Book(id=2, bookName=mysqlBook)  2
//true  Book(id=1, bookName=javaBook)  3  --------虽然1.3行内容是一样的,但是版本号不一样

ABA复现(多线程情况下)

public class ABADemo {
    static AtomicInteger atomicInteger = new AtomicInteger(100);
    static AtomicStampedReference atomicStampedReference = new AtomicStampedReference(100, 1);

    public static void main(String[] args) {
        new Thread(() -> {
            atomicInteger.compareAndSet(100, 101);
            atomicInteger.compareAndSet(101, 100);//这里 中间就有人动过了,虽然值是不变的,假如不检查版本号,CAS就直接能成功了
        }, "t1").start();

        new Thread(() -> {
            //暂停一会儿线程
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ;
            System.out.println(atomicInteger.compareAndSet(100, 2022) + "\t" + atomicInteger.get());
        }, "t2").start();

        //-------------------- true-2022

        //暂停一会儿线程,main彻底等待上面的ABA出现演示完成。
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("============以下是ABA问题的解决=============================");

        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t 首次版本号:" + stamp);//1-----------初始获得一样的版本号
            //暂停500毫秒,保证t4线程初始化拿到的版本号和我一样,
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicStampedReference.compareAndSet(100, 101, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t 2次版本号:" + atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(101, 100, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t 3次版本号:" + atomicStampedReference.getStamp());
        }, "t3").start();

        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();//记录一开始的版本号,并且写死
            System.out.println(Thread.currentThread().getName() + "\t 首次版本号:" + stamp);//1------------初始获得一样的版本号
            //暂停1秒钟线程,等待上面的t3线程,发生了ABA问题
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean result = atomicStampedReference.compareAndSet(100, 2019, stamp, stamp + 1);//这个还是初始的版本号,但是实际上版本号被T3修改了,所以肯定会失败
            System.out.println(Thread.currentThread().getName() + "\t" + result + "\t" + atomicStampedReference.getReference());
        }, "t4").start();
    }
}
//t3 首次版本号:1
//t4 首次版本号:1
//t3 2次版本号:2
//t3 3次版本号:3
//false 100 3   -----因为版本号实际上已经被修改了

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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

JMeter 进行函数助手MD5加密

JMeter 函数助手 MD5 加密 JMeter函数助手中&#xff0c;提供了MD5加密的方法&#xff0c;如图所示&#xff0c;我们将内容 “123456”进行加密&#xff0c;可以看到加密成功了。 下面我们来看看项目接口的请求参数。 这是一个认证接口&#xff0c;我们可以看到请求的参数中包…

MySQL-MVCC多版本控制及事务的隔离性

MySQL事务的启动方式 隐式&#xff1a;执行SQL语句自动提交&#xff08;前提MySQL使用SET AUTOCOMMIT1开启自动提交&#xff09;显式&#xff1a;begin/start transaction; update user set username timi where id 1; commit; begin/start transaction命令并不是一个事务的起…

UE获取当前鼠标点击位置坐标

文章目录 1. 实现目标2. 实现过程2.1 蓝图代码2.2 实现思路3. 参考资料1. 实现目标 获取当前鼠标点击位置的UE世界坐标(x,y,z),效果如下图所示(为便于演示,下图显示了碰撞点位)。 2. 实现过程 2.1 蓝图代码 (1)核心函数的蓝图代码如下: (2)当鼠标左键按下时,…

【✨十五天搞定电工基础】一阶电路的暂态分析

本章要求1. 了解电阻元件、电感元件与电容元件的特征; 2. 理解电路的暂态和稳态、零输入响应、零状态响应、全响应的概念&#xff0c;以及时间常数的物 理意义; 3. 掌握换路定则及初始值的求法; 4. 掌握一阶线性电路分析的三要素法。 目录 一、一阶电路和换路定律 1…

第十四章 图的存储及图的DFS(超级详细!!逐行解析!!)

第十四章 图的存储及图的DFS一、图1、什么是图&#xff1f;2、图的存储&#xff08;1&#xff09;邻接矩阵&#xff08;2&#xff09;邻接表二、图的深度优先搜索1、思路2、模板&#xff08;1&#xff09;问题&#xff1a;如何求左右子树呢?什么时候记录呢&#xff1f;如何构造…

数字孪生场景、代码即开即用 | 图观™引擎 超详细功能范例演示

数字孪生已经从一项前沿技术&#xff0c;演变成为各行各业数字化转型的必选项。 过去想要构建数字孪生应用&#xff0c;要面对视觉设计、三维底座构建、代码开发、数据对接、部署联调等一系列复杂工作。不仅要了解复杂的数学基础知识、底层三维开发技术&#xff0c;还要熟知各…

Spring Cloud微服务迁移到Kubernetes容器化

文章目录相关文章k8s容器部署流程熟悉Spring Cloud微服务项目源代码编译构建构建项目镜像并推送到镜像仓库制作镜像将镜像推送到harbor仓库K8s服务编排部署基础环境在K8s中部署Nacos集群&#xff08;注册和配置中心&#xff09;在k8s中部署Seata分布式事务在linux部署mysql,red…

李炎恢ECMAScript6 / ES6+(二)

16.Set 数据集合 学习要点&#xff1a; 1.Set 数据集合 本节课我们来开始学习 ES6 新增的 Set 数据集合的用法&#xff1b; 一&#xff0e;Set 数据集合 1.ES6 之前只有数组一种数据结构&#xff0c;而现在提供了 Set 和 Map 两种集合&#xff1b; 严格来说&#xff0c;对象…

PC辉光效果一切正常,安卓辉光却没效果、显示异常(爆闪、黑屏等)

一&#xff1a;安卓端辉光不显示问题 问题描述&#xff1a;项目中使用unity的PostProcessing package实现辉光的功能&#xff0c;在pc上辉光效果一切正常&#xff0c;但是打出apk在真机测试时&#xff0c;辉光基本没效果。 解决思路&#xff1a;PostProcessing Bloom效果需要有…

【ArcGIS微课1000例】0056:将单波段栅格背景设置为无数据NoData的方法

本文讲解将单波段栅格背景设置为空值的方法,以DEM数据为例。 文章目录 一、DEM设置无数据二、注意事项单波段数据,一般只有DEM,遥感单波段影像,二值化图像等。 使用珊格计算器通过SetNull 函数(设定空值函数)可以将特定值计算为空值(NoData),SetNull的语法格式为: Se…

[附源码]Python计算机毕业设计Django教育企业网站

项目运行 环境配置&#xff1a; Pychram社区版 python3.7.7 Mysql5.7 HBuilderXlist pipNavicat11Djangonodejs。 项目技术&#xff1a; django python Vue 等等组成&#xff0c;B/S模式 pychram管理等等。 环境需要 1.运行环境&#xff1a;最好是python3.7.7&#xff0c;…

4-5:关注,取消关注

需求 开发关注、取消关注功能。 统计用户的关注数、粉丝数。 关键 若A关注了B&#xff0c;则A是B的Follower (粉丝)&#xff0c;B是A的Followee (目标)。关注的目标可以是用户、帖子、题目等&#xff0c;在实现时将这些目标抽象为实体。 也是将数据存储到redis中&#xff0c;…

LeetCode刷题复盘笔记—一文搞懂0 - 1背包之494. 目标和问题(动态规划系列第九篇)

今日主要总结一下动态规划0-1背包的一道题目&#xff0c;494. 目标和问题 题目&#xff1a;494. 目标和 Leetcode题目地址 题目描述&#xff1a; 给你一个整数数组 nums 和一个整数 target 。 向数组中的每个整数前添加 ‘’ 或 ‘-’ &#xff0c;然后串联起所有整数&#…

国外网友分享如何从零开始打造一辆真正的自动驾驶汽车

在 2021 年夏天大学二年级结束后,我决定从事当时最先进的项目之一——从头开发自动驾驶软件并在真车上实现。在公开我的代码的一些主要部分并发布演示视频后,我收到了很多关于该项目的问题。因此,我决定分享开发过程背后的故事。 我一直对与人工智能和机器学习相关的任何事…

Java代码审计——ClassLoader 类加载机制

目录 前言&#xff1a; (一&#xff09;类加载机制 0x01 ClassLoader 类 0x02 loadClass()方法的流程 0x03 自定义的类加载器 0x04 loadClass()方法与 Class.forName 的区别 0x05 URLClassLoader &#xff08;二&#xff09;Java 动态代理 0x01 静态代理 0x02 动态代理…

2022最新 MySQL 内部技术架构面试题

更多面试题&#xff1a;https://javaxiaobear.gitee.io/ 47、MySQL内部支持缓存查询吗&#xff1f; 当MySQL接收到客户端的查询SQL之后&#xff0c;仅仅只需要对其进行相应的权限验证之后&#xff0c;就会通过Query Cache来查找结果&#xff0c;甚至都不需要经过Optimizer模…

dot product【点积】

&#xff08;1&#xff09;概念 点积在数学中&#xff0c;又称数量积&#xff08;dot product; scalar product&#xff09;&#xff0c;是指接受在实数R上的两个向量并返回一个实数值标量的二元运算。 两个向量a [a1, a2,…, an]和b [b1, b2,…, bn]的点积定义为&#xff…

点云数据集ShapeNet

目录 1. 数据采集的作者 2. 下载shapenet数据集的代码 3. 数据特点 3.1 每个数字文件夹代表一个类别 3.2 synsetoffset2category.txt 3.3 train_test_split文件夹 3.4 pts点云文件 3.6 seg分割类别文件 1. 数据采集的作者 article{yi2016scalable,title{A scalable ac…

idea导入eclipse项目的时候,Java图标变成黄色小J了,怎么解决?

凯哥今天导入一个15年时候写的小项目&#xff0c;当时使用的是eclipse写的。最近好几年都在使用idea&#xff0c;习惯了idea的&#xff0c;在用eclipse&#xff0c;不习惯&#xff0c;不顺手&#xff0c;就导入到idea中。发现&#xff0c;Java文件的图标变成了黄色的J。如下图&…

【Linux】详解套接字编程

文章目录网络套接字1.端口号1.1认识端口号1.2端口号VS PID2.TCP与UDP协议3.网络字节序4.socket编程4.1常用接口4.2sockaddr结构4.3.socket接口的底层工作4.4字符串IP VS 整形IP4.5 bind与INADDR_ANY5.UDP聊天服务器5.1va_start和va_end5.2vsnprintf函数5.3自定义日志类5.4UDP服…