Spring 中的重试机制,简单、实用!

Spring Cloud: OpenFeign 超时重试机制 介绍Spring Cloud的OpenFeign中超时重传的使用 阅读详情

点击上方“芋道源码”,选择“设为星标”

管她前浪,还是后浪?

能浪的浪,才是好浪!

每天 8:55 更新文章,每天掉亿点点头发...

源码精品专栏

 

来源:albenw.github.io/posts/69a9647f


概要

Spring实现了一套重试机制,功能简单实用。Spring Retry是从Spring Batch独立出来的一个功能,已经广泛应用于Spring Batch,Spring Integration, Spring for Apache Hadoop等Spring项目。

本文将讲述如何使用Spring Retry及其实现原理。

背景

重试,其实我们其实很多时候都需要的,为了保证容错性,可用性,一致性等。一般用来应对外部系统的一些不可预料的返回、异常等,特别是网络延迟,中断等情况。还有在现在流行的微服务治理框架中,通常都有自己的重试与超时配置,比如dubbo可以设置retries=1,timeout=500调用失败只重试1次,超过500ms调用仍未返回则调用失败。

如果我们要做重试,要为特定的某个操作做重试功能,则要硬编码,大概逻辑基本都是写个循环,根据返回或异常,计数失败次数,然后设定退出条件。这样做,且不说每个操作都要写这种类似的代码,而且重试逻辑和业务逻辑混在一起,给维护和扩展带来了麻烦。

从面向对象的角度来看,我们应该把重试的代码独立出来。

使用介绍

基本使用

先举个例子:

@Configuration
@EnableRetry
public class Application {

    @Bean
    public RetryService retryService(){
        return new RetryService();
    }

    public static void main(String[] args) throws Exception{
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext("springretry");
        RetryService service1 = applicationContext.getBean("service", RetryService.class);
        service1.service();
    }
}

@Service("service")
public class RetryService {

    @Retryable(value = IllegalAccessException.class, maxAttempts = 5,
            backoff= @Backoff(value = 1500, maxDelay = 100000, multiplier = 1.2))
    public void service() throws IllegalAccessException {
        System.out.println("service method...");
        throw new IllegalAccessException("manual exception");
    }

    @Recover
    public void recover(IllegalAccessException e){
        System.out.println("service retry after Recover => " + e.getMessage());
    }

}

@EnableRetry - 表示开启重试机制

@Retryable - 表示这个方法需要重试,它有很丰富的参数,可以满足你对重试的需求

@Backoff - 表示重试中的退避策略

@Recover - 兜底方法,即多次重试后还是失败就会执行这个方法

Spring-Retry 的功能丰富在于其重试策略和退避策略,还有兜底,监听器等操作。

然后每个注解里面的参数,都是很简单的,大家看一下就知道是什么意思,怎么用了,我就不多讲了。

重试策略

看一下Spring Retry自带的一些重试策略,主要是用来判断当方法调用异常时是否需要重试。(下文原理部分会深入分析实现)

图片
  • SimpleRetryPolicy 默认最多重试3次

  • TimeoutRetryPolicy 默认在1秒内失败都会重试

  • ExpressionRetryPolicy 符合表达式就会重试

  • CircuitBreakerRetryPolicy 增加了熔断的机制,如果不在熔断状态,则允许重试

  • CompositeRetryPolicy 可以组合多个重试策略

  • NeverRetryPolicy 从不重试(也是一种重试策略哈)

  • AlwaysRetryPolicy 总是重试

….等等

退避策略

看一下退避策略,退避是指怎么去做下一次的重试,在这里其实就是等待多长时间。(下文原理部分会深入分析实现)

图片
  • FixedBackOffPolicy 默认固定延迟1秒后执行下一次重试

  • ExponentialBackOffPolicy 指数递增延迟执行重试,默认初始0.1秒,系数是2,那么下次延迟0.2秒,再下次就是延迟0.4秒,如此类推,最大30秒。

  • ExponentialRandomBackOffPolicy 在上面那个策略上增加随机性

  • UniformRandomBackOffPolicy 这个跟上面的区别就是,上面的延迟会不停递增,这个只会在固定的区间随机

  • StatelessBackOffPolicy 这个说明是无状态的,所谓无状态就是对上次的退避无感知,从它下面的子类也能看出来

