多线程

已于 2024-09-09 21:58:29 修改
阅读量657 收藏 10
点赞数 5
文章标签： java 开发语言
于 2024-09-09 21:46:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57278939/article/details/142069588
版权
1.线程安全

多个线程同时修改同一个资源

① 创建线程的方式有哪些？各有什么优缺点

继承 Thread 类并重写 run 方法创建线程，实现简单但不可以继承其他类
实现 Runnable 接口并重写 run 方法。避免了单继承局限性，编程更加灵活，
实现解耦。
实现 Callable 接口并重写 call 方法，创建线程。可以获取线程执行结果的返
回值，并且可以抛出异常。
使用线程池创建（使用 java.util.concurrent.Executor 接口）

②runnable 和 callable 有什么区别？

1.Runnable 接口run方法无返回值；Callable接口call方法有返回值，是个泛型，和Future、FutureTask配合可以用来获取异步执行的结果
2.Runnable接口run方法只能抛出运行时异常，且无法捕获处理；Callable接口call方法允许抛出异常，可以获取异常信息
3.Callalbe接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会
阻塞主进程的继续往下执行，如果不调用不会阻塞

取钱案例
    小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元
    如果小明和小红同时来取钱，并且2人各自都在取钱10万元，可能会出现什么问题呢？
实现步骤
    1. 创建1个账户类，在类中定义账户金额和取钱方法
    2. 创建1个取钱线程类，在类中调用取钱方法
    3. 在主线程中创建1个账户对象代表二人的共享账户
    4. 在主线程中创建2个取钱线程，分别代表小明和小红，并将共享账户对象传递给2个线程处理
    5. 启动2个线程

public class Demo {
    public static void main(String[] args) {

//        创建共享账户
        Account account = new Account();
//        创建2个取钱线程
        Person xiaoming = new Person(account);
        xiaoming.setName("小明");
        Person xiaohong = new Person(account);
        xiaohong.setName("小红");
//        开始取钱
        xiaohong.start();
        xiaoming.start();

    }
}


/*
取钱线程类
 */
public class Person extends Thread{
//    不能创建Account
    private Account account;
//    构造器
    public Person(Account account){
        this.account = account;
    }


//    调用取钱的方法
    @Override
    public void run() {
        account.drawMoney(100000);
    }
}


//账户类
public class Account {
//    在类中定义账户金额和取钱方法
    private Integer money=100000;

    public void drawMoney(Integer drawMoney){
//        判断余额是否足够
        if(drawMoney>money){
            throw new RuntimeException(Thread.currentThread().getName()+"余额不足");
        }
//        模拟吐钱
        System.out.println(Thread.currentThread().getName()+",ATM吐出"+drawMoney);
//        修改余额
        money -= drawMoney;
        System.out.println("余额是="+this.money);
    }
}
2.线程同步
（1）同步代码块

把访问共享资源的核心代码给上锁，以此保证线程安全

  • 格式
        synchronized(同步锁){
            访问共享资源的核心代码
        }

  • 原理
        每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行

  • 注意
        1、对于当前同时执行的线程来说，同步锁必须是同一把(同一个对象)，否则会出bug注意
        2、同步锁不建议随便使用一个唯一的对象，也能锁住，但可能影响无关线程, 建议使用共享资源作为锁对象
            对于实例方法建议使用this作为锁对象规范
            对于静态方法建议使用字码(类名.class) 对象作为锁对象


public class Demo {
    public static void main(String[] args) {
        //1. 创建一个账户对象
        Account account = new Account();

        //2. 创建两个取钱的人,并把账户交给它
        Person person1 = new Person(account);
        person1.setName("小明");
        Person person2 = new Person(account);
        person2.setName("小红");
//3. 启动2个线程
        person1.start();
        person2.start();



        //1. 创建一个账户对象
        Account account1 = new Account();

        //2. 创建两个取钱的人,并把账户交给它
        Person person11 = new Person(account1);
        person11.setName("大明");
        Person person21 = new Person(account1);
        person21.setName("大红");
//3. 启动2个线程
        person11.start();
        person21.start();
    }
}


public class Account {

    //账户余额
    private Integer balance = 100000;

    //取钱
    public void drawMoney(Integer money) {
        //0.获取线程名称
        String threadName = Thread.currentThread().getName();

        synchronized (this) {
            //1. 判断余额是否充足
            if (money > balance) {
                System.out.println(threadName + "取钱失败,余额不足");
                return;//方法结束
            }

            //2. 如果够,出钱
            System.out.println(Thread.currentThread().getName() + "取钱成功");

            //3. 更新余额
            balance -= money;
            System.out.println(Thread.currentThread().getName() + "取钱之后余额为:" + balance);
        }
    }
}


