每天学习一点点20211212/20211213/20211214/20211215/20211216--线程池

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量358 收藏
点赞数
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45352902/article/details/121884267
版权

线程池

1.线程池

  可以以 new Thread(()->{线程执行的任务}).start(); 这种形式开启一个线程，当 run() 方法运行结束，线程对象会被 GC 释放。
  在真实的生产环境中，可能需要很多线程来支撑整个应用，当线程数量非常多时，反而会耗尽 CPU 资源，如果不对线程进行控制和管理，反而会影响程序的性能。线程开销主要包括：创建与启动线程的开销；线程销毁开销；线程调度的开销；线程数量受限 CPU 处理器数量。
  线程池就是有效使用线程的一种常用方式。线程池内部可以预先创建一定数量的工作线程，客户端代码直接将任务作为一个对象提交给线程池，线程池将这些任务缓存在工作队列中，线程池中的工作线程不断地从队列中取出任务并执行。

2.JDK对线程池的支持

  JDK 提供了一套 Executor 框架，可以帮助开发人员有效的使用线程池。

package com.jason.java.duoxiancheng.threadpool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author Jason
 */
public class Test01 {
    public static void main(String[] args) {
        //创建有 5 个线程大小的线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);

        //向线程池中提交 18 个任务，这 18 个任务存储到线程池的阻塞队列中，线程池中这 5 个线程就从阻塞队列中取任务执行
        for (int i = 0; i < 18; i++) {
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getId() + " 编号的任务在执行任务，开始时间：" + System.currentTimeMillis());
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}


package com.jason.java.duoxiancheng.threadpool;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 线程池的计划任务
 * @author Jason
 */
public class Test02 {
    public static void main(String[] args) {
        //创建一个有调度功能的线程池
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
        //在延迟2秒后执行任务，  schedule(Runnable任务，延迟时长，时间单位)
        System.out.println(System.currentTimeMillis());
        /*scheduledExecutorService.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getId() + " -- " + System.currentTimeMillis());
            }
        }, 2, TimeUnit.SECONDS);*/

        //以固定的频率执行任务，开启任务的时间是固定的，在 3 秒后执行任务，在上次任务结束后，在固定延迟后再次执行该任务，不管执行任务耗时多长，总是在任务结束后的 2 秒再次开启新的任务
        scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getId()+"----在固定频率开启任务---" + System.currentTimeMillis());
                try {
                    //睡眠模拟任务执行时间 ,如果任务执行时长超过了时间间隔,则任务完成后立即开启下个任务
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, 3, 2, TimeUnit.SECONDS);
    }
}

3.核心线程池的底层实现

  查看 Executors 工具类中 newCachedThreadPool()，newSingleThreadExecutor()，newFixedThreadPool() 源码。

 public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
    该线程池在极端情况下，每次提交新的任务都会创建新的线程执行，适合用来执行大量耗时短并且提交频繁的任务。

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

  Excutors 工具类中返回线程池的方法底层都使用了 ThreadPoolExecutor 线程池，这些方法都是 ThreadPoolExecutor 线程池的封装。

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }
  • corePoolSize，指定线程池中核心线程的数量
  • maximumPoolSize，指定线程池中最大线程数量
  • keepAliveTime，当前线程池的数量超过 corePoolSize 时，多余的空闲线程的存货时长，即空闲线程在多长时长内销毁
  • unit，是 keepAliveTime 时长单位
  • workQueue，任务队列，把任务提交到该任务队列中等待执行
  • threadFactory，线程工厂，用于创建线程
  • handler，拒绝策略，当任务太多来不及处理时，如何拒绝