原理

原理部分我想分开两部分来讲,一是重试机制的切入点,即它是如何使得你的代码实现重试功能的;二是重试机制的详细,包括重试的逻辑以及重试策略和退避策略的实现。

切入点

@EnableRetry

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@EnableAspectJAutoProxy(proxyTargetClass = false)
@Import(RetryConfiguration.class)
@Documented
public @interface EnableRetry {

 /**
  * Indicate whether subclass-based (CGLIB) proxies are to be created as opposed
  * to standard Java interface-based proxies. The default is {@code false}.
  *
  * @return whether to proxy or not to proxy the class
  */
 boolean proxyTargetClass() default false;

}

我们可以看到@EnableAspectJAutoProxy(proxyTargetClass = false)这个并不陌生,就是打开Spring AOP功能。

重点看看@Import(RetryConfiguration.class)@Import相当于注册这个Bean

我们看看这个RetryConfiguration是个什么东西:

图片

它是一个AbstractPointcutAdvisor,它有一个pointcut和一个advice。我们知道,在IOC过程中会根据PointcutAdvisor类来对Bean进行Pointcut的过滤,然后生成对应的AOP代理类,用advice来加强处理。

看看RetryConfiguration的初始化:

@PostConstruct
public void init() {
    Set<Class<? extends Annotation>> retryableAnnotationTypes = new LinkedHashSet<Class<? extends Annotation>>(1);
    retryableAnnotationTypes.add(Retryable.class);
    //创建pointcut
    this.pointcut = buildPointcut(retryableAnnotationTypes);
    //创建advice
    this.advice = buildAdvice();
    if (this.advice instanceof BeanFactoryAware) {
        ((BeanFactoryAware) this.advice).setBeanFactory(beanFactory);
    }
}
protected Pointcut buildPointcut(Set<Class<? extends Annotation>> retryAnnotationTypes) {
    ComposablePointcut result = null;
    for (Class<? extends Annotation> retryAnnotationType : retryAnnotationTypes) {
        Pointcut filter = new AnnotationClassOrMethodPointcut(retryAnnotationType);
        if (result == null) {
            result = new ComposablePointcut(filter);
        }
        else {
            result.union(filter);
        }
    }
    return result;
}

上面代码用到了AnnotationClassOrMethodPointcut,其实它最终还是用到了AnnotationMethodMatcher来根据注解进行切入点的过滤。这里就是@Retryable注解了。

//创建advice对象,即拦截器
protected Advice buildAdvice() {
    //下面关注这个对象
 AnnotationAwareRetryOperationsInterceptor interceptor = new AnnotationAwareRetryOperationsInterceptor();
 if (retryContextCache != null) {
  interceptor.setRetryContextCache(retryContextCache);
 }
 if (retryListeners != null) {
  interceptor.setListeners(retryListeners);
 }
 if (methodArgumentsKeyGenerator != null) {
  interceptor.setKeyGenerator(methodArgumentsKeyGenerator);
 }
 if (newMethodArgumentsIdentifier != null) {
  interceptor.setNewItemIdentifier(newMethodArgumentsIdentifier);
 }
 if (sleeper != null) {
  interceptor.setSleeper(sleeper);
 }
 return interceptor;
}

AnnotationAwareRetryOperationsInterceptor

继承关系

图片

可以看出AnnotationAwareRetryOperationsInterceptor是一个MethodInterceptor,在创建AOP代理过程中如果目标方法符合pointcut的规则,它就会加到interceptor列表中,然后做增强,我们看看invoke方法做了什么增强。

@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
    MethodInterceptor delegate = getDelegate(invocation.getThis(), invocation.getMethod());
    if (delegate != null) {
        return delegate.invoke(invocation);
    }
    else {
        return invocation.proceed();
    }
}

这里用到了委托,主要是需要根据配置委托给具体“有状态”的interceptor还是“无状态”的interceptor。