//取钱人
public class Person extends Thread {

    //账户
    private Account account;
    public Person(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        //调用取钱的方法
        account.drawMoney(100000);
    }
}
（2）同步方法

把访问共享资源的核心方法给上锁，以此保证线程安全。

  • 格式
        修饰符 synchronized 返回值类型 方法名称(形参列表) {
           操作共享资源的代码
        }

  • 原理
        每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行
        同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
        如果方法是实例方法：同步方法默认用this作为的锁对象。
        如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

public class Demo {

    public static void main(String[] args) {
        //1. 创建一个账户对象
        Account account = new Account();

        //2. 创建两个取钱的人,并把账户交给它
        Person person1 = new Person(account);
        Person person2 = new Person(account);

        //3. 启动2个线程
        person1.start();
        person2.start();

    }
}

public class Account {

    //账户余额
    private Integer balance = 100000;

//    获取余额
    public Integer getBalance(){
        return balance;
    }
    //充值
    public synchronized void setBalance(Integer balance){
        this.balance = this.balance+balance;
    }
    //取钱
    public synchronized void drawMoney(Integer money) {
        //0.获取线程名称
        String threadName = Thread.currentThread().getName();

        //1. 判断余额是否充足
        if (money > balance) {
            System.out.println(threadName + "取钱失败,余额不足");
            return;//方法结束
        }

        //2. 如果够,出钱
        System.out.println(Thread.currentThread().getName() + "取钱成功");

        //3. 更新余额
        balance -= money;
        System.out.println(Thread.currentThread().getName() + "取钱之后余额为:" + balance);
    }
}

//取钱人
public class Person extends Thread {

    //账户
    private Account account;
    public Person(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        //调用取钱的方法
        account.drawMoney(100000);
    }
}
（3）lock锁

Lock锁是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大
Lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建锁对象

  • 方法
        public ReentrantLock() 创建锁对象
        public void lock()    上锁
        public void unlock() 释放锁

  • Lock锁使用规范
        规范1、锁对象创建在成员位置，使用final修饰
        规范2、释放锁的代码写在finally块中

public class Account {

    //账户余额
    private Integer balance = 100000;

//    创建锁对象
    private Lock lock = new ReentrantLock();


    //取钱
    public void drawMoney(Integer money) {

        //0.获取线程名称
        String threadName = Thread.currentThread().getName();

//        加锁
        lock.lock();
        try {
            //1. 判断余额是否充足
            if (money > balance) {
                System.out.println(threadName + "取钱失败,余额不足");
                return;//方法结束
            }

            //2. 如果够,出钱
            System.out.println(Thread.currentThread().getName() + "取钱成功");

            //3. 更新余额
            balance -= money;
            System.out.println(Thread.currentThread().getName() + "取钱之后余额为:" + balance);
        }catch (Exception e){
            e.printStackTrace();
        }finally{
//        释放锁
            lock.unlock();
        }


    }
}


/*
测试类
*/
public class Demo {

    public static void main(String[] args) {
        //1. 创建一个账户对象
        Account account = new Account();

        //2. 创建两个取钱的人,并把账户交给它
        Person person1 = new Person(account);
        Person person2 = new Person(account);

        //3. 启动2个线程
        person1.start();
        person2.start();

    }
}


//取钱人
public class Person extends Thread {

    //账户
    private Account account;
    public Person(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        //调用取钱的方法
        account.drawMoney(100000);
    }
}
3.线程池

一个可以复用线程的技术

  • 执行流程(核心线程-->工作队列-->临时线程-->拒绝策略)
        判断核心线程数是否已满，如果没满，则创建一个新的核心线程来执行任务
        如果核心线程满了，则判断工作队列是否已满，如果没满，则将任务存储在这个工作队列
        如果工作队列满了，则判断最大线程数是否已满，如果没满，则创建临时线程执行任务
        如果最大线程数已满，则执行拒绝策略

  • 对象创建
        接口 ExecutorService
        实现类 ThreadPoolExecutor
            int corePoolSize : 指定线程池的核心线程的数量
            int maximumPoolSize：指定线程池的最大线程数量
            long keepAliveTime ：指定临时线程的存活时间
            TimeUnit unit：指定临时线程存活的时间单位
            BlockingQueue<Runnable> workQueue：指定线程池的任务队列
            ThreadFactory threadFactory：指定线程池的线程工厂
            RejectedExecutionHandler handler：指定线程池的任务拒绝策略

