AQS实现之Semaphore、CountDownLatch、CyclicBarrier分析

最新推荐文章于 2024-08-03 17:05:14 发布
最新推荐文章于 2024-08-03 17:05:14 发布
阅读量165 收藏
点赞数
分类专栏： 并发 文章标签： 多线程 java 并发编程 java.util.concurrent
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heng_zou/article/details/117228656
版权

对基于AQS的一些线程并发工具的分析

Semaphore

Semaphore维持一组信号量，信号量的大小代表线程并发上限，超过上限后线程将被阻塞直到其它线程释放信号，该类可用于控制并发大小，详见下面例子，例子中定义了一个持有3个信号量的Semaphore,同时启动12个线程去竞争这个三个信号量，竞争成功后打印提示信息

package com.test.sync;

import lombok.SneakyThrows;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreTest {
    static class MyTask implements  Runnable{
        private Semaphore semaphore;
        private DateFormat df = new SimpleDateFormat("HH:mm:ss");

        public MyTask(Semaphore semaphore) {
            this.semaphore = semaphore;
        }

        @SneakyThrows
        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println("时间："+df.format(new Date())+"，任务："+Thread.currentThread().getName()+"执行中···");
                TimeUnit.SECONDS.sleep(2);
            }finally {
                semaphore.release();
            }
        }
    }

    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);
        ExecutorService es = Executors.newFixedThreadPool(12);
        for (int i = 0; i < 12; i++) {
            es.submit(new MyTask(semaphore));
        }
        es.shutdown();
    }
}

测试结果如下：可发现每隔两秒钟有3个线程完成打印工作，12个线程前后间隔了6秒钟完成所有打印任务

时间：17:52:58，任务：pool-1-thread-1执行中···
时间：17:52:58，任务：pool-1-thread-2执行中···
时间：17:52:58，任务：pool-1-thread-3执行中···
时间：17:53:00，任务：pool-1-thread-4执行中···
时间：17:53:00，任务：pool-1-thread-5执行中···
时间：17:53:00，任务：pool-1-thread-6执行中···
时间：17:53:02，任务：pool-1-thread-7执行中···
时间：17:53:02，任务：pool-1-thread-9执行中···
时间：17:53:02，任务：pool-1-thread-8执行中···
时间：17:53:04，任务：pool-1-thread-10执行中···
时间：17:53:04，任务：pool-1-thread-11执行中···
时间：17:53:04，任务：pool-1-thread-12执行中···

源码逻辑相对较为简单：主要是构造器初始化了锁数量，每次acquire将锁数量-1，如果大于等于0，则标识获取锁成功，否则标识锁已用完进入阻塞状态，当有线程调用release时将释放锁并将所数量+1，并通知唤醒队列线程。

CountDownLatch

直译是倒计时启动：实现多个线程间执行同步，假设有n个线程各自再执行任务，但是他们之间需要在执行到指定地方时等待其它线程也到达各自指定的地方后再一起执行，可以使用该类实现步调控制，参见下面例子：