private MethodInterceptor getDelegate(Object target, Method method) {
    if (!this.delegates.containsKey(target) || !this.delegates.get(target).containsKey(method)) {
        synchronized (this.delegates) {
            if (!this.delegates.containsKey(target)) {
                this.delegates.put(target, new HashMap<Method, MethodInterceptor>());
            }
            Map<Method, MethodInterceptor> delegatesForTarget = this.delegates.get(target);
            if (!delegatesForTarget.containsKey(method)) {
                Retryable retryable = AnnotationUtils.findAnnotation(method, Retryable.class);
                if (retryable == null) {
                    retryable = AnnotationUtils.findAnnotation(method.getDeclaringClass(), Retryable.class);
                }
                if (retryable == null) {
                    retryable = findAnnotationOnTarget(target, method);
                }
                if (retryable == null) {
                    return delegatesForTarget.put(method, null);
                }
                MethodInterceptor delegate;
                //支持自定义MethodInterceptor,而且优先级最高
                if (StringUtils.hasText(retryable.interceptor())) {
                    delegate = this.beanFactory.getBean(retryable.interceptor(), MethodInterceptor.class);
                }
                else if (retryable.stateful()) {
                    //得到“有状态”的interceptor
                    delegate = getStatefulInterceptor(target, method, retryable);
                }
                else {
                    //得到“无状态”的interceptor
                    delegate = getStatelessInterceptor(target, method, retryable);
                }
                delegatesForTarget.put(method, delegate);
            }
        }
    }
    return this.delegates.get(target).get(method);
}

getStatefulInterceptor和getStatelessInterceptor都是差不多,我们先看看比较简单的getStatelessInterceptor。

private MethodInterceptor getStatelessInterceptor(Object target, Method method, Retryable retryable) {
    //生成一个RetryTemplate
    RetryTemplate template = createTemplate(retryable.listeners());
    //生成retryPolicy
    template.setRetryPolicy(getRetryPolicy(retryable));
    //生成backoffPolicy
    template.setBackOffPolicy(getBackoffPolicy(retryable.backoff()));
    return RetryInterceptorBuilder.stateless()
            .retryOperations(template)
            .label(retryable.label())
            .recoverer(getRecoverer(target, method))
            .build();
}

具体生成retryPolicy和backoffPolicy的规则,我们等下再回头来看。

RetryInterceptorBuilder其实就是为了生成RetryOperationsInterceptor。RetryOperationsInterceptor也是一个MethodInterceptor,我们来看看它的invoke方法。

public Object invoke(final MethodInvocation invocation) throws Throwable {

    String name;
    if (StringUtils.hasText(label)) {
        name = label;
    } else {
        name = invocation.getMethod().toGenericString();
    }
    final String label = name;

    //定义了一个RetryCallback,其实看它的doWithRetry方法,调用了invocation的proceed()方法,是不是有点眼熟,这就是AOP的拦截链调用,如果没有拦截链,那就是对原来方法的调用。
    RetryCallback<Object, Throwable> retryCallback = new RetryCallback<Object, Throwable>() {

        public Object doWithRetry(RetryContext context) throws Exception {

            context.setAttribute(RetryContext.NAME, label);

            /*
             * If we don't copy the invocation carefully it won't keep a reference to
             * the other interceptors in the chain. We don't have a choice here but to
             * specialise to ReflectiveMethodInvocation (but how often would another
             * implementation come along?).
             */
            if (invocation instanceof ProxyMethodInvocation) {
                try {
                    return ((ProxyMethodInvocation) invocation).invocableClone().proceed();
                }
                catch (Exception e) {
                    throw e;
                }
                catch (Error e) {
                    throw e;
                }
                catch (Throwable e) {
                    throw new IllegalStateException(e);
                }
            }
            else {
                throw new IllegalStateException(
                        "MethodInvocation of the wrong type detected - this should not happen with Spring AOP, " +
                                "so please raise an issue if you see this exception");
            }
        }

    };

    if (recoverer != null) {
        ItemRecovererCallback recoveryCallback = new ItemRecovererCallback(
                invocation.getArguments(), recoverer);
        return this.retryOperations.execute(retryCallback, recoveryCallback);
    }
    //最终还是进入到retryOperations的execute方法,这个retryOperations就是在之前的builder set进来的RetryTemplate。
    return this.retryOperations.execute(retryCallback);

}

无论是RetryOperationsInterceptor还是StatefulRetryOperationsInterceptor,最终的拦截处理逻辑还是调用到RetryTemplate的execute方法,从名字也看出来,RetryTemplate作为一个模板类,里面包含了重试统一逻辑。