public class Demo1 {
    public static void main(String[] args) {

//        线程池的创建
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                3,
                5,
                60,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );
        System.out.println(poolExecutor);
//        核心线程
        poolExecutor.execute(() -> {

                    System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(8000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        poolExecutor.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(8000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        poolExecutor.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(8000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
//      等待队列
        poolExecutor.execute(() -> {
            System.out.println(Thread.currentThread().getName());
        });
        poolExecutor.execute(() -> {
            System.out.println(Thread.currentThread().getName());
        });
        poolExecutor.execute(() -> {
            System.out.println(Thread.currentThread().getName());
        });
        poolExecutor.execute(() -> {
            System.out.println(Thread.currentThread().getName());
        });
        poolExecutor.execute(() -> {
            System.out.println(Thread.currentThread().getName());
        });
//        临时线程
        poolExecutor.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(8000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        poolExecutor.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(8000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

//      拒绝策略执行
        poolExecutor.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });


        System.out.println(poolExecutor);
//        提交多次任务
//        for (int i = 0; i < 10; i++) {
//            poolExecutor.execute(new Runnable() {
//                @Override
//                public void run() {
//                    System.out.println(Thread.currentThread().getName());
//                }
//            });
//        }

    }
}

  • 线程池执行Runnable任务
        void execute(Runnable command)     执行Runnable任务
        void shutdown()  等全部任务执行完毕后，再关闭线程池！
        List<Runnable> shutdownNow() 立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务

  • Future<T> submit(Callable<T> task)  执行Callable任务，返回未来任务对象，用于获取线程返回的结果

public class Demo3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
//        线程池的创建
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                3,
                5,
                60,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );
        System.out.println(poolExecutor);

//        Future<Integer> future = poolExecutor.submit(new Callable<Integer>() {
//            @Override
//            public Integer call() throws Exception {
//                int count = 0;
//                for (int i = 1; i < 11; i++) {
//                    if(i%2==0){
                        如果遇到偶数，我就休眠2秒
//                        Thread.sleep(2000);
//                    }
//                    count += i;
//                }
//                return count;
//            }
//        });
//        Integer count = future.get(5,TimeUnit.SECONDS);
//        System.out.println("count="+count);

//        执行自己的任务
        MyTask myTask = new MyTask(5);
        Future<Integer> future = poolExecutor.submit(myTask);
        Integer sum = future.get();

        MyTask myTask1 = new MyTask(10);
        Future<Integer> future1 = poolExecutor.submit(myTask1);
        Integer sum1 = future1.get();

        System.out.println(sum);
        System.out.println(sum1);

//        poolExecutor.shutdown();
        List<Runnable> runnables = poolExecutor.shutdownNow();
        System.out.println(runnables);
    }
}

//需求: 编写一个任务类, 可以通过构造器接收n, 计算并返回1~n的和
class MyTask implements Callable<Integer>{
    private int n;
    public MyTask(int n){
        this.n = n;
    }
    /**
     * 计算 1~n的和
     * @return
     * @throws Exception
     */
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n ; i++) {
            sum += i;
        }
        return sum;
    }
}

  • Executors
        是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象。

  • 创建线程池的方法
        ExecutorService newFixedThreadPool(int nThreads) 创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它
        ExecutorService newSingleThreadExecutor()  创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程
        ExecutorService newCachedThreadPool()  线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60s则会被回收掉
        ScheduledExecutorService newScheduledThreadPool(int corePoolSize)  创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务

  • 最大线程怎么定?
        计算密集型的任务：核心线程数量 = CPU的核数 + 1   算法，递归这样的计算任务， cpu+1
        IO密集型的任务：核心线程数量 = CPU核数 * 2      很多的磁盘任务，上传下载导入导出

  • 注意
        大型并发系统环境中使用Executors如果不注意可能会出现系统风险。
            1) FixedThreadPool和SingleThreadPool:允许的请求队列长度为Integer.MAX_VALUE,可能会堆积大量的请求,从而导致00M
            2) CachedThreadPoo和ScheduledThreadPool: 允许的创建线程数量为Integer.MAX_VALUE,可能会创建大量的线程,从而导致OOM

①线程池的拒绝策略有哪些？

AbortPolicy：直接抛出异常，默认策略；
CallerRunsPolicy：用调用者所在的线程来执行任务；
DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
DiscardPolicy：直接丢弃任务