public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService es = Executors.newFixedThreadPool(5);
        CountDownLatch cdl = new CountDownLatch(1);
        for (int i = 0; i < 5; i++) {
            es.submit(()->{
                try {
                    //随机休眠500~2500模拟各线程任务耗时
                    TimeUnit.MILLISECONDS.sleep((int)(Math.random()*2000+500));
                    System.out.println("线程："+Thread.currentThread().getName()+"已到达指定地点，等待其它线程准备各自指定地点后再执行");
                    cdl.await();
                    System.out.println("线程："+Thread.currentThread().getName()+"已越过指定地点继续执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        TimeUnit.SECONDS.sleep(5);
        cdl.countDown();
        es.shutdown();
    }
}

测试结果：可以看到所有线程都到达指定点后开始等待其它线程到达，主线程通过countDown让所有线程都继续执行，这里主线程为保证所有子线程都已到达指定点通过休眠5s实现，实际上完全可以让子线程自己来判断各自线程是否已经到达指定点，参见下面例子。

线程：pool-1-thread-4已到达指定地点，等待其它线程准备各自指定地点后再执行
线程：pool-1-thread-1已到达指定地点，等待其它线程准备各自指定地点后再执行
线程：pool-1-thread-5已到达指定地点，等待其它线程准备各自指定地点后再执行
线程：pool-1-thread-2已到达指定地点，等待其它线程准备各自指定地点后再执行
线程：pool-1-thread-3已到达指定地点，等待其它线程准备各自指定地点后再执行
线程：pool-1-thread-4已越过指定地点继续执行
线程：pool-1-thread-3已越过指定地点继续执行
线程：pool-1-thread-2已越过指定地点继续执行
线程：pool-1-thread-5已越过指定地点继续执行
线程：pool-1-thread-1已越过指定地点继续执行

相比第一种控制方式，下面这种初始化计数器为线程总数量，每个线程再到达指点地点后执行countDown将计数器-1后执行await进行等待，最后一个线程到达后计数值-1为0后将通知所有被阻塞的线程继续执行，同时由于计数器为0，因此await将不在阻塞本本线程。

public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService es = Executors.newFixedThreadPool(5);
        CountDownLatch cdl = new CountDownLatch(5);
        for (int i = 0; i < 5; i++) {
            es.submit(()->{
                try {
                    //随机休眠500~2500模拟各线程任务耗时
                    TimeUnit.MILLISECONDS.sleep((int)(Math.random()*2000+500));
                    System.out.println("线程："+Thread.currentThread().getName()+"已到达指定地点，等待其它线程准备各自指定地点后再执行");
                    cdl.countDown();
                    cdl.await();
                    System.out.println("线程："+Thread.currentThread().getName()+"已越过指定地点继续执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        es.shutdown();
    }
}

测试结果如下

线程：pool-1-thread-1已到达指定地点，等待其它线程准备各自指定地点后再执行
线程：pool-1-thread-3已到达指定地点，等待其它线程准备各自指定地点后再执行
线程：pool-1-thread-2已到达指定地点，等待其它线程准备各自指定地点后再执行
线程：pool-1-thread-5已到达指定地点，等待其它线程准备各自指定地点后再执行
线程：pool-1-thread-4已到达指定地点，等待其它线程准备各自指定地点后再执行
线程：pool-1-thread-4已越过指定地点继续执行
线程：pool-1-thread-1已越过指定地点继续执行
线程：pool-1-thread-5已越过指定地点继续执行
线程：pool-1-thread-3已越过指定地点继续执行
线程：pool-1-thread-2已越过指定地点继续执行

对比第一种的区别在于第二种能再第一时间知晓是否所有线程都已经到达指定点并及时唤醒所有阻塞线程继续执行，这是自动的，而第一种则必须要通过一些检测才能发现是否全部线程已到达，但它可以控制其它线程何时唤醒执行。

CyclicBarrier

循环壁垒：实现的功能和CountDownLatch很相似，都是让一组线程达到各自指定地点后相互等待，待最后一个线程到达后再同时执行，与CountDownLatch不同的是CyclicBarrier的可以指定多处地点让一组线程相互等待，同时CyclicBarrier构造器提供了一个Runnable参数barrierAction，可以让最后一个到达指定地点的线程执行该barrierAction。参见如下例子：3个线程完成相同的任务，任务分为3部分，要求每个线程完成第一部分任务后等待其它线程完成第一部分任务后再执行第二部分任务；同理要求先完成第二部分任务的线程等待其它线程完成第二部分任务，最后完成第三部分任务

public class CyclicBarrierTest {
    public static void main(String[] args) {
        CyclicBarrier cb = new CyclicBarrier(3, () -> {
            System.out.println(Thread.currentThread().getName() + "last barrier passed!");
        });
        ExecutorService es = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 3; i++) {
            es.submit(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + "执行完成任务第一部分，等待其它线程完成第一部分");
                    cb.await();
                    System.out.println(Thread.currentThread().getName() + "执行完成任务第二部分，等待其它线程完成第二部分");
                    cb.await();
                    System.out.println(Thread.currentThread().getName() + "执行完成任务第三部分，等待其它线程完成第三部分");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            });
        }
    }
}

测试结果：各个线程按照要求再完成任务一部分后等待其它线程，重测试结果可以发现，每次最后一个完成部分的线程执行barrierAction并会最新执行下个部分任务，说明最后一个到达指定点的任务负责执行barrierAction并负责唤醒等待的任务

pool-1-thread-1执行完成任务第一部分，等待其它线程完成第一部分
pool-1-thread-2执行完成任务第一部分，等待其它线程完成第一部分
pool-1-thread-3执行完成任务第一部分，等待其它线程完成第一部分
pool-1-thread-3last barrier passed!
pool-1-thread-3执行完成任务第二部分，等待其它线程完成第二部分
pool-1-thread-2执行完成任务第二部分，等待其它线程完成第二部分
pool-1-thread-1执行完成任务第二部分，等待其它线程完成第二部分
pool-1-thread-1last barrier passed!
pool-1-thread-1执行完成任务第三部分，等待其它线程完成第三部分
pool-1-thread-3执行完成任务第三部分，等待其它线程完成第三部分
pool-1-thread-2执行完成任务第三部分，等待其它线程完成第三部分

虽然与CountDownLatch很相似，但实际上二者逻辑完全不一样。

CyclicBarrier等待入口方法：await

    public int await() throws InterruptedException, BrokenBarrierException {
        try {
            return dowait(false, 0L);
        } catch (TimeoutException toe) {
            throw new Error(toe); // cannot happen
        }
    }

dowait源码如下：

    private int dowait(boolean timed, long nanos)
        throws InterruptedException, BrokenBarrierException,
               TimeoutException {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
        	//引用当前head，在后续过程中由于当前线程释放锁或所有线程已到达会更新generation导致g!=generation
            final Generation g = generation;
            //检测是否broken,阻塞中断或barrierAction异常将导致此处broken=true;
            if (g.broken)
                throw new BrokenBarrierException();
			//响应中断并抛出中断异常，其它阻塞线程将抛出BrokenBarrierException
            if (Thread.interrupted()) {
                breakBarrier();
                throw new InterruptedException();
            }

            int index = --count;
            if (index == 0) {  // 如果最后一个线程到达指定点，如果存在barrierCommand将执行该barrierCommand
                boolean ranAction = false;
                try {
                    final Runnable command = barrierCommand;
                    if (command != null)
                        command.run();
                    ranAction = true;
                    //进入下一个指定点进行相互等待
                    nextGeneration();
                    return 0;
                } finally {
                	//执行barrierCommand抛出异常则将breakBarrier
                    if (!ranAction)
                        breakBarrier();
                }
            }
            for (;;) {
                try {
                	//非超时等待
                    if (!timed)
                        trip.await();
                    //超时等待
                    else if (nanos > 0L)
                        nanos = trip.awaitNanos(nanos);
                } catch (InterruptedException ie) {
                	//阻塞中断将broken并抛出中断异常，其它线程将抛出BrokenBarrierException
                    if (g == generation && ! g.broken) {
                        breakBarrier();
                        throw ie;
                    } else {
                        Thread.currentThread().interrupt();
                    }
                }
                if (g.broken)
                    throw new BrokenBarrierException();

                if (g != generation)
                    return index;

                if (timed && nanos <= 0L) {
                    breakBarrier();
                    throw new TimeoutException();
                }
            }
        } finally {
            lock.unlock();
        }
    }

上述流程分以下几个分支(不讨论parties!=threads的情况)

  • 没有中断请求
    • 如果barrierAction没有发生异常，则将按照正常流程工作，不做说明
    • 如果barrierAction发生异常，这件导致执行barrierAction的线程抛出该异常并导致其它阻塞线程抛出BrokenBarrierException，测试代码如下：
public static void main(String[] args) {
        CyclicBarrier cb = new CyclicBarrier(3, () -> {
            System.out.println(Thread.currentThread().getName() + "last barrier passed!");
            throw new Error("error");
        });
        ExecutorService es = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 3; i++) {
            es.submit(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + "执行完成任务第一部分，等待其它线程完成第一部分");
                    cb.await();
                    System.out.println(Thread.currentThread().getName() + "执行完成任务第二部分，等待其它线程完成第二部分");
                    cb.await();
                    System.out.println(Thread.currentThread().getName() + "执行完成任务第三部分，等待其它线程完成第三部分");
                } catch (Throwable e) {
                    e.printStackTrace();
                    throw new Error(e);
                }
            });
        }
    }

