JUC（五）

已于 2024-04-02 19:40:12 修改
阅读量340 收藏 3
点赞数 4
分类专栏： java学习 文章标签： java
于 2024-03-29 22:49:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/keleid/article/details/137158441
版权

1、CAS

        compare and swap，比较并交换，实现并发算法时常用到的一种技术，它包含三个操作数--内存位置、预期原值以及更新值。执行CAS操作的时候，将内存位置的值和预期原值比较：如果匹配，那么处理器会自动将该位置值更新为新值，如果不匹配，处理器不做任何处理，多个线程同时执行CAS操作只有一个会成功。

        CAS有3个操作数，位置内存值V，旧的预期值A，要修改的更新值B，只有V和A的值型同时，才会将V修改成B，否则什么都不做处理或者重来，重来的这种行为是叫做----自旋。

public class CasDemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(5);
​
        boolean b = atomicInteger.compareAndSet(5, 2021);//如果期望值达到了，就更新，否则不更新
        System.out.println(atomicInteger.get()+"\t 修改成功与否："+b);
​
        boolean b1 = atomicInteger.compareAndSet(5, 1024);
        System.out.println(atomicInteger.get()+"\t 修改成功与否："+b1);
    }
}

        CAS是JDK提供的非阻塞原子性操作，它通过硬件保证了比较-----更新的原子性。它是非阻塞的且自身具有原子性，也就是说这玩意效率更高且通过硬件保证，说明这玩意更可靠。

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

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

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

原子引用

其实上面就有这个，只不过是interger类型的，现在换一个

public class AtomicReferenceDemo {
    public static void main(String[] args) {
        AtomicReference<User> userAtomicReference = new AtomicReference<>();
​
        User z3 = new User("z3", 22);
        User li4 = new User("li4",24);
​
        userAtomicReference.set(z3);
​
        boolean b = userAtomicReference.compareAndSet(z3, li4);
        System.out.println("\t"+userAtomicReference.get().toString()+"修改成功"+b);
​
        boolean b1 = userAtomicReference.compareAndSet(z3, li4);
        System.out.println("\t"+userAtomicReference.get().toString()+"修改成功:"+b1);
    }
}
​
#自己加Lombok注解
class User{
    String userName;
    int age;
}

1.1、自旋锁

        CAS 是实现自旋锁的基础，CAS 利用 CPU指令保证了操作的原子性，以达到锁的效果，至于自旋呢，看字面意思也很明白，自己旋转。是指尝试获取锁的线程不会立即阻寒，而是采用循环的方式去尝试获取锁，当线程发现锁被占用时，会不断循环判断锁的状态，直到获取。这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU

