Java多线程学习笔记

已于 2024-06-16 20:07:57 修改
阅读量1k 收藏 9
点赞数 15
分类专栏： 学习记录 文章标签： java 学习 笔记
于 2024-06-14 21:07:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49832841/article/details/139683449
版权

文章目录

1. 引言

1.1 多线程的重要性

多线程编程是现代软件开发中的重要技术，能够提高资源利用率、提升应用程序的响应性、简化并发问题的建模和实现、提升性能，并增强系统的健壮性和容错性。掌握多线程编程技术，对开发高效、可靠的现代应用至关重要。

2. 什么是多线程

2.1 线程的定义和基本概念

在计算机科学中，是将进程划分为两个或多个线程（实例）或子进程，由单处理器（单线程）或多处理器（多线程）或多核处理系统并发执行。

2.2 线程与进程的区别

线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多。
进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是
一个进程从创建，运行到消亡的过程。

3. 创建线程的方式

3.1 继承Thread类

public class MyThread extends Thread {

    public void run() {
        System.out.println("Thread is running");
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

3.2 实现Runnable接口，重写run方法

class MyRunnable implements Runnable {

    public void run() {
        System.out.println("Thread is running");
    }

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }

}

3.3 实现Runnable接口，重写call方法

无参

public class MyCallable implements Callable<String> {

    public String call() {
        return "Thread is running";
    }

    public static void main(String[] args) {
        MyCallable callableTask = new MyCallable();
        String call = callableTask.call();
        System.out.println(call);
    }

}

有参

public class MyCallable implements Callable<String> {

    private String name;

    public MyCallable(String name) {
        this.name = name;
    }

    public String call() {
        return "Hello, " + name;
    }

    public static void main(String[] args) {
        MyCallable callableTask = new MyCallable("Thread is running");
        String call = callableTask.call();
        System.out.println(call);
    }

}

3.4 匿名内部类创建Thread子类对象

public class Test {

    public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("Thread anonymous class is running");
            }
        };
        thread.start();
    }

}

3.5 使用匿名内部类实现 Runnable 接口

public class Test {

    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Runnable anonymous class is running");
            }
        });
        thread.start();
    }

}

3.6 使用匿名内部类实现 Callable 接口

public class Test {

    public static void main(String[] args) {
        // 创建一个线程池
        ExecutorService executor = Executors.newFixedThreadPool(1);

        // 提交一个Callable任务，使用匿名内部类实现Callable接口
        Future<String> future = executor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("Callable anonymous class is running");
                // 模拟一些长时间的任务
                Thread.sleep(1000);
                return "Callable task completed";
            }
        });

        try {
            // 获取Callable任务的执行结果
            String result = future.get();
            System.out.println("Result from Callable: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池
            executor.shutdown();
        }
    }

}

3.7 实现runable和callable的区别

Runnable：适用于任务不需要返回结果或处理异常的场景，如简单的后台任务、事件处理等。
Callable：适用于任务需要返回结果或需要处理异常的场景，如计算任务、IO操作等。

4. 线程的生命周期

4.1 线程的状态

  1. 新建（New）
    （1）线程对象已经被创建，但还没有调用start()方法。
    （2）线程处于新建状态，还没有开始执行。

  2. 可运行（Runnable）
    （1）线程已经调用了start()方法，但还没有获得CPU时间片开始执行。
    （2）线程处于就绪状态，等待操作系统调度执行。
    （3）一旦获得CPU时间片，线程就会执行其run()方法。

  3. 运行中（Running）
    （1）线程当前正在执行代码。
    （2）严格来说，Java线程状态没有单独的“运行中”状态，它是Runnable状态的一部分。

  4. 阻塞（Blocked）
    （1）线程在等待监视器锁（monitor lock），以进入同步块或方法。
    （2）当线程试图进入一个被其他线程持有的同步块/方法时，会进入阻塞状态。

  5. 等待（Waiting）
    （1）线程等待另一线程显式地唤醒（通过Object.wait()、Thread.join()、LockSupport.park()等方法）。
    （2）等待状态下的线程不占用CPU时间片。

  6. 超时等待（Timed Waiting）
    （1）线程等待另一线程显式地唤醒，但有时间限制（通过Thread.sleep()、Object.wait(long timeout)、Thread.join(long millis)、LockSupport.parkNanos()等方法）。
    （2）超时等待状态下的线程不占用CPU时间片。

  7. 终止（Terminated）
    （1）线程已完成执行，或由于异常退出了run()方法。
    （2）线程生命周期结束，进入终止状态。