说明：
  workQueue 工作队列是指提交未执行的任务队列，它是 BlockingQueue 接口的对象 ，仅用于存储 Runnable 任务。根据队列功能分类，在 ThreadPoolExecutor 构造方法中可以使用以下几种阻塞队列：
  1) 直接提交队列，由 SynchronousQueue 对象提供，该队列没有容量，提交给线程池的任务不会被真实的保存，总是将新的任务提交给线程执行，如果没有空闲线程，则尝试创建新的线程，如果线程数量已经达到 maximumPoolSize 规定的最大值则执行拒绝策略。
  2) 有界任务队列，由 ArrayBlockingQueue 实现，在创建 ArrayBlockingQueue 对象时，可以指定一个容量，当有任务需要执行时，如果线程池中线程数小于 corePoolSize 核心线程数则创建新的线程，如果大于 corePoolSize 核心线程数则加入等待队列，如果队列已满则无法加入，在线程数小于 maximumPoolSize 指定的最大线程数前提下会创建新的线程来执行，如 果 线 程 数 大 于 maxinumPoolSize 最大线程数则执行拒绝策略。
  3) 无界任务队列，由 LinkedBlockingQueue 对象实现，与有界队列相比，除非系统资源耗尽，否则无界队列不存在任务入队失败的情况。当有新的任务时，在系统线程数小于 corePoolSize 核心线程数则创建新的线程来执行任务，当线程池中线程数量大于 corePoolSize 核心线程数则把任务加入阻塞队列。
  4) 优先任务队列是通过 PriorityBlockingQueue 实现的，是代有任务优先级的队列，是一个特殊的无界队列，不管是 ArrayBlocking 队列还是 LinkedBlockingQueue 队列都是按照先进先出算法处理任务的，在 PriorityBlockingQueue 队列中可以根据任务优先级顺序先后执行。

4.拒绝策略

  ThreadPoolExecutor 构造方法的最后一个参数制定了拒绝策略，当提交给线程池的任务量超过实际承载能力时，如何处理。即线程池中的线程已经用完了，等待队列也满了，无法为新提交的任务服务，可以通过拒绝策略来处理这个问题。JDK 提供了四种拒绝策略：

  • AbortPolicy 策略，会抛出异常
  • CallerRunsPolicy 策略，只要线程池没关闭，会在调用者线程中运行当前被丢弃的任务
  • DiscardOldestPolicy，将任务队列中最老的任务丢弃，尝试再次提交新任务
  • DiscardPolicy，直接丢弃这个无法处理的任务

  Executors 工具类提供的静态方法返回的线程池默认的拒绝策略是 AbortPolicy 抛出异常，如果内置的拒绝策略无法满足实际需求，可以扩展 RejectedExecutionHandler 接口。

package com.jason.java.duoxiancheng.threadpool;

import java.util.Random;
import java.util.concurrent.*;

/**
 * 自定义拒绝策略
 * @author Jason
 */
public class Test03 {
    public static void main(String[] args) {
        //定义任务
        Runnable r = new Runnable() {
            @Override
            public void run() {
                int num = new Random().nextInt(5);
                System.out.println(Thread.currentThread().getId() + "--" + System.currentTimeMillis() + "开始睡眠" + num + "秒");
                try {
                    TimeUnit.SECONDS.sleep(num);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        //创建线程池，自定义拒绝策略
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 5, 0, TimeUnit.SECONDS, new LinkedBlockingDeque<>(10), Executors.defaultThreadFactory(), new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                //r 就是请求的任务，executor 就是当前线程池
                System.out.println(r + "id discarding...");
            }
        });
        //向线程池提交若干任务
        for (int i = 0; i < 100; i++) {
            threadPoolExecutor.submit(r);
        }
    }
}

5.ThreadFactory

  线程池中的线程从哪儿来的？答案就是 ThreadFactory。
  ThreadFactory 是一个接口，只有一个用来创建线程的方法： Thread newThread(Runnable r)；
  当线程池中需要创建线程时就会调用该方法。

package com.jason.java.duoxiancheng.threadpool;

import java.util.Random;
import java.util.concurrent.*;

/**
 * 自定义线程工厂
 * @author Jason
 */