不过,我看这个RetryTemplate并不是很“模板”,因为它没有很多可以扩展的地方。

重试逻辑及策略实现

上面介绍了Spring Retry利用了AOP代理使重试机制对业务代码进行“入侵”。下面我们继续看看重试的逻辑做了什么。RetryTemplate的doExecute方法。

protected <T, E extends Throwable> T doExecute(RetryCallback<T, E> retryCallback,
   RecoveryCallback<T> recoveryCallback, RetryState state)
   throws E, ExhaustedRetryException {

    RetryPolicy retryPolicy = this.retryPolicy;
    BackOffPolicy backOffPolicy = this.backOffPolicy;

    //新建一个RetryContext来保存本轮重试的上下文
    RetryContext context = open(retryPolicy, state);
    if (this.logger.isTraceEnabled()) {
        this.logger.trace("RetryContext retrieved: " + context);
    }

    // Make sure the context is available globally for clients who need
    // it...
    RetrySynchronizationManager.register(context);

    Throwable lastException = null;

    boolean exhausted = false;
    try {

        //如果有注册RetryListener,则会调用它的open方法,给调用者一个通知。
        boolean running = doOpenInterceptors(retryCallback, context);

        if (!running) {
            throw new TerminatedRetryException(
                    "Retry terminated abnormally by interceptor before first attempt");
        }

        // Get or Start the backoff context...
        BackOffContext backOffContext = null;
        Object resource = context.getAttribute("backOffContext");

        if (resource instanceof BackOffContext) {
            backOffContext = (BackOffContext) resource;
        }

        if (backOffContext == null) {
            backOffContext = backOffPolicy.start(context);
            if (backOffContext != null) {
                context.setAttribute("backOffContext", backOffContext);
            }
        }

        //判断能否重试,就是调用RetryPolicy的canRetry方法来判断。
        //这个循环会直到原方法不抛出异常,或不需要再重试
        while (canRetry(retryPolicy, context) && !context.isExhaustedOnly()) {

            try {
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Retry: count=" + context.getRetryCount());
                }
                //清除上次记录的异常
                lastException = null;
                //doWithRetry方法,一般来说就是原方法
                return retryCallback.doWithRetry(context);
            }
            catch (Throwable e) {
                //原方法抛出了异常
                lastException = e;

                try {
                    //记录异常信息
                    registerThrowable(retryPolicy, state, context, e);
                }
                catch (Exception ex) {
                    throw new TerminatedRetryException("Could not register throwable",
                            ex);
                }
                finally {
                    //调用RetryListener的onError方法
                    doOnErrorInterceptors(retryCallback, context, e);
                }
                //再次判断能否重试
                if (canRetry(retryPolicy, context) && !context.isExhaustedOnly()) {
                    try {
                        //如果可以重试则走退避策略
                        backOffPolicy.backOff(backOffContext);
                    }
                    catch (BackOffInterruptedException ex) {
                        lastException = e;
                        // back off was prevented by another thread - fail the retry
                        if (this.logger.isDebugEnabled()) {
                            this.logger
                                    .debug("Abort retry because interrupted: count="
                                            + context.getRetryCount());
                        }
                        throw ex;
                    }
                }

                if (this.logger.isDebugEnabled()) {
                    this.logger.debug(
                            "Checking for rethrow: count=" + context.getRetryCount());
                }

                if (shouldRethrow(retryPolicy, context, state)) {
                    if (this.logger.isDebugEnabled()) {
                        this.logger.debug("Rethrow in retry for policy: count="
                                + context.getRetryCount());
                    }
                    throw RetryTemplate.<E>wrapIfNecessary(e);
                }

            }

            /*
             * A stateful attempt that can retry may rethrow the exception before now,
             * but if we get this far in a stateful retry there's a reason for it,
             * like a circuit breaker or a rollback classifier.
             */
            if (state != null && context.hasAttribute(GLOBAL_STATE)) {
                break;
            }
        }

        if (state == null && this.logger.isDebugEnabled()) {
            this.logger.debug(
                    "Retry failed last attempt: count=" + context.getRetryCount());
        }

        exhausted = true;
        //重试结束后如果有兜底Recovery方法则执行,否则抛异常
        return handleRetryExhausted(recoveryCallback, context, state);

    }
    catch (Throwable e) {
        throw RetryTemplate.<E>wrapIfNecessary(e);
    }
    finally {
        //处理一些关闭逻辑
        close(retryPolicy, context, state, lastException == null || exhausted);
        //调用RetryListener的close方法
        doCloseInterceptors(retryCallback, context, lastException);
        RetrySynchronizationManager.clear();
    }

}