New -> Runnable -> Blocked/Waiting/Timed Waiting -> Runnable -> Terminated

4.2 线程状态转换图

在这里插入图片描述

5. 线程的基本控制方法

5.1 线程状态管理

5.1.1 start()

启动线程，使其进入可执行状态（RUNNABLE状态）。
系统会在后台为线程分配资源，并调用线程的run()方法执行任务。

5.1.2 join()

当前线程等待目标线程执行完成。
调用该方法的线程将会阻塞，直到目标线程执行完毕或超时。

5.1.3 sleep(long millis)

让当前线程休眠指定的时间（毫秒），进入TIMED_WAITING状态。
休眠结束或被中断后线程重新进入可运行状态。

5.1.4 yield()：

暂停当前正在执行的线程对象，并执行其他线程。
可以让同优先级的线程有机会执行。

5.2 线程等待和唤醒

wait()、notify()、notifyAll()：
这些方法是Object类中的方法，用于线程间的等待和唤醒机制，必须在同步代码块或同步方法中使用。

5.2.1 wait()

使当前线程等待，释放锁资源。

5.2.2 notify()

唤醒一个等待中的线程。

5.2.3 notifyAll()

唤醒所有等待中的线程。

5.3 线程优先级设置

5.3.1 setPriority(int priority)

设置线程的优先级，优先级范围为1到10，默认为5。
高优先级的线程具有抢占低优先级线程CPU时间的能力，但具体实现依赖于操作系统。

5.4 线程中断

5.4.1 interrupt()：

中断线程，设置线程的中断状态为true。
被中断的线程可以通过检查自身的中断状态或捕获InterruptedException异常来处理中断请求。

5.4.2 isInterrupted()：

判断线程是否被中断，返回true或false。

5.4.3 interrupted()：

判断当前线程是否被中断，返回true或false，同时会清除中断状态。

start和run的区别

1. start() 方法
作用：
start()方法用于启动一个新的线程，并使线程进入可执行状态（RUNNABLE状态）。在调用start()方法后，系统会为该线程分配必要的资源，并执行线程的run()方法。start()方法只能被调用一次，重复调用会抛出IllegalThreadStateException异常。
执行过程：
当调用start()方法后，系统会在后台启动一个新的线程，并调用该线程的run()方法。start()方法返回后，当前线程（通常是调用start()的线程）会继续执行，而不会等待新线程的执行完毕。
2. run() 方法
作用：
run()方法是Thread类的实例方法，用于定义线程的主体任务或逻辑。当线程处于可执行状态并获得CPU时间片时，系统会调用线程的run()方法执行具体的任务。
执行过程：
run()方法被直接调用时，它会在当前线程中执行，而不会创建新的线程。直接调用run()方法会使得线程任务在当前线程中串行执行，不会体现出多线程的并发特性。

6. 线程的同步与互斥

一个多线程的程序，两个或者多个线程可能需要访问同一个数据资源。这时就必须考虑数据安全的问题，需要线程互斥或者同步。

6.1 synchronized关键字

例如对 count 进行修改或访问

同步方法：

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

同步代码块：

public class Counter {
    private int count = 0;
    private final Object lock = new Object();

    public void increment() {
        synchronized (lock) {
            count++;
        }
    }

    public int getCount() {
        synchronized (lock) {
            return count;
        }
    }
}

6.2 ReentrantLock

public class Counter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

7. 线程间通信

7.1 BlockingQueue

BlockingQueue 是 java.util.concurrent 包中的接口，它提供了线程安全的阻塞队列实现，如 ArrayBlockingQueue、LinkedBlockingQueue 等。它们简化了生产者-消费者模式的实现，自动处理线程间的等待和唤醒。