public class SpinLockDemo {
  AtomicReference<Thread> atomicReference = new AtomicReference<>();
  public void lock(){
    Thread thread = Thread.currentThread();
    System.out.println(Thread.currentThread().getName()+"\t come in");
    while (!atomicReference.compareAndSet(null,thread)){
​
    }
  }
  public void unlock(){
    Thread thread = Thread.currentThread();
    atomicReference.compareAndSet(thread,null);
    System.out.println(Thread.currentThread().getName()+"\t unlock");
  }
​
  public static void main(String[] args) {
    SpinLockDemo spinLockDemo = new SpinLockDemo();
    new Thread(() -> {
      spinLockDemo.lock();
      try {
        Thread.sleep(5000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      spinLockDemo.unlock();
    }, "t1").start();
​
    try {
      TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    new Thread(() -> {
      spinLockDemo.lock();
      try {
        Thread.sleep(1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      spinLockDemo.unlock();
    }, "t2").start();
  }
}
​

2、原子操作类

2.1、基本类型原子类

代表AtomicInteger、AtomicBoolean、AtomicLong。常用API如下

  1. public final int get() 获取当前值

  2. public final int getAndSet(int newValue) 获取当前值，并设置新的值

  3. public final int getAndIncrement() 获取当前值并且自增

  4. public final int getAndDecrement() 获取当前值并且自减

  5. public final int getAndAdd(int delta) 获取当前值，并且加上预期值

  6. public final boolean compareAndSet(int expect, int update) 如果输入值和预期值相等，以原子的方式将该值替换为输入值

public class Jiben {
​
    public static final int SIZE =50 ;
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(SIZE);
        number number = new number();
        for (int i = 0; i < SIZE; i++) {
            new Thread(() -> {
                try {
                    for (int j = 0; j < 1000; j++) {
                        number.add();
                    }
                } finally {
                    countDownLatch.countDown();//每个线程执行完之后，countDownLatch减一
                }
            }, String.valueOf(i)).start();
        }
​
        countDownLatch.await();//等待上面的线程全部执行完
​
        System.out.println(Thread.currentThread().getName() + "\t" + number.atomicInteger.get());
    }
​
}
class number{
    AtomicInteger atomicInteger = new AtomicInteger();
​
    public void add() {
        atomicInteger.getAndIncrement();
    }
}
​

2.2、数组类型原子类

AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray

public class AtomicIntegerArrayDemo
{
    public static void main(String[] args)
    {
        AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(new int[5]);
        //AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(5);
        //AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(new int[]{1,2,3,4,5});
​
        for (int i = 0; i <atomicIntegerArray.length(); i++) {
            System.out.println(atomicIntegerArray.get(i));
        }
​
        System.out.println();
​
        int tmpInt = 0;
​
        tmpInt = atomicIntegerArray.getAndSet(0,1122);
        System.out.println(tmpInt+"\t"+atomicIntegerArray.get(0));
​
        tmpInt = atomicIntegerArray.getAndIncrement(0);
        System.out.println(tmpInt+"\t"+atomicIntegerArray.get(0));
    }
}

2.3、引用类型原子类

AtomicReference、AtomicStampdReference、AtomicMarkableReference

public class AtomicMarkableReferenceDemo
{
    static AtomicMarkableReference markableReference = new AtomicMarkableReference(100,false);
​
    public static void main(String[] args)
    {
        new Thread(() -> {
            boolean marked = markableReference.isMarked();
            System.out.println(Thread.currentThread().getName()+"\t"+"默认标识："+marked);
            //暂停1秒钟线程,等待后面的T2线程和我拿到一样的模式flag标识，都是false
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            markableReference.compareAndSet(100,1000,marked,!marked);
        },"t1").start();
​
        new Thread(() -> {
            boolean marked = markableReference.isMarked();
            System.out.println(Thread.currentThread().getName()+"\t"+"默认标识："+marked);
​
            try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
            boolean b = markableReference.compareAndSet(100, 2000, marked, !marked);
            System.out.println(Thread.currentThread().getName()+"\t"+"t2线程CASresult： "+b);
            System.out.println(Thread.currentThread().getName()+"\t"+markableReference.isMarked());
            System.out.println(Thread.currentThread().getName()+"\t"+markableReference.getReference());
        },"t2").start();
    }
}

2.4、对象的属性修改原子类

        AtomicIntegerFiledUpdater原子更新对象中int类型字段的值，AtomicLongFieldUpdater原子更新对象中Long类型字段的值，AtomicRefenceFieldUpdater原子更新引用类型字段的值，局部麻醉和全麻醉的区别

        使用要求：更新的对象属性必须要使用public volatile修饰，因为对象的属性修改类型原子类都是抽象类，所以每次使用都必须使用静态方法newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。

class BankAccount//资源类
{
    String bankName = "CCB";
​
    //更新的对象属性必须使用 public volatile 修饰符。
    public volatile int money = 0;//钱数
​
    public void add()
    {
        money++;
    }
​
    //因为对象的属性修改类型原子类都是抽象类，所以每次使用都必须
    // 使用静态方法newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。
​
    AtomicIntegerFieldUpdater<BankAccount> fieldUpdater =
            AtomicIntegerFieldUpdater.newUpdater(BankAccount.class,"money");
​
    //不加synchronized，保证高性能原子性，局部微创小手术
    public void transMoney(BankAccount bankAccount)
    {
        fieldUpdater.getAndIncrement(bankAccount);
    }
​
​
}
​
/**
 * 以一种线程安全的方式操作非线程安全对象的某些字段。
 *
 * 需求：
 * 10个线程，
 * 每个线程转账1000，
 * 不使用synchronized,尝试使用AtomicIntegerFieldUpdater来实现。
 */
public class AtomicIntegerFieldUpdaterDemo
{
    public static void main(String[] args) throws InterruptedException
    {
        BankAccount bankAccount = new BankAccount();
        CountDownLatch countDownLatch = new CountDownLatch(10);
​
        for (int i = 1; i <=10; i++) {
            new Thread(() -> {
                try {
                    for (int j = 1; j <=1000; j++) {
                        //bankAccount.add();
                        bankAccount.transMoney(bankAccount);
                    }
                } finally {
                    countDownLatch.countDown();
                }
            },String.valueOf(i)).start();
        }
​
        countDownLatch.await();
​
        System.out.println(Thread.currentThread().getName()+"\t"+"result: "+bankAccount.money);
    }
}

2.5、原子操作类增强类

DoubleAccumulator、DoubleAdder、LongAccumulator、LongAdder

  1. public void add(long x) 将当前的value加X

  2. public void increment() 将当前的value加1

  3. public void decrement() 将当前的value减1

  4. public long sum() 返回当前值，高 不时精确值 不高 时精确值

  5. public void reset() 将value重置为0 没有并发更新的情况下使用

  6. public long sumThenReset() 获取当前的value 将value重置为0

LongAdder只能用来计算加法，且从零开始计算，LongAccumulator提供了自定义的函数操作

class ClickNumber //资源类
{
    int number = 0;
    public synchronized void clickBySynchronized()
    {
        number++;
    }
​
    AtomicLong atomicLong = new AtomicLong(0);
    public void clickByAtomicLong()
    {
        atomicLong.getAndIncrement();
    }
​
    LongAdder longAdder = new LongAdder();
    public void clickByLongAdder()
    {
        longAdder.increment();
    }
​
    LongAccumulator longAccumulator = new LongAccumulator((x,y) -> x + y,0);
    public void clickByLongAccumulator()
    {
        longAccumulator.accumulate(1);
    }
​
}
​
/**
 * 需求： 50个线程，每个线程100W次，总点赞数出来
 */
public class AccumulatorCompareDemo
{
    public static final int _1W = 10000;
    public static final int threadNumber = 50;
​
    public static void main(String[] args) throws InterruptedException
    {
        ClickNumber clickNumber = new ClickNumber();
        long startTime;
        long endTime;
​
        CountDownLatch countDownLatch1 = new CountDownLatch(threadNumber);
        CountDownLatch countDownLatch2 = new CountDownLatch(threadNumber);
        CountDownLatch countDownLatch3 = new CountDownLatch(threadNumber);
        CountDownLatch countDownLatch4 = new CountDownLatch(threadNumber);
​
        startTime = System.currentTimeMillis();
        for (int i = 1; i <=threadNumber; i++) {
            new Thread(() -> {
                try {
                    for (int j = 1; j <=100 * _1W; j++) {
                        clickNumber.clickBySynchronized();
                    }
                } finally {
                    countDownLatch1.countDown();
                }
            },String.valueOf(i)).start();
        }
        countDownLatch1.await();
        endTime = System.currentTimeMillis();
        System.out.println("----costTime: "+(endTime - startTime) +" 毫秒"+"\t clickBySynchronized: "+clickNumber.number);
​
        startTime = System.currentTimeMillis();
        for (int i = 1; i <=threadNumber; i++) {
            new Thread(() -> {
                try {
                    for (int j = 1; j <=100 * _1W; j++) {
                        clickNumber.clickByAtomicLong();
                    }
                } finally {
                    countDownLatch2.countDown();
                }
            },String.valueOf(i)).start();
        }
        countDownLatch2.await();
        endTime = System.currentTimeMillis();
        System.out.println("----costTime: "+(endTime - startTime) +" 毫秒"+"\t clickByAtomicLong: "+clickNumber.atomicLong.get());
​
​
        startTime = System.currentTimeMillis();
        for (int i = 1; i <=threadNumber; i++) {
            new Thread(() -> {
                try {
                    for (int j = 1; j <=100 * _1W; j++) {
                        clickNumber.clickByLongAdder();
                    }
                } finally {
                    countDownLatch3.countDown();
                }
            },String.valueOf(i)).start();
        }
        countDownLatch3.await();
        endTime = System.currentTimeMillis();
        System.out.println("----costTime: "+(endTime - startTime) +" 毫秒"+"\t clickByLongAdder: "+clickNumber.longAdder.sum());
​
        startTime = System.currentTimeMillis();
        for (int i = 1; i <=threadNumber; i++) {
            new Thread(() -> {
                try {
                    for (int j = 1; j <=100 * _1W; j++) {
                        clickNumber.clickByLongAccumulator();
                    }
                } finally {
                    countDownLatch4.countDown();
                }
            },String.valueOf(i)).start();
        }
        countDownLatch4.await();
        endTime = System.currentTimeMillis();
        System.out.println("----costTime: "+(endTime - startTime) +" 毫秒"+"\t clickByLongAccumulator: "+clickNumber.longAccumulator.get());
    }
}

3、ThreadLocal

        ThreadLocal提供线程局部变量。这些变量与正常的变量不同，因为每一个线程在访问ThreadLocal实例的时候（通过其get或 set方法）都有自己的、独立初始化的变量副本。ThreadLocal实例通常是类中的私有静态字段，使用它的目的是希望将状态（例如，用户ID或事务ID）与线程关联起来。

  1. protected T initialValue() 返回此线程局部变量的当前线程的“初始值”

  2. public T get() 返回此线程局部变量的当前线程副本中的值。如果变量没有当前线程的值，则首先将其初始化为调用方法返回 initialValue 的值

  3. public void set(T value) 此线程局部变量的当前线程副本设置为指定值。大多数子类不需要重写此方法，只需依靠该 initialValue 方法来设置线程局部变量的值。

  4. public void remove() 删除此线程局部变量的当前线程值。

  5. public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) 创建线程局部变量

class House //资源类
{
    int saleCount = 0;
    public synchronized void saleHouse()
    {
        ++saleCount;
    }
​
    /*ThreadLocal<Integer> saleVolume = new ThreadLocal<Integer>(){
        @Override
        protected Integer initialValue()
        {
            return 0;
        }
    };*/
    ThreadLocal<Integer> saleVolume = ThreadLocal.withInitial(() -> 0);
    public void saleVolumeByThreadLocal()
    {
        saleVolume.set(1+saleVolume.get());
    }
}
​
/**
 * @auther zzyy
 * @create 2021-12-31 15:46
 *
 * 需求1： 5个销售卖房子，集团高层只关心销售总量的准确统计数。
 *
 * 需求2： 5个销售卖完随机数房子，各自独立销售额度，自己业绩按提成走，分灶吃饭，各个销售自己动手，丰衣足食
 *
 *
 */
public class ThreadLocalDemo
{
    public static void main(String[] args) throws InterruptedException
    {
​
        House house = new House();
​
        for (int i = 1; i <=5; i++) {
            new Thread(() -> {
                int size = new Random().nextInt(5)+1;
                try {
                    for (int j = 1; j <=size; j++) {
                        house.saleHouse();
                        house.saleVolumeByThreadLocal();
                    }
                    System.out.println(Thread.currentThread().getName()+"\t"+"号销售卖出："+house.saleVolume.get());
                } finally {
                    house.saleVolume.remove();
                }
            },String.valueOf(i)).start();
        };
​
        //暂停毫秒
        try { TimeUnit.MILLISECONDS.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); }
​
        System.out.println(Thread.currentThread().getName()+"\t"+"共计卖出多少套： "+house.saleCount);
    }
}

        这种是new 的方式，最后不删除线程中的数据也可以，但是如果是使用的是线程池的话不移除的话会出现问题---共用数据的问题。

        必须回收自定义的ThreadLocal 变量，尤其在线程池场景下，线程经常会被复用，如果不清理自定义的 ThreadLocal 变量，可能会影响后续业务逻辑和造成内存泄露等问题。尽量在代理中使用try-finally块进行回收。

class MyData
{
    ThreadLocal<Integer> threadLocalField = ThreadLocal.withInitial(() -> 0);
    public void add()
    {
        threadLocalField.set(1 + threadLocalField.get());
    }
}
​
​
public class ThreadLocalDemo2
{
    public static void main(String[] args) throws InterruptedException
    {
        MyData myData = new MyData();
​
        ExecutorService threadPool = Executors.newFixedThreadPool(3);
​
        try
        {
            for (int i = 0; i < 10; i++) {
                threadPool.submit(() -> {
                    try {
                        Integer beforeInt = myData.threadLocalField.get();
                        myData.add();
                        Integer afterInt = myData.threadLocalField.get();
                        System.out.println(Thread.currentThread().getName()+"\t"+"beforeInt:"+beforeInt+"\t afterInt: "+afterInt);
                    } finally {
                        myData.threadLocalField.remove();
                    }
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool.shutdown();
        }
    }
}

3.1、内存泄露

        什么是内存泄漏，不再会被使用的对象或者变量占用的内存不能被回收，就是内存泄露。

3.2、强引用

        当内存不足，JVM开始垃圾回收，对于强引用的对象，就算是出现了OOM也不会对该对象进行回收，死都不收。 ​ 强引用是我们最常见的普通对象引周，只要还有强引用指向一个对象，就能表明对象还 “活着”，垃圾收集器不会碰这种对象。在Java 中最常见的就是强引用，把一个对象赋给一个引用变量，这个引用变量就是一个强引用。当一个对象被强引用变量引用时，它处于可达状态，它是不可能被垃圾回收机制回收的，即使该对象以后永远都不会被用到，JVM也不会回收。因此强引用是造成Java内存泄漏的主要原因之一 ​ 对于一个普通的对象，如果没有其他的引用关系，只要超过了引用的作用域或者显式地将相应（强）引用赋值为null, 一般认为就是可以被垃圾收集的了(当然具体回收时机还是要看垃圾收集策略)。

3.3、软引用

        软引用是一种相对强引用弱化了一些的引用，需要用java.lang.ref.SoftReference类来实现，可以让对象豁免一些垃圾收集。对于只有软引用的对象来说，

  1. 当系统内存充足时它不会被回收，

  2. 当系统内存不足时它会被回收。

    软引用通常用在对内存敏感的程序中，比如高速缓存就有用到软引用，内存够用的时候就保留，不够用就回收！

3.4、弱引用

        弱引用需要使用java.long.ref.WeakReference类来实现，它比软引用的生命周期更短，对于只有弱引用的对象来说，只要垃圾回收机制一运行，不管JVM的内存是否够用，都会回收对象占用的内存。

3.5、虚引用

虚引用必须和引用队列 (ReferenceQueue)联合使用

        虚引用需要java.lang ref.PhantorReference类来实现，顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收，它不能单独使用也不能通过它访问对象，虚引用必须和引用队列 (ReferenceQueue)联合使用。

PhantomReference的get方法总是返回null

        虛引用的主要作用是跟踪对象被垃圾回收的状态。仅仅是提供了一种确保对象被 finalize以后，做某些事情的通知机制。PhantomReference的get方法总是返回null，因此无法访问对应的引用对象。

处理监控通知使用

        换句话说，设置虚引用关联对象的唯一目的，就是在这个对象被收集器回收的时候收到一个系统通知或者后续添加进一步的处理，用来实现比finalize机制更灵活的回收操作

3.6、总结

        ThreeLocal并不解决线程之间数据共项的数据问题，适用于变量在线程间隔离且在方法之间共享的场景，通过隐式的在不同的线程内创建独立实例副本避免了实例线程安全问题，每一个线程持有一个只属于自己的专属Map并维护ThreadLocal对象与具体实例的映射，该Map由于只被持有它的线程访问，所以不存在线程的安全以及锁的问题。

        ThreadLocalMap的Entity对ThreadLocal的引用为弱引用，避免啦ThreadLocal对象无法被回收的问题都会通过ExpungeStaleEntity、cleanSomeSlots、replaceStaleEntitry这三个方法回收键为null的Entitry对象的值（即为具体实例）以及Entry对象本身从而防止内存泄漏，属于安全加固的方法。

蒋一清
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC个人笔记1
08-04
在Java并发编程中，"JUC个人笔记1"主要探讨了多线程并发控制的一些核心概念和技巧。首先，遵循高内聚低耦合的原则，将线程的操作与资源类进行解耦，使得代码结构更加清晰，易于维护。在多线程交互中，特别是涉及到`...
java并发编程专题（五）----详解（JUC）ReentrantLock
08-18
Java并发编程中的ReentrantLock是Java并发包（java.util.concurrent，简称JUC）中的一个重要的锁机制，它是Lock接口的一个具体实现，提供了比synchronized更强大的锁定功能和更细粒度的控制。ReentrantLock的主要...
JUC并发编程视频教程
11-28
视频详细讲解，需要的小伙伴自行网盘下载，链接见附件，永久有效...进程与线程第三章：Java 线程第四章：共享模型之管程第五章：共享模型之内存第六章：共享模型之无锁第七章：共享模型之不可变第八章：共享模型之工具
jucproject:JUC进阶
03-08
五、最佳实践 1. **避免过度使用synchronized**：尽可能使用JUC提供的并发工具，它们通常能提供更好的性能和更高的灵活性。 2. **合理使用线程池**：根据业务需求定制线程池大小，避免创建大量线程导致的系统资源...
JUC2课程设计培训课件.pdf
10-30
#### 五、执行阶段的微程序设计 执行阶段涉及对指令进行解码并执行相应的操作。 ##### INC指令的微程序设计 - **微地址**：071 - **微指令**：1A700E50 - **微命令**：INC, SVce, PSWce INC指令用于对寄存器中的...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1258
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
golang 接口
m0_70982551的博客
07-24 807
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 364
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 490
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 2393
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1562
Java实现拼图小游戏
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 282
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 353
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
[Jenkins]jenkins-cli.jar调用用户token启动任务
China_Yanhy的博客
07-23 653
jenkins-cli.jar调用用户token启动任务
学习笔记---java篇（0723）
m0_70630166的博客
07-23 801
java、数据类型、循环、选择等
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 112
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
19.jdk源码阅读之FutureTask
前端、移动端、后端源码级底层原理分享
07-25 842
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
Jvm基础（一）
G81948577的博客
07-19 950
本地方法就是不使用java编写的，比如C++编写的程序，只是需要传递参数。
Java的集合框架（Collection Framework）中的Iterator接口详解
m0_49013185的博客
07-22 636
在Java中，将Iterator定义为接口是一种设计上的选择，目的是提供一个统一的迭代机制，使不同类型的集合都能以一致的方式进行遍历。以下是将Iterator以下是IteratorE next();将Iterator定义为接口的主要目的是提供一个统一、灵活且可扩展的迭代机制。通过这种方式，Java集合框架能够支持多种类型的集合，并且客户端代码能够以一致的方式使用这些集合。这种设计不仅简化了集合的使用，还提高了代码的可维护性和可扩展性。
Java并发编程详解：JUC与面试必备知识
"这篇资源主要介绍了Java并发编程中的重要组件JUC，以及相关的并发编程概念，包括进程和线程的定义、线程的状态和相关方法如wait、notify、notifyAll等。" Java并发编程（JUC）是Java.util.concurrent包及其相关子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值