public class Test04 {
    public static void main(String[] args) throws InterruptedException {
        //定义任务
        Runnable r = new Runnable() {
            @Override
            public void run() {
                int num = new Random().nextInt(10);
                System.out.println(Thread.currentThread().getId() + "--" + System.currentTimeMillis() + "开始睡眠：" + num + "秒");
                try {
                    TimeUnit.SECONDS.sleep(num);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        //创建线程池，使用自定义线程工厂，采用默认的拒绝策略是抛出异常
        ExecutorService executorService = new ThreadPoolExecutor(5, 5, 0, TimeUnit.SECONDS, new SynchronousQueue<>(), new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                //根据参数 r 接收的任务，创建一个线程
                Thread t = new Thread(r);
                t.setDaemon(true);//设置为守护线程，当主线程运行结束，线程池中的线程会自动退出
                System.out.println("创建了线程：" + t);
                return t;
            }
        });

        //提交5个任务，当给当前线程池提交的任务超过5个是，线程池默认抛出异常
        for (int i = 0; i < 5; i++) {
            executorService.submit(r);
        }

        //主线程睡眠
        Thread.sleep(10000);
        //主线程睡眠超时，主线程结束，线程池中的线程会自动退出
    }
}

6.监控线程池

  ThreadPoolExecutor 提供了一组方法用于监控线程池。

  • int getActiveCount() 获得线程池中当前活动线程的数量。
  • long getCompletedTaskCount() 返回线程池完成任务的数量
  • int getCorePoolSize() 线程池中核心线程的数量
  • int getLargestPoolSize() 返回线程池曾经达到的线程的最大数
  • int getMaximumPoolSize() 返回线程池的最大容量
  • int getPoolSize() 当前线程池的大小
  • BlockingQueue getQueue() 返回阻塞队列
  • long getTaskCount() 返回线程池收到的任务总数
package com.jason.java.duoxiancheng.threadpool;

import java.util.concurrent.*;

/**
 * 监控线程池
 * @author Jason
 */
public class Test05 {
    public static void main(String[] args) throws InterruptedException {
        //先定义任务
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getId() + "编号 的线程开始执行：" + System.currentTimeMillis());
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        //定义线程池
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(2, 5, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardPolicy());

        //向线程池提交 30 个任务
        for (int i = 0; i < 30; i++) {
            poolExecutor.submit(r);
            System.out.println("当前线程池核心线程数量:" + poolExecutor.getCorePoolSize() + ",最大线程数:" + poolExecutor.getMaximumPoolSize() +
                    ",当前线程池大小:" + poolExecutor.getPoolSize() + ",活动线程数量:" + poolExecutor.getActiveCount() +
                    ",收到任务数量:" + poolExecutor.getTaskCount() + ",完成任务数:" + poolExecutor.getCompletedTaskCount() +
                    ",等待任务数：" + poolExecutor.getQueue().size());
            TimeUnit.MILLISECONDS.sleep(500);
        }

        System.out.println("---------------------------");
        while (poolExecutor.getActiveCount() >= 0) {
            System.out.println("当前线程池核心线程数量:" + poolExecutor.getCorePoolSize() + ",最大线程数:" + poolExecutor.getMaximumPoolSize() +
                    ",当前线程池大小:" + poolExecutor.getPoolSize() + ",活动线程数量:" + poolExecutor.getActiveCount() +
                    ",收到任务数量:" + poolExecutor.getTaskCount() + ",完成任务数:" + poolExecutor.getCompletedTaskCount() +
                    ",等待任务数：" + poolExecutor.getQueue().size());
            Thread.sleep(1000);
        }
    }
}

7.扩展线程池

  有时需要对线程池进行扩展，如在监控每个任务的开始和结束时间，或者自定义一些其他增强的功能。
  ThreadPoolExecutor 线程池提供了两个方法：
    protected void afterExecute(Runnable r, Throwable t)
    protected void beforeExecute(Thread t, Runnable r)
  在线程池执行某个任务前会调用 beforeExecute ，在任务结束后（任务异常退出）会执行 afterExecute。
  查看 ThreadPoolExecutor 源码，在该类中定义了一个内部类 Worker，ThreadPoolExecutor 线程池中的工作线程就是 Worker 类的实例，Worker 实例会在执行时调用 beforeExecute () 与 afterExecute() 方法。

package com.jason.java.duoxiancheng.threadpool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 扩展线程池
 * @author Jason
 */
public class Test06 {
    //定义任务类
    private static class MyTask implements Runnable{
        String name;
        public MyTask(String name){
            this.name = name;
        }