测试结果：BrokenBarrierException的个数为总线数-1个，剩余一个异常是barrierAction抛出的运行时异常。

pool-1-thread-1执行完成任务第一部分，等待其它线程完成第一部分
pool-1-thread-3执行完成任务第一部分，等待其它线程完成第一部分
pool-1-thread-2执行完成任务第一部分，等待其它线程完成第一部分
pool-1-thread-1last barrier passed!
java.util.concurrent.BrokenBarrierException
	···省略异常堆栈信息
	at java.lang.Thread.run(Thread.java:748)
java.util.concurrent.BrokenBarrierException
	···省略异常堆栈信息
	at java.lang.Thread.run(Thread.java:748)
java.lang.Error: error
	···省略异常堆栈信息
	at java.lang.Thread.run(Thread.java:748)
  • 存在中断请求
    • 在进入await前发生中断请求或阻塞期间发生中断请求，则该线程进入await后或唤醒后将抛出中断异常，被阻塞线程将抛出BrokenBarrierException，还未到达await地点的线程将也将抛出BrokenBarrierException异常，测试代码如下：
    public static void main(String[] args) {
        CyclicBarrier cb = new CyclicBarrier(3, () -> {
            System.out.println(Thread.currentThread().getName() + "last barrier passed!");
        });
        ExecutorService es = Executors.newFixedThreadPool(3);
        AtomicInteger ai = new AtomicInteger(0);
        for (int i = 0; i < 3; i++) {
            es.submit(() -> {
                try {
                    if(ai.incrementAndGet() == 2){
                        //模拟第二个线程进入wait前发生中断
                        Thread.currentThread().interrupt();
                        System.out.println(Thread.currentThread().getName() + "进入wait前发生中断请求");
                    }
                    System.out.println(Thread.currentThread().getName() + "执行完成任务第一部分，等待其它线程完成第一部分");
                    cb.await();
                    System.out.println(Thread.currentThread().getName() + "执行完成任务第二部分，等待其它线程完成第二部分");
                    cb.await();
                    System.out.println(Thread.currentThread().getName() + "执行完成任务第三部分，等待其它线程完成第三部分");
                } catch (Throwable e) {
                    e.printStackTrace();
                    throw new Error(e);
                }
            });
        }
    }