主要核心重试逻辑就是上面的代码了,看上去还是挺简单的。

在上面,我们漏掉了RetryPolicy的canRetry方法和BackOffPolicy的backOff方法,以及这两个Policy是怎么来的。我们回头看看getStatelessInterceptor方法中的getRetryPolicy和getRetryPolicy方法。

private RetryPolicy getRetryPolicy(Annotation retryable) {
    Map<String, Object> attrs = AnnotationUtils.getAnnotationAttributes(retryable);
    @SuppressWarnings("unchecked")
    Class<? extends Throwable>[] includes = (Class<? extends Throwable>[]) attrs.get("value");
    String exceptionExpression = (String) attrs.get("exceptionExpression");
    boolean hasExpression = StringUtils.hasText(exceptionExpression);
    if (includes.length == 0) {
        @SuppressWarnings("unchecked")
        Class<? extends Throwable>[] value = (Class<? extends Throwable>[]) attrs.get("include");
        includes = value;
    }
    @SuppressWarnings("unchecked")
    Class<? extends Throwable>[] excludes = (Class<? extends Throwable>[]) attrs.get("exclude");
    Integer maxAttempts = (Integer) attrs.get("maxAttempts");
    String maxAttemptsExpression = (String) attrs.get("maxAttemptsExpression");
    if (StringUtils.hasText(maxAttemptsExpression)) {
        maxAttempts = PARSER.parseExpression(resolve(maxAttemptsExpression), PARSER_CONTEXT)
                .getValue(this.evaluationContext, Integer.class);
    }
    if (includes.length == 0 && excludes.length == 0) {
        SimpleRetryPolicy simple = hasExpression ? new ExpressionRetryPolicy(resolve(exceptionExpression))
                                                        .withBeanFactory(this.beanFactory)
                                                 : new SimpleRetryPolicy();
        simple.setMaxAttempts(maxAttempts);
        return simple;
    }
    Map<Class<? extends Throwable>, Boolean> policyMap = new HashMap<Class<? extends Throwable>, Boolean>();
    for (Class<? extends Throwable> type : includes) {
        policyMap.put(type, true);
    }
    for (Class<? extends Throwable> type : excludes) {
        policyMap.put(type, false);
    }
    boolean retryNotExcluded = includes.length == 0;
    if (hasExpression) {
        return new ExpressionRetryPolicy(maxAttempts, policyMap, true, exceptionExpression, retryNotExcluded)
                .withBeanFactory(this.beanFactory);
    }
    else {
        return new SimpleRetryPolicy(maxAttempts, policyMap, true, retryNotExcluded);
    }
}

嗯~,代码不难,这里简单做一下总结好了。就是通过@Retryable注解中的参数,来判断具体使用文章开头说到的哪个重试策略,是SimpleRetryPolicy还是ExpressionRetryPolicy等。

private BackOffPolicy getBackoffPolicy(Backoff backoff) {
    long min = backoff.delay() == 0 ? backoff.value() : backoff.delay();
    if (StringUtils.hasText(backoff.delayExpression())) {
        min = PARSER.parseExpression(resolve(backoff.delayExpression()), PARSER_CONTEXT)
                .getValue(this.evaluationContext, Long.class);
    }
    long max = backoff.maxDelay();
    if (StringUtils.hasText(backoff.maxDelayExpression())) {
        max = PARSER.parseExpression(resolve(backoff.maxDelayExpression()), PARSER_CONTEXT)
                .getValue(this.evaluationContext, Long.class);
    }
    double multiplier = backoff.multiplier();
    if (StringUtils.hasText(backoff.multiplierExpression())) {
        multiplier = PARSER.parseExpression(resolve(backoff.multiplierExpression()), PARSER_CONTEXT)
                .getValue(this.evaluationContext, Double.class);
    }
    if (multiplier > 0) {
        ExponentialBackOffPolicy policy = new ExponentialBackOffPolicy();
        if (backoff.random()) {
            policy = new ExponentialRandomBackOffPolicy();
        }
        policy.setInitialInterval(min);
        policy.setMultiplier(multiplier);
        policy.setMaxInterval(max > min ? max : ExponentialBackOffPolicy.DEFAULT_MAX_INTERVAL);
        if (this.sleeper != null) {
            policy.setSleeper(this.sleeper);
        }
        return policy;
    }
    if (max > min) {
        UniformRandomBackOffPolicy policy = new UniformRandomBackOffPolicy();
        policy.setMinBackOffPeriod(min);
        policy.setMaxBackOffPeriod(max);
        if (this.sleeper != null) {
            policy.setSleeper(this.sleeper);
        }
        return policy;
    }
    FixedBackOffPolicy policy = new FixedBackOffPolicy();
    policy.setBackOffPeriod(min);
    if (this.sleeper != null) {
        policy.setSleeper(this.sleeper);
    }
    return policy;
}