        @Override
        public void run() {
            System.out.println(name + "任务正在被线程" + Thread.currentThread().getId() + " 执行");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        public static void main(String[] args) {
            //定义扩展线程池，可以定义线程池类继承 ThreadPoolExecutor，在子类中重写 beforeExecute()/afterExecute() 方法
            // 也可以直接使用 ThreadPoolExecutor 的内部类
            ExecutorService executorService = new ThreadPoolExecutor(5, 5, 0, TimeUnit.SECONDS, new LinkedBlockingDeque<>()) {
                @Override
                protected void beforeExecute(Thread t, Runnable r) {
                    System.out.println(t.getId() + "线程准备执行任务:" + ((MyTask) r).name);
                }

                @Override
                protected void afterExecute(Runnable r, Throwable t) {
                    System.out.println(((MyTask) r).name + "任务执行完毕");
                }

                @Override
                protected void terminated() {
                    System.out.println("线程池退出");
                }
            };

            //向线程池中添加任务
            for (int i = 0; i < 5; i++) {
                MyTask task = new MyTask("task-" + i);
                executorService.execute(task);
            }
            //关闭线程池
            executorService.shutdown();
            //关闭线程池仅仅是说线程池不再接收新的任务 , 线程池中已接收的任务正常执行完毕
        }
    }
}

8.优化线程池大小

  线程池大小对系统性能是有一定影响的，过大或者过小都会无法发挥最优的系统性能，线程池大小不需要非常精确，只要避免极大或者极小的情况即可，一般来说，线程池大小需要考虑 CPU 数量，内存大小等因素，在 中给出一个估算线程池大小的公式：
  线程池大小 = CPU 的数量 * 目标 CPU 的使用率*( 1 + 等待时间与计算时间的比)

9.线程池死锁