public class Demo4 {
    public static void main(String[] args) {

//  ExecutorService newFixedThreadPool(int nThreads) 创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它
        ExecutorService executorService = Executors.newFixedThreadPool(5);
//    ExecutorService newSingleThreadExecutor()	创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程
        ExecutorService executorService1 = Executors.newSingleThreadExecutor();
//    ExecutorService newCachedThreadPool()	线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60s则会被回收掉
        ExecutorService executorService2 = Executors.newCachedThreadPool();
//    ScheduledExecutorService newScheduledThreadPool(int corePoolSize)	创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);
    }
}
4.线程通信

案例说明
    1) 3个厨师可以认为是生产者，负责生产包子，每次只能生产1个（生产者线程）
    2) 2个客人可以认为是消费者，负责消费包子，每次只能消费1个（消费者线程）
    3) 中间有张桌子用于存储包子，但是只能存储1个包子（桌子和包子是共享数据）

核心思路
   生产者线程放包子：
       1)先判断桌子上是否有包子
       2)没有包子时，开始做包子, 做完之后把别人唤醒，然后让自己等待
       3)有包子时，不做包子了，直接唤醒别人，然后让自己等待
   消费者线程吃包子：
       1)先判断是否有包子
       2)有包子时，开始吃包子，吃完之后把别人唤醒，然后让自己等待
       3)没有包子时，不吃包子了，直接唤醒别人，然后让自己等待

  • 使用方法(使用当前同步锁对象进行调用)
        void wait()让当前线程等待并释放所占锁
        void notify()随机唤醒正在等待的某个线程
        void notifyAll()唤醒正在等待的所有线程

public class Demo {
    public static void main(String[] args) {
        //1. 将共享数据对象创建出来
        Desk desk = new Desk();

        //2. 创建3个生产者(厨师)线程
        for (int i = 1; i <= 3; i++) {
            new Thread(() -> {
                while (true) {
                    desk.set();
                }
            }, "厨师" + i).start();
        }

        //3. 创建2个消费者(顾客)线程
        for (int i = 1; i <= 2; i++) {
            new Thread(() -> {
                while (true) {
                    desk.get();
                }
            }, "顾客" + i).start();
        }
    }
}

class Desk {
    //维护一个集合,来放包子
    private List<String> list = new ArrayList<>();