嗯~,一样的味道。就是通过@Backoff注解中的参数,来判断具体使用文章开头说到的哪个退避策略,是FixedBackOffPolicy还是UniformRandomBackOffPolicy等。

那么每个RetryPolicy都会重写canRetry方法,然后在RetryTemplate判断是否需要重试。我们看看SimpleRetryPolicy的

@Override
public boolean canRetry(RetryContext context) {
    Throwable t = context.getLastThrowable();
    //判断抛出的异常是否符合重试的异常
    //还有,是否超过了重试的次数
    return (t == null || retryForException(t)) && context.getRetryCount() < maxAttempts;
}

同样,我们看看FixedBackOffPolicy的退避方法。

protected void doBackOff() throws BackOffInterruptedException {
    try {
        //就是sleep固定的时间
        sleeper.sleep(backOffPeriod);
    }
    catch (InterruptedException e) {
        throw new BackOffInterruptedException("Thread interrupted while sleeping", e);
    }
}

至此,重试的主要原理以及逻辑大概就是这样了。

RetryContext

我觉得有必要说说RetryContext,先看看它的继承关系。

图片

可以看出对每一个策略都有对应的Context。

在Spring Retry里,其实每一个策略都是单例来的。我刚开始直觉是对每一个需要重试的方法都会new一个策略,这样重试策略之间才不会产生冲突,但是一想就知道这样就可能多出了很多策略对象出来,增加了使用者的负担,这不是一个好的设计。

Spring Retry采用了一个更加轻量级的做法,就是针对每一个需要重试的方法只new一个上下文Context对象,然后在重试时,把这个Context传到策略里,策略再根据这个Context做重试,而且Spring Retry还对这个Context做了cache。这样就相当于对重试的上下文做了优化。

总结

Spring Retry通过AOP机制来实现对业务代码的重试”入侵“,RetryTemplate中包含了核心的重试逻辑,还提供了丰富的重试策略和退避策略。



欢迎加入我的知识星球,一起探讨架构,交流源码。加入方式,长按下方二维码噢:

已在知识星球更新源码解析如下:

最近更新《芋道 SpringBoot 2.X 入门》系列,已经 20 余篇,覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。

提供近 3W 行代码的 SpringBoot 示例,以及超 4W 行代码的电商微服务项目。

获取方式:点“在看”,关注公众号并回复 666 领取,更多内容陆续奉上。

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
ARM和FPGA之间的通信(硬件原理图篇) 设计该开发板的初衷是为了学习,但也希望今后能扩展其功能,看到大家都在diy示波器,自己也非常冲动的想DIY一把,于是呼选了arm+fpga的方案,fpga主要用来实现数据的高速采样,而ARM则提供数据的显示,以及一些人机交互的功能。那么该方案中最重要的地方就是ARM和FPGA之间的通信如何实现了。在网上查了很多的资料,有说将FPGA作为ARM的一个外设,可以通过DMA的方式来直接访问;也有说把FP 阅读详情

相关推荐

用ESP32-S3+OV2640摄像头+ILI9488屏,DIY一个能联网的智能猫眼(附完整代码)

本文详细介绍了如何利用ESP32-S3微控制器搭配OV2640摄像头和ILI9488显示屏,DIY一个功能强大的智能猫眼系统。从硬件选型、电路设计到软件开发,提供了完整的解决方案和优化技巧,包括图像采集显示、WiFi远程访问及低功耗设计,适合智能家居爱好者动手实践。