public static void main(String[] args) {
    BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

    Thread producer = new Thread(() -> {
        for (int i = 0; i < 10; i++) {
            try {
                queue.put(i);
                System.out.println("Produced: " + i);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    });

    Thread consumer = new Thread(() -> {
        for (int i = 0; i < 10; i++) {
            try {
                int value = queue.take();
                System.out.println("Consumed: " + value);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    });

    producer.start();
    consumer.start();
}

这里我只列举了其中一种，其他实现方式可参考：https://blog.csdn.net/qq_42411214/article/details/107767326 或其他文章。

8. 高级多线程工具

8.1 线程池

8.1.1 线程池继承关系

在这里插入图片描述

1、Executor 接口：Executor 是一个函数式接口，定义了一个执行任务的方法execute(Runnable command)，用于将任务提交到线程池执行。它是所有执行器的基类，提供了最基本的任务执行方法。

2、ExecutorService ：ExecutorService 是 Executor 的扩展，提供了更高级的任务管理功能，包括任务的提交、返回结果、取消任务以及关闭线程池等。它是一个接口，定义了管理线程池的方法。其中提供了一个方法submit(Runnable task):提交一个任务，返回 Future 对象。

3、AbstractExecutorService ：AbstractExecutorService 是 ExecutorService 的抽象实现类，提供了一些默认实现，方便子类实现。它实现了 ExecutorService 接口，提供了 shutdown() 和 shutdownNow() 方法的默认实现。

4、ThreadPoolExecutor 类：ThreadPoolExecutor 是 ExecutorService 的一个具体实现，提供了一个可配置的线程池。
它具有高度的可配置性，可以设置线程池的核心线程数、最大线程数、线程存活时间、任务队列和拒绝策略等。

8.1.2 ThreadPoolExecutor

在这里插入图片描述

ThreadPoolExecutor 的构造方法包含七个参数：

1、核心线程数量——在线程池当中无论空闲多久都不会被删除的线程
2、线程池当中最大的线程数量——线程池当中最大能创建的线程数量
3、空闲时间（数值）——临时线程（线程池中出核心线程之外的线程）空闲了多久就会被淘汰的时间。
4、空闲时间（单位）——临时线程空闲了多久就会被淘汰的时间单位，要用枚举类TimeUnit类作为参数
5、阻塞队列——就是创建一个阻塞队列作为参数传入，就是当线程池当中线程数量已经达到了最大线程数量，允许多少个任务排队获取线程，其余的用参数七那个方案来处理。
6、创建线程的方式——不是new一个线程，而是传入一个线程工厂（例如：Executors工具类中的defaultThreadFactory方法返回的就是一个线程工厂）
7、要执行的任务过多时的解决方案——当等待队列中也排满时要怎么处理这些任务(任务拒绝策略)。

ThreadPoolExecutor 支持多种任务队列：

LinkedBlockingQueue：一个基于链表的阻塞队列，容量为 Integer.MAX_VALUE，适合大多数场景。
ArrayBlockingQueue：一个有界的阻塞队列，必须指定容量。
SynchronousQueue：一个不存储元素的队列，每个插入操作必须等待一个相应的移除操作。
PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列。

拒绝策略

当线程池和队列都满了时，可以使用拒绝策略来处理新提交的任务。ThreadPoolExecutor 提供了以下四种拒绝策略：

AbortPolicy（默认）：抛出 RejectedExecutionException 异常。
CallerRunsPolicy：由调用线程执行该任务。
DiscardPolicy：直接丢弃任务。
DiscardOldestPolicy：丢弃队列中最旧的任务，然后重新提交被拒绝的任务。

8.2.2.1 线程池的任务调度流程

在这里插入图片描述

  1. 当线程池中线程数量小于 corePoolSize 则创建线程，并处理请求。
  2. 当线程池中线程数量大于等于 corePoolSize 时，则把请求放入 workQueue 中,随着线程池 中的核
    心线程们不断执行任务，只要线程池中有空闲的核心线程，线程池就从 workQueue 中取 任务并处
    理。
  3. 当 workQueue 已存满，放不下新任务时则新建非核心线程入池，并处理请求直到线程数目 达到
    maximumPoolSize（最大线程数量设置值）。
  4. 如果线程池中线程数大于 maximumPoolSize 则使用 RejectedExecutionHandler 来进行任 务拒绝
    处理。

8.1.2 Executors创建线程的4种方法

1、newFixedThreadPool(int nThreads)

创建一个固定大小的线程池，线程数量为 nThreads。当所有线程都在忙时，新的任务会在队列中等待。

2、newCachedThreadPool()

创建一个缓存型线程池。如果线程池的规模超过了处理需求，会回收空闲线程；当需求增加时，会添加新的线程。

3、newSingleThreadExecutor()

创建一个单线程的线程池，它只会用唯一的工作线程来执行任务，确保所有任务按顺序执行。

4、newScheduledThreadPool(int corePoolSize)

创建一个可以延迟或定期执行任务的线程池。

8.3 并发集合（ConcurrentHashMap, CopyOnWriteArrayList等）

线程安全的集合可参考：Java Collection集合介绍、fail-fast快速失败机制介绍、线程安全的容器介绍

8.4 原子变量（AtomicInteger, AtomicBoolean等）

AtomicInteger
AtomicInteger 是一个提供对 int 类型进行原子操作的类。它提供了许多方法来对整数进行原子操作，避免了使用 synchronized 关键字的复杂性和开销。

AtomicBoolean
AtomicBoolean 是一个提供对 boolean 类型进行原子操作的类。它同样提供了一些方法来确保在多线程环境下对布尔值的操作是线程安全的。

10. 性能优化和最佳实践

10.1 多线程性能优化

1、多线程性能优化合理使用线程池：
使用 Executor 框架来管理线程，而不是直接创建和管理线程。合理配置线程池的核心线程数、最大线程数和任务队列可以有效提高性能。
选择合适的线程池类型（如固定大小线程池、缓存线程池、单线程池、调度线程池）以适应具体需求。

2、减少上下文切换：
线程上下文切换开销很大，尽量减少不必要的线程切换。通过调整线程池大小来控制线程数量，避免过多的线程竞争CPU资源。
合理划分任务，避免任务过于细粒度导致频繁切换。

3、避免锁竞争：
尽量减少锁的使用范围和时间，缩小临界区范围。
使用 java.util.concurrent 包中的并发集合和工具类（如 ConcurrentHashMap、CopyOnWriteArrayList）来替代传统的同步集合。
使用 ReentrantLock 代替 synchronized，并结合 tryLock 方法进行非阻塞锁定。

4、无锁编程：
使用原子类（如 AtomicInteger、AtomicBoolean）进行无锁操作，提高性能。
尽量避免在高并发环境下使用锁，尝试使用无锁算法和数据结构。

10.2 多线程最佳实践

1、任务划分和线程数量：
合理划分任务，根据任务的性质和计算复杂度来确定线程的数量。
根据硬件资源和具体应用场景调优线程池的配置，一般来说，CPU密集型任务线程数应为 CPU 核心数+1，IO密集型任务线程数应大于CPU核心数。

2、线程安全：
确保共享资源的线程安全，使用适当的同步机制或并发集合。
尽量使用不可变对象，避免共享状态。

3、线程间通信：
使用高效的线程间通信机制，如 BlockingQueue、CountDownLatch、CyclicBarrier 等。

4、线程生命周期管理：
避免频繁创建和销毁线程，使用线程池来管理线程的生命周期。
在线程池使用完毕后，记得调用 shutdown() 方法来优雅地关闭线程池。

5、异常处理：
在线程内部进行适当的异常处理，避免因未处理的异常导致线程突然终止。
使用 Thread.setUncaughtExceptionHandler 来处理未捕获的异常。

6、性能监控和调优：
使用性能监控工具（如 JVisualVM、JProfiler）来监控线程的状态、锁竞争和CPU利用率。
定期进行性能调优，根据实际运行情况调整线程池配置和任务划分策略。

示例

public class Test {
    private static final int NUM_THREADS = 4;
    private static final int NUM_TASKS = 10;
    private static final ExecutorService executor = Executors.newFixedThreadPool(NUM_THREADS);
    private static final ConcurrentHashMap<String, AtomicInteger> map = new ConcurrentHashMap<>();

    public static void main(String[] args) {
        for (int i = 0; i < NUM_TASKS; i++) {
            executor.submit(new Task("task" + i));
        }
        executor.shutdown();
        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }
        map.forEach((key, value) -> System.out.println(key + ": " + value));
    }

    static class Task implements Runnable {
        private final String taskName;

        Task(String taskName) {
            this.taskName = taskName;
        }

        @Override
        public void run() {
            map.computeIfAbsent(taskName, k -> new AtomicInteger(0)).incrementAndGet();
            System.out.println(Thread.currentThread().getName() + " executed " + taskName);
        }
    }
}

11. 常见面试题

1、如何理解内存泄漏问题？有哪些情况会导致内存泄露？如何解决？
2、线程有哪些基本状态?
3、为什么要创建线程池？创建线程池的方式？
4、创建线程池有哪几个核心参数？ 如何合理配置线程池的大小？
5、说说阻塞队列的实现
6、线程间的通讯方式
7、说说线程安全问题，什么是线程安全，如何实现线程安全；
8、synchronized 和 ReentrantLock 的区别
9、线程安全的集合

李子木、
关注
  • 15
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java多线程学习笔记(七)--线程池
至尊宝
05-19 2万+
什么是线程池 为了避免系统频繁地创建和销毁线程,我们可以让创建的线程进行复用,线程池是来管理线程的,线程池中总有那么几个活跃线程,当使用线程时可以从池子中随便拿一个空闲线程,当完成工作时,不用立即关闭线程,而是将线程还给线程池,方便下一个要使用线程的任务,有了线程池后,创建线程变成是从线程池中拿线程,销毁线程时变成是将线程还给线程池继续管理。 这种场景非常像在开发中连接数据库,有一个数据库连...
Java多线程学习笔记（一）
wuqinghai2012的专栏
05-03 1282
首先推荐一篇好文： http://www.cnblogs.com/nexiyi/p/java_memory_model_and_thread.html
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3252
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
java多线程学习笔记
weach的博客
12-19 605
java多线程
Java多线程学习笔记 - 1
涞公子的博客
03-13 2441
多任务 概述： 多任务就是同时运行多个任务。 好处： 充分利用了CPU的资源，提高了代码的执行效率。 执行方式： 并发：在一段时间内交替去执行多项任务【任务数 > 核数】 并行：多个计算机内核一起执行任务，一个内核负责执行一个任务【任务数 <= 核数】 实现方式： 多线程或多进程。 进程与线程介绍： 进程 概述： 线程 概述： 进程与线程之间的关系 一个进程内含有一个或多个线程，但至少含有一个线程。 ...
Java 多线程学习笔记
zjrodger的专栏
06-16 2998
多线程笔记目录 ·多线程的概念 (·)线程和进程 1.进程的概念 2.线程的概念 3.多线程的特性 4.注意区别并行和并发   ·多线程的创建和启动 (·)实现多线程的综述 1.综述 2.为什么要覆盖run()方法？ 3. run()方法和start()方法的区别     (·)继承Thread类     (·)实现Runnable接口实现多线程   ·多线程的生命
Java多线程笔记详解
you are sherlocked by me!
10-09 541
这是学习多线程知识的学习笔记，大家可以选择自己感兴趣的部分阅读学习 详细代码见github代码   Java多线程学习笔记1之多线程基础 内容: 1) 基本概念以及线程的实现方法   Java多线程学习笔记2之多线程基础 内容: 1) 数据同步 2) 非线程安全情况以及处理方法 3) Java内存模型 4) Thread.currentThread()抽象方法使用 ...
目录: java 多线程 学习笔记
Java 程序源
09-01 7540
速度发送
JAVA 多线程学习笔记
03-27
这篇学习笔记将深入探讨Java多线程的核心概念、实现方式以及相关工具的使用。 一、多线程基础 1. 线程与进程：在操作系统中，进程是资源分配的基本单位，而线程是程序执行的基本单位。每个进程至少有一个主线程，...
java多线程学习笔记之自定义线程池
08-29
Java多线程学习笔记之自定义线程池 本篇文章主要介绍了Java多线程学习笔记之自定义线程池，通过深入了解ThreadPoolExecutor这个核心类，我们可以自定义线程池，满足不同的线程池需求。 Java多线程学习笔记之自定义...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 738
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 692
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 711
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1237
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1266
JVM-垃圾回收与内存分配
【Java算法】前缀和 下
2302_79806056的博客
07-18 1123
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
淘客返利系统中的服务发现与注册机制详解
最新发布
技术研究中心
07-22 1099
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

李子木、

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值