简单的熔断 java实现 CircuitBreaker

简单的熔断 java实现 CircuitBreaker

接口 熔断 严格来说应该间隔一定时间后在开放请求 参考第三个熔断

public interface CircuitBreaker {
T execute();
}

1. 基于qps的熔断 即单位时间请求数不能超过阈值 否则熔断 返回默认的failback方法
   package com.multiplyzero.mz.core.rpc;

import java.util.concurrent.TimeUnit;

import com.multiplyzero.mz.core.function.Supplier;

public class QpsCircuitBreaker implements CircuitBreaker {

public Supplier<T> function;
public Supplier<T> failback;

private QpsRateLimiter rateLimiter;

public QpsCircuitBreaker(Supplier<T> function, Supplier<T> failback, int rate, long interval, TimeUnit unit) {
    this.rateLimiter = new QpsRateLimiter(rate, interval, unit);
    this.failback = failback;
    this.function = function;
}

public QpsCircuitBreaker(Supplier<T> function, int rate, long interval, TimeUnit unit) {
    this(function, null, rate, interval, unit);
}

@Override
public T execute() {
    if (this.rateLimiter.allowable()) {
        return function.get();
    }
    if (failback != null) {
        return failback.get();
    }
    return null;
}

}

2. 基于并发的熔断 即并发数不能超过阈值 否则返回默认值
   package com.multiplyzero.mz.core.rpc;

import com.multiplyzero.mz.core.function.Supplier;

public class ExecuteCircuitBreaker implements CircuitBreaker {

public Supplier<T> function;
public Supplier<T> failback;

private ExecuteRateLimiter rateLimiter;

public ExecuteCircuitBreaker(Supplier<T> function, Supplier<T> failback, int rate) {
    this.rateLimiter = new ExecuteRateLimiter(rate);
    this.failback = failback;
    this.function = function;
}

public ExecuteCircuitBreaker(Supplier<T> function, int rate) {
    this(function, null, rate);
}

@Override
public T execute() {
    if (this.rateLimiter.allowable()) {
        try {
            T t = function.get();
            return t;
        } finally {
            this.rateLimiter.release();
        }
    }
    if (failback != null) {
        return failback.get();
    }
    return null;
}

}

3. 基于异常的熔断 即单位时间内 报错数量超过阈值 熔断 返回默认值 并且一直不可访问 然后间隔一定时间后开放接口
   其实 ExecuteCircuitBreaker QpsCircuitBreaker 严格来说也应该按照这种模式 间隔一定时间后在开放请求
   package com.multiplyzero.mz.core.rpc;

import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.TimeUnit;

import com.multiplyzero.mz.core.function.Supplier;

public class ExceptionCircuitBreaker implements CircuitBreaker {

public Supplier<T> function;
public Supplier<T> failback;

private QpsRateLimiter rateLimiter;

private long delay;

private boolean allowable = true;

public ExceptionCircuitBreaker(Supplier<T> function, Supplier<T> failback, int rate, long interval,
        TimeUnit intervalUnit, long delay, TimeUnit delayUnit) {
    this.rateLimiter = new QpsRateLimiter(rate, interval, intervalUnit);
    this.failback = failback;
    this.function = function;
    this.delay = delayUnit.toMillis(delay);
}

public ExceptionCircuitBreaker(Supplier<T> function, int rate, long interval, TimeUnit intervalUnit, long delay,
        TimeUnit delayUnit) {
    this(function, null, rate, interval, intervalUnit, delay, delayUnit);
}

@Override
public T execute() {
    try {
        if (allowable) {
            return function.get();
        }
    } catch (Exception e) {
        boolean b = this.rateLimiter.allowable();
        if (!b) {
            allowable = false;
            new Timer().schedule(new TimerTask() {
                @Override
                public void run() {
                    allowable = true;
                }
            }, delay);
        }
    }
    if (failback != null) {
        return failback.get();
    }
    return null;

}

}