  如果在线程池中执行的 任务A 在执行过程中又向线程池提交了任务B，任务B 添加到了线程池的等待队列中，如果任务A 的结束需要等待任务B 的执行结果，就有可能会出现这种情况：线程池中所有的工作线程都处于等待任务处理结果，而这些任务在阻塞队列中等待执行，线程池中没有可以对阻塞队列中的任务进行处理的进程，这种等待会一直持续下去，从而造成死锁。
  适合给线程池提交相互独立的任务，而不是彼此依赖的任务，对于彼此依赖的任务，可以考虑分别提交给不同的线程池来执行。

10.线程池中的异常处理

11. ForkJoinPool 线程池

AJ7777777
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
pthreadpool是用于C / C ++的可移植（POSIX / Windows / Emscripten）线程池-C/C++开发
05-27
pthreadpool是一种可移植且高效的线程池实现。 它提供的功能与#pragma omp parallel类似，但具有附加功能。 pthreadpool pthreadpool是一种可移植且高效的线程池实现。 它提供的功能与#pragma omp parallel类似，但...
通过c的http服务器代码-C/C++开发
05-27
当然免不了还有 linux的多线程编程，实现了一个简单的线程池，对于各个线程之间的通信实现了一个channel, 当然最重要的是我们使用了epoll技术，让我们的服务支持高并发。下面是整个项目的架构图。 安装编译 ...
每天学习一点点20211210/20211211--线程管理
qq_45352902的博客
12-12 64
线程管理 线程组1.创建线程组2.线程组的基本操作3.复制线程组中的线程及子线程组4.线程组的批量中断5.设置守护线程组捕获线程的执行异常注入 Hool 钩子线程线程池 线程组   类似于在计算机中使用文件夹管理文件，也可以使用线程组来管理线程。在线程组中定义一组相似（相关）的线程，在线程组中也可以定义子线程组。   Thread 类有几个构造方法允许在创建线程时指定线程组，如果在创建线程时没有指定线程组则该线程就属于父线程所在的线程组。JVM 在创建 main 线程时会为它指定一个线程组，因此每个 Jav
每天学习一点点211207/211208/211209--Lock显示锁
qq_45352902的博客
12-08 535
Lock显示锁锁的可重入性ReentrantLock   在 JDK5 中增加了 Lock 锁接口，有 ReentrantLock 实现类，ReentrantLock 锁称为可重入锁，它功能比 synchronized 多。 锁的可重入性   锁的可重入是指，当一个线程获得一个对象锁后，再次请求该对象锁时是可以获得该对象的锁的。 package com.jason.java.duoxiancheng.reentrantLock; /** * @author Jason */ public class
每天学习一点点20211217--线程池中的异常处理
qq_45352902的博客
12-22 155
线程池中的异常处理   在使用 ThreadPoolExecutor 进行 submit 提交任务时，有的任务抛出了异常，但是线程池并没有进行提示，即线程池把任务中的异常给吃掉了，可以把 submit 提交改为 execute 执行，也可以对 ThreadPoolExecutor 线程池进行扩展，对提交的任务进行包装。 package com.jason.java.duoxiancheng.threadpool; import java.util.concurrent.*; /** * 自定义线程池类
每天学习一点点20211218--ForkJoinPool 线程池
qq_45352902的博客
12-22 222
ForkJoinPool 线程池
Java 并发编程(五)-线程池一
杀神lwz的博客
04-10 933
一、ThreadPool线程池 1、概述 线程池(英语:thread pool):一种线程使用模式。线程过多会带来调度开销。进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。 线程池的优势:线程池做的工作只要是控制运行的线程数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中
每天学习一点点之从 Cached 线程池到线程池的一些细节（执行、超时关闭等）
【欢迎关注公众号：冬瓜白】
09-05 479
相关文章： 每天学习一点点之 Java 七大阻塞队列之 SynchronousQueue 前天研究了一下 SynchronousQueue，那么必然不能忽略 Cached 线程池，因为它使用的阻塞队列就是 SynchronousQueue，所以今天就来探讨下 Cached 线程池（不过单独拧出 Cached 线程池其实意义不大，主要还是将 Cached 线程池作为一个切入点来分析 JUC 中的线程池） 。 线程池先看构造： public static ExecutorService newCac
网络编程之每天学习一点点[day2]-----伪异步IO
抱愚守拙，持之以恒；不问结果，相信过程.
06-17 263
在jdk1.5以前，java并没有nio的概念，对于上个例子中所讲的传统BIO，每一个客户端的每一个连接都会产生一个线程，久而久之，服务器端就会面临内存爆满的情况导致宕机。那么jdk1.5前，这个为题如何解决？答案是使用伪异步IO，就是线程池+队列组合。实现思路：对于服务端收到的每一个TCP连接，仍然创建一个线程，不过这个线程被一个线程池来管理：import java.util.concurren...
Java 并发编程(六)-线程池二
杀神lwz的博客
12-17 110
Fork/Join它可以将一个大的任务拆分成多个子任务进行并行处理，最后将子任务结果合并成最后的计算结果，并进行输出。Fork/Join框架要完成两件事情：Fork：把一个复杂任务进行分拆，大事化小Join：把分拆任务的结果进行合并。
网络编程之每天学习一点点[day5]-----真正的异步非阻塞
抱愚守拙，持之以恒；不问结果，相信过程.
06-19 365
AIO------在NIO的基础上引入了异步通道的概念，并提供了异步文件和异步套接字通道的实现，从而在真正意义上实现了异步非阻塞，这是在jdk1.7及以后才有的。AIO不需要通过类似NIO的多路复用器对注册的通道进行轮训操作，即可实现异步读写，从而简化了NIO的编程模型。也可以称为NIO2.0.这种模式才是真正的异步非阻塞模型。
C#线程处理系列之线程池中的I/O线程
09-02
在C#编程中，线程池是一个非常重要的概念，它能有效地管理线程资源，提高系统效率。在本文中，我们将深入探讨线程池中的I/O线程，以及如何利用它们来执行异步I/O操作。 首先，我们需要理解线程的分类。线程通常分为...
c/c++用一个源文件，一个头文件实现的线程池源码，包含测试代码，可运行
01-27
c/c++用一个源文件，一个头文件实现的线程池源码，包含测试代码，可运行。 说明： 1、线程池初始化时，会起多个独立线程作为线程池的work进程； 2、可修改线程池的work线程数量，需要简单修改下接口即可； 3、可设置...
cpp-threadpool一个C语言栈式线程池
08-16
标题 "cpp-threadpool一个C语言栈式线程池" 提供了一个关键信息，即这是一个用C++实现的线程池库，特别强调了其基于C语言的编程风格。线程池是一种多线程处理形式，预创建一组线程，等待处理一系列的任务，而不是...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 732
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 691
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 710
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1232
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值