    //放包子
    public synchronized void set() {
        try {
            //0. 获取线程的名字
            String name = Thread.currentThread().getName();

            //1. 先判断是否有包子
            if (list.size() == 0) {//没有包子
                System.out.println(name + "开始做包子");
                Thread.sleep(2000);
                list.add(name + "做的包子");

                //叫醒别人,自己休息=======>包子好了啊,我休息会
                this.notifyAll();
                this.wait();
            } else {//有包子
                //叫醒别人,自己休息=======>包子还有啊,我休息会
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //取包子
    public synchronized void get() {
        try {
            //0. 获取线程的名字
            String name = Thread.currentThread().getName();

            //1. 先判断是否有包子
            if (list.size() != 0) {//有包子
                System.out.println(name + "吃了" + list.remove(0));
                Thread.sleep(2000);

                //叫醒别人,自己休息=======>包子吃完啊,我休息会
                this.notifyAll();
                this.wait();
            } else {//没有包子
                //叫醒别人,自己休息=======>包子没了啊,我休息会
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

①线程的生命周期 : 新建、就绪、运行、阻塞和终止

②wait和sleep的区别：

1.方法归属不同
sleep(long) 是 Thread 的静态方法
而 wait()，wait(long) 都是 Object 的成员方法，每个对象都有
2.醒来时机不同
执行 sleep(long) 和 wait(long) 的线程都会在等待相应毫秒后醒来
wait(long) 和 wait() 还可以被 notify 唤醒，wait() 如果不唤醒就一直等下
去
它们都可以被打断唤醒
3.锁特性不同（重点）
wait 方法的调用必须先获取 wait 对象的锁，而 sleep 则无此限制
wait 方法执行后会释放对象锁，允许其它线程获得该对象锁（我放弃
cpu，但你们还可以用）
而 sleep 如果在 synchronized 代码块中执行，并不会释放对象锁（我放
弃 cpu，你们也用不了）

③synchronized和lock的区别：

Syncronized 的目的是一次只允许一个线程进入由他修饰的代码段，从
而允许他们进行自我保护。Synchronized 锁住的代码区域执行完成后需要把锁归还，也
就是释放锁，这样才能够让其他线程使用
Lock 需要手动加锁和手动解锁，一般通过 lock.lock()方法来进行
加锁，通过 lock.unlock()方法进行解锁。

……啊吧啊吧
关注
c++多线程
02-20
一个进程中可以同时运行多个线程，每个线程可以执行不同的任务，这就是所谓的多线程。同一进程中的多个线程将共享该进程中的全部系统资源，如虚拟地址空间、文件描述符和信号处理等，但是同一个进程中的多个线程都有...
stm32单片机多线程实例
12-03
多线程是实现复杂任务并发执行的关键技术，能够提高资源利用率，优化系统响应时间。在STM32上实现多线程，通常会借助实时操作系统（RTOS）如RT-Thread。 RT-Thread是一个轻量级、开源的实时操作系统，它为STM32等微...
Java多线程详解及示例
07-20
在多线程环境下，死锁是指两个或多个线程相互等待对方释放资源，导致它们都无法继续执行。活锁则是指线程不断重试获取资源，但由于其他线程持有资源不释放，导致线程陷入无限循环的状态。避免死锁和活锁的关键在于...
多线程测试
09-21
在计算机科学领域，多线程是一种程序设计技术，它允许应用程序同时执行多个任务或子任务。这极大地提高了软件的效率和响应性，特别是在现代多核处理器的环境下。本主题将深入探讨多线程的实现方式及其与单线程的对比...
大漠多线程模板_大漠_大漠多线程_
09-30
"大漠多线程模板"是一个专门针对C#开发的多线程处理框架，它为开发者提供了便捷的方式来管理和优化多线程应用。这个框架由知名开发者"大漠"创建，旨在简化复杂的并发编程，提高代码的可读性和可维护性。 多线程允许...
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 202
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 453
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 891
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 556
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 804
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【RocketMQ】RocketMQ应用难点
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 888
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
JAVA开源项目 旅游管理系统 计算机毕业设计
as230627的博客
10-03 1251
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。
【hot100-java】【合并两个有序链表】
m0_73629042的博客
09-30 388
记忆中，两个指针合并即可。
古典舞在线交流：SpringBoot平台实现与优化
2401_85341950的博客
10-04 579
在这段时期里，我查找了很多相关的资料，查阅了很多Java的相关文献，结合自己的经验，设计了这个古典舞在线交流平台，虽然每个学期学校都会针对动手练习进行相应的课程设计，但是在古典舞在线交流平台的具体设计中还是遇到了一些小问题，但在不断的学习、研究中都将问题一一解决，在一一克服的过程中，我也得到了成长，知识和经验也得到了丰富，这对我来说是一笔巨大的财富。这次设计也大大提高了我的动手的能力，让我在学习中充分体会到了探索的乐趣，享受成功的创作过程，在本次设计过程中汲取的东西，是一笔宝贵的财富，让我受益匪浅。
英语词汇小程序小程序|英语词汇小程序系统|基于java的四六级词汇小程序设计与实现(源码+数据库+文档)
伟庭的博客
10-02 1553
四六级词汇小程序，可以实现目标用户群需要的功能，四六级词汇小程序的设计主要是对系统所要实现的功能进行详细考虑，确定所要实现的功能后进行界面的设计，四六级词汇小程序的开发利用现有的成熟技术参考，以源代码为模板，分析功能调整与四六级词汇小程序管理的实际需求相结合，讨论了基于四六级词汇小程序管理的使用。词汇是英语永恒的话题，单词太多记不住是孩子永远的难题。为方便用户能够可以随时进行四六级词汇小程序的数据信息管理，特开发了基于四六级词汇小程序的管理系统。
[C++][程序退出]详细讲解
SnowK博客
09-30 3458
[C++][程序退出]详细讲解
JavaScript Set基础与实战应用
软考鸭
10-01 390
Set是JavaScript中一个非常有用的数据结构，它提供了一种存储唯一值的方式。通过掌握Set的基本用法、特性以及高级操作，你可以在开发过程中更加灵活地处理集合数据。无论是去除数组中的重复元素，还是进行集合运算，Set都能提供简洁而高效的解决方案。
【微服务】服务调用 - OpenFeign（day6）
weixin_73060900的博客
10-06 691
对远程调用组件OpenFeign进行了简单介绍.
基于SSM的超市订单系统（源码+定制+讲解）
程序员阿龙的博客
10-02 1368
博主介绍： ✌我是阿龙，一名专注于Java技术领域的程序员，全网拥有10W+粉丝。作为CSDN特邀作者、博客专家、新星计划导师，我在计算机毕业设计开发方面积累了丰富的经验。同时，我也是掘金、华为云、阿里云、InfoQ等平台的优质作者。通过长期分享和实战指导，我致力于帮助更多学生完成毕业项目和技术提升。 技术范围： 我熟悉的技术领域涵盖SpringBoot、Vue、SSM、HLMT、Jsp、PHP、Nodejs、Python、爬虫、数据可视化、小程序、安卓app、大数据、物联网、机器学习等方
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值