测试结果：和预期一致

pool-1-thread-1进入wait前发生中断请求
pool-1-thread-1执行完成任务第一部分，等待其它线程完成第一部分
pool-1-thread-3执行完成任务第一部分，等待其它线程完成第一部分
pool-1-thread-2执行完成任务第一部分，等待其它线程完成第一部分
java.util.concurrent.BrokenBarrierException
	···省略异常堆栈信息
	at java.lang.Thread.run(Thread.java:748)
java.util.concurrent.BrokenBarrierException
	···省略异常堆栈信息
	at java.lang.Thread.run(Thread.java:748)
java.lang.InterruptedException
	···省略异常堆栈信息
	at java.lang.Thread.run(Thread.java:748)

CyclicBarrier使用总结：关于CyclicBarrier的两个异常InterruptedException，BrokenBarrierException，前者是线程交互主动要抛出的异常，后者是barrierAction抛出异常或InterruptedException导致其它线程被动抛出的异常。如果想要无视这两个异常(barrierAction中抛出的异常不包括在内)则可以捕获这两个异常后调用reset方法重置barrier信息并循环检测，代码如下：将能正常完成工作。

public class CyclicBarrierTest {
    public static void main(String[] args) {
        CyclicBarrier cb = new CyclicBarrier(3, () -> {
            System.out.println(Thread.currentThread().getName() + "last barrier passed!");
        });
        ExecutorService es = Executors.newFixedThreadPool(3);
        AtomicInteger ai = new AtomicInteger(0);

        for (int i = 0; i < 3; i++) {
            es.submit(() -> {
                if (ai.incrementAndGet() == 2) {
                    //模拟第二个线程进入wait前发生中断
                    Thread.currentThread().interrupt();
                    System.out.println(Thread.currentThread().getName() + "进入wait前发生中断请求");
                }
                System.out.println(Thread.currentThread().getName() + "执行完成任务第一部分，等待其它线程完成第一部分");
                wait(cb);
                System.out.println(Thread.currentThread().getName() + "执行完成任务第二部分，等待其它线程完成第二部分");
                wait(cb);
                System.out.println(Thread.currentThread().getName() + "执行完成任务第三部分，等待其它线程完成第三部分");
            });
        }
        es.shutdown();
    }