weixin_30897233的博客 504

记录一次使用@Retryable和@Recover的过程

使用@Retryable和@Recover常见问题

xiaosun2194的博客 563

HBF凭什么能挑战HBM?

最近AI圈聊得最多的,除了大模型迭代,就是“算力瓶颈”。大家都知道GPU不够用、HBM抢疯了,但很少有人注意到,存储层正在酝酿一场革命——高带宽闪存(HBF)。今天就结合HBM之父Joungho Kim教授的最新观点,跟大家好好盘盘这门技术:它不是HBM的替代品,却可能重塑AI推理的游戏规则,甚至在2038年超越HBM市场规模。先澄清一个核心认知:HBF不是凭空冒出来的新技术,而是站在HBM肩膀上的“优化款”。

存储随笔 2132

Spring-Retry(重试机制)

Spring-Retry(重试机制)

爱笑的boy的博客 1万+

解决 PyInstaller 与 `pathlib` 包不兼容的问题

为了避免 PyInstaller 和pathlib包的兼容性问题,最简单的解决办法就是卸载不必要的pathlib包。只需在命令行中运行卸载命令,然后重新打包即可。

Winfredzhang的博客 3227

ArcGIS符号库下载 | 制图规范、三调、1:1万地形图、土地利用总体规划图.....

最近整理了一些符号库 涉及的类型比较多 包含有三调的(二调的也加上去了),一些点线面符号库,1:1万地形图,1:5万土地利用,土地利用总体规划图

qq_43173805的博客 2万+

spring中重试机制详解

spring中的重试机制

卓越之识论道,平常之识论事,狭隘之识论人 3166

用Python可视化硅晶体生长:3D图解<100>/<110>/<111>晶向差异

本文通过Python 3D可视化技术,详细解析了硅晶体生长中<100>、<110>、<111>三种关键晶向的差异及其在半导体工业中的应用。从密勒指数转换到原子密度计算,结合交互式3D模型展示不同晶向的原子排列特性,帮助读者深入理解晶向对芯片性能的影响。

weixin_42567752的博客 573

Spring Retry方法重试

介绍 使用 注解方式:@Retryable Retryable注解的属性 Retryable注解的使用 模板方式:RetryTemplate

骑个小蜗牛的博客 5075

从2D到3D地图开发:手把手教你用Cesium+Three.js实现卫星轨迹可视化(含代码片段)

本文详细介绍了如何结合Cesium与Three.js实现从2D到3D的卫星轨迹可视化。通过对比传统Web GIS框架的局限,阐述了Cesium处理三维地理与轨道数据、Three.js负责高级图形渲染的分工优势,并提供了从环境搭建、坐标同步到动态粒子效果实现的完整代码实战指南。

nut55的博客 674

Vue - 在纯 HTML 普通项目中实现组件化,让原生 html 项目支持引入 *.vue 组件 / 组件与组件间的互相引用等,完美解决了引入组件出现的跨域问题(保姆级详细教程,完整示例源码及插件)

html中使用vue组件,在HTML页面中引入vue组件,HTML界面利用http-vue-loader.js以组件方式引入vue文件,使用http-vue-loader引入组件出现报错,在html页面使用http-vue-loader插件引入组件报跨域错误,如何解决http-vue-loader引用组件时出现跨域问题,纯html原生web项目引入vue后如何实现组件引入,使用http-vue-loader插件控制台报错跨域,http-vue-loader跨域怎么办官方文档,html页面如何引入.vu

🏆 前端领域优质创作者 3910

Spring 重试机制 @Retryable

2、在启动类或者方法所在的类上添加注解@EnableRetry 3、在需要重试的方法上添加注解@Retryable,示例如下: @Retryable注解中的参数说明: maxAttempts :最大重试次数,默认为3,如果要设置的重试次数为3,可以不写; value:抛出指定异常才会重试 include:和value一样,默认为空,当exclude也为空时,默认所以异常 exclude:指定不处理的异常 backoff:重试等待策略,默认使用@Backoff的value默认为1000L @Backo

窗边冷月光 6017

MATLAB - 利用非线性模型预测控制(Nonlinear MPC)来控制四旋翼飞行器