    static void wait(CyclicBarrier cb) {
        boolean ex = true;
        do {
            try {
                cb.await();
                ex = false;
            } catch (InterruptedException | BrokenBarrierException e) {
                cb.reset();
            }
        } while (ex);
    }
}
heng_zou
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解高并发编程 - AQS 中的 CountDownLatch、Semaphore 与 CyclicBarrier
学无止境
08-24 277
AQS（AbstractQueuedSynchronizer）是 Java 中用于实现同步器的一个抽象基类。它提供了构建各种同步工具的基础框架，如锁、信号量、倒计时器等。AQS 主要通过一个先进先出（FIFO）的等待队列来管理线程的竞争和等待状态。AQS 的核心思想是基于状态的控制和等待/通知机制。每个 AQS 子类都可以定义一个状态（state），并提供了一些基本方法来操作这个状态，例如获取锁、释放锁等。基于这些方法，AQS 能够实现线程的排他性访问以及线程之间的协调。
Java并发编程一CountDownLatch、CyclicBarrier、Semaphore初使用
12-23
在Java并发编程中，CountDownLatch、CyclicBarrier和Semaphore是三种重要的线程协作工具，它们都基于AbstractQueuedSynchronizer（AQS）框架来实现线程间的同步和协调。AQS是一个内置的锁和同步组件，它为构建高级...
高并发之——浅谈AQS中的CountDownLatch、Semaphore与CyclicBarrier
冰河的专栏
03-18 1553
CountDownLatch 概述 同步辅助类，通过它可以阻塞当前线程。也就是说，能够实现一个线程或者多个线程一直等待，直到其他线程执行的操作完成。使用一个给定的计数器进行初始化，该计数器的操作是原子操作，即同时只能有一个线程操作该计数器。 调用该类await()方法的线程会一直阻塞，直到其他线程调用该类的countDown()方法，使当前计数器的值变为0为止。每次调用该类的countDown()...
深入AQS之Semaphorer & CountDownLatch & CyclicBarrier
沮丧的南瓜
11-22 268
文章目录一、Semaphore介绍1.1 Semaphore 常用方法构造器 一、Semaphore介绍 Semaphore，俗称信号量，它是操作系统中PV操作的原语在java的实现，它也是基于AbstractQueuedSynchronizer实现的。 Semaphore的功能非常强大，大小为1的信号量就类似于互斥锁，通过同时只能有一个线程获取信号量实现。大小为n（n>0）的信号量可以实现限流的功能，它可以实现只能有n个线程同时获取信号量。 PV操作是操作系统一种实现进程互斥与同步的有效方法。P
AQS解密：深入理解 CountDownLatch, Semaphore 和 CyclicBarrier
逆流的小鱼
05-03 1041
CountDownLatch是一种同步工具类，它允许一个或多个线程等待其他线程完成一组操作之后再继续执行。CountDownLatch通过一个计数器实现，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减一。当计数器值降至零时，意味着所有的线程都完成了任务，等待的线程就可以恢复执行任务。Semaphore，也称为信号量，是用于控制同时访问某个特定资源的操作数量的同步工具，它管理一系列许可（permits）。
java实现管程之AQS以及ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier
weixin_36279234的博客
12-31 757
管程 管程是管理共享变量和对共享变量操作的过程；上文讲解了synchronized在jvm层面实现了MESA管程模型，本文阐述AQS在java层面实现MESA管程模型 AQS--AbstractQueuedSynchronizer AQS是java层面实现管程的同步队列抽象类，抽象类实现管程的同步等待队列和条件等待队列；而加锁和解锁的逻辑由具体的子类实现，只是对外提供模板方法，由程序员自己实现加解锁的逻辑。 AQS特性 阻塞等待队列；共享/独占；公平/非公平；可重入；可中断...
AQS之Semaphore&CountDownLatch&CyclicBarrier的特性与源码分析
IUNIQUE技术册
07-12 185
第一节 synchronized关键字详解-偏向锁、轻量级锁、偏向锁、重量级锁、自旋、锁粗化、锁消除 第二节 AQS抽象队列同步器原理详解 第三节 AQS之ReentrantLock特性和源码分析及CAS和LockSupport的核心原理本节介绍Semaphore、CountDownLatch、CyclicBarrier三大工具类的相关特性与源码分析。PV操作是一种实现进程互斥与同步的有效方法。PV操作与信号量的处理相关，P表示通过的意思，V表示释放的意思。①S减1； ②若S减1后仍大于或等于0，则进程继续
Semaphore、CountdownLatch、CyclicBarrier详解
张大安的博客
03-20 804
文章目录1.Semaphore1.1 基本使用1.2 Semaphore原理-图解流程1.3 Semaphore原理-源码分析2.CountdownLatch3.CyclicBarrier 1.Semaphore 信号量，用来限制能同时访问共享资源的线程上限。 1.1 基本使用 /** * @ClassName SemaphoreTest * @author: shouanzh * @Description 信号量，用来限制能同时访问共享资源的线程上限。 * @date 2022/3/20 11:3
AQS之Semaphore、CountDownLatch、CyclicBarrier
xq_adress的博客
06-19 120
aqs
浅谈java并发之计数器CountDownLatch
08-25
如果需要多次使用，可以考虑使用CyclicBarrier或者Semaphore等其他并发工具类。 总的来说，CountDownLatch是Java并发编程中的一种重要工具，通过它可以实现线程间的协作，确保特定操作在所有线程完成后再进行，有效...
J.U.C-AQS框架同步组件之闭锁CountDownLatch介绍
12-21
CountDownLatch的设计基于AbstractQueuedSynchronizer（AQS），这是一个用于构建锁和同步组件的基础框架。 CountDownLatch的构造函数接收一个整数参数`count`，这个参数代表了计数器的初始值。当并发执行的线程调用...
java并发编程：juc、aqs
08-09
共享模式下，多个线程可以同时访问执行，如Semaphore、CountDownLatch和CyclicBarrier。ReentrantReadWriteLock则结合了这两种模式，允许多个线程同时对同一资源进行读操作。 2. **等待队列**：AQS使用CLH（Craig, ...
Java并发包源码分析(JDK1.8)
06-13
AQS相关应用(CountDownLatch、CyclicBarrier、Semaphore等)，executor（ThreadPoolExecutor、ScheduledThreadPoolExecutor、FutureTask等），collection（ConcurrentHashMap、CopyOnWriteArrayList等）， ...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 628
1.导入hutool的maven依赖。2.复制一下代码执行。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
最新发布
m0_74283290的博客
08-03 657
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
社区养老服务小程序的设计
Karen198的博客
07-31 552
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 491
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
JavaSE面向对象进阶
qq_45348840的博客
07-30 497
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
Java并发编程深度解析：AQS与ReentrantLock实战
AQS的设计使得开发者可以方便地创建出满足特定需求的高级同步原语，如Semaphore、CountDownLatch、CyclicBarrier等。 通过对AQS源码的分析，我们可以更深入地理解其内部的工作原理，如等待队列的管理、线程的阻塞和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值