本示例展示了如何利用非线性模型预测控制(MPC)为四旋翼飞行器设计一个跟踪轨迹的控制器。

机器人控制与仿真应用 4435

【重试】Java 中的 7 种重试机制

如果是基于 Spring 的项目,使用 Spring Retry 的注解方式已经可以解决大部分问题如果项目没有使用 Spring 相关框架,则适合使用 Google guava-retrying:自成体系,使用起来更加灵活强大【转载】Java重试机制Java教程:重试实现高可用一览。

sco5282的博客 1万+

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

实现重试只知道Spring Retry?试试Spring Boot 整合 Fast Retry 来实现重试机制

在外面日常开发中,服务之间的调用往往存在延迟和失败的情况。比如之前博主写的一篇【Spring Boot集成 Spring Retry 实现容错重试机制并附源码】短信发送远程服务调用争抢锁网络延迟服务宕机或临时故障等问题。为了提高服务的可靠性,我们可以使用重试机制来处理这些问题,之前我们已经介绍了,今天我们介绍另外一款轻量级的Fast Retry库。Fast Retry是一个轻量级的 Java 重试库,它可以方便地为方法调用添加重试机制。

Micro麦可乐的博客 1万+

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

Java Retry 重试 Java 重试机制 Spring Retry 重试机制 Java Spring Retry 实现代码重试

Java Retry 重试 Java 重试机制 Spring Retry 重试机制 Java Spring Retry 实现代码重试

HaHa_Sir的博客 5018

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

Spring Cloud Gateway重试机制

前言 重试,我相信大家并不陌生。在我们调用Http接口的时候,总会因为某种原因调用失败,这个时候我们可以通过重试的方式,来重新请求接口。 生活中这样的事例很多,比如打电话,对方正在通话中啊,信号不好啊等等原因,你总会打不通,当你第一次没打通之后,你会打第二次,第三次…第四次就通了。 重试也要注意应用场景,读数据的接口比较适合重试的场景,写数据的接口就需要注意接口的幂等性了。还有就是重试次数如...

u010889990的专栏 1万+

Spring Boot 中的重试机制

Retryable注解是 Spring Retry 模块提供的,用于自动重试可能会失败的方法。在微服务架构和分布式系统中,服务之间的调用可能会因为网络问题、服务繁忙等原因失败。使用@Retryable可以提高应用的稳定性和容错能力1。

m0_73837751的博客 1254

spring的@Retryable重试机制

前言 在很多业务场景中,我们需要用重试机制。比如说在微服务中,服务之间的调用有时候会因为网络波动导致调用失败,这时候代码中进行失败重试就ok了,当然这种重试机制通常会和异步结合使用,否则因为重试导致响应时间变长,这肯定是不行的。至于异步,无论是spring自带的异步机制,还是整合消息中间件。具体异步方式这里不重点讲。当然我们也可以自己用代码逻辑实现重试,不过这种方式不统一,要写一些非业务代码,对...

爱琴孩的博客 4807

Spring Retry 重试机制 10 分钟立马掌握

特别鸣谢:https://blog.youkuaiyun.com/Revivedsun/article/details/53401335 参考方式:以下内容都是demo,直接复制粘贴到项目中即可。 1.自定义手写重试机制 参考地址:https://blog.youkuaiyun.com/u010081710/article/details/77879129 参考地址:https://blog.youkuaiyun.com/x...

easy_to_know的博客 9484

JAVA如何优雅的重试?@Retryable(spring的重试机制)

楔子 在应用程序中,由于一些网络等不可预知的问题,我们的程序或者接口会失败,比如调用一个第三方的接口获取数据失败了,这时就需要重试机制,比如延时3S后重试、间隔不断增加重试等,而这些机制完全不需要你自己去实现,全部交给Spring Retry吧。 使用 1.在pom文件中添加相应的依赖 <dependency> <groupId>org.springframewor...

借你一秒 2万+

RabbitMQ 高级特性——重试机制

RabbitMQ重试机制

不能再留遗憾了的博客 2641
上一篇: 一个注解搞定 SpringBoot 接口防刷,还有谁不会?
下一篇: 再见了,收费的Navicat。
公众号-芋道源码
博客等级 码龄10年 1639粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值