徒手撸了一个RPC框架,理解更透彻了,代码已上传github,自取~

前端工程师成长的三次能力跃迁与面试底层逻辑 前端工程师的核心能力已从页面实现转向系统思维与问题解决,其职业演进本质是‘能力坐标系’的持续迁移:从像素级还原到体验定义,从单点技术到全链路系统理解,再到基于问题本质动态选型的技术决策力。这种转变使面试不再考察API记忆,而聚焦于技术抽象能力、工程判断力与协作质感。真实项目中的可量化优化、GitHub上的技术人格表达、对Web Vitals等性能指标的主动诊断,正成为比框架熟练度更关键的能力信号。本文结合400+场一线面试经验,解析前端人才评估的真实维度。 阅读详情

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

管她前浪,还是后浪?

能浪的浪,才是好浪!

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

源码精品专栏

 

来源:cnblogs.com/2YSP/p/13545217.html


一、前言

前段时间看到一篇不错的文章《看了这篇你就会手写RPC框架了》,于是便来了兴趣对着实现了一遍,后面觉得还有很多优化的地方便对其进行了改进。

主要改动点如下:

  1. 除了Java序列化协议,增加了protobuf和kryo序列化协议,配置即用。

  2. 增加多种负载均衡算法(随机、轮询、加权轮询、平滑加权轮询),配置即用。

  3. 客户端增加本地服务列表缓存,提高性能。

  4. 修复高并发情况下,netty导致的内存泄漏问题

  5. 由原来的每个请求建立一次连接,改为建立TCP长连接,并多次复用。

  6. 服务端增加线程池提高消息处理能力

二、介绍

RPC,即 Remote Procedure Call(远程过程调用),调用远程计算机上的服务,就像调用本地服务一样。RPC可以很好的解耦系统,如WebService就是一种基于Http协议的RPC。

调用示意图

调用示意图

总的来说,就如下几个步骤:

  1. 客户端(ServerA)执行远程方法时就调用client stub传递类名、方法名和参数等信息。

  2. client stub会将参数等信息序列化为二进制流的形式,然后通过Sockect发送给服务端(ServerB)

  3. 服务端收到数据包后,server stub 需要进行解析反序列化为类名、方法名和参数等信息。

  4. server stub调用对应的本地方法,并把执行结果返回给客户端

所以一个RPC框架有如下角色:

服务消费者

远程方法的调用方,即客户端。一个服务既可以是消费者也可以是提供者。

服务提供者

远程服务的提供方,即服务端。一个服务既可以是消费者也可以是提供者。

注册中心

保存服务提供者的服务地址等信息,一般由zookeeper、redis等实现。

监控运维(可选)

监控接口的响应时间、统计请求数量等,及时发现系统问题并发出告警通知。

三、实现

本RPC框架rpc-spring-boot-starter涉及技术栈如下:

  • 使用zookeeper作为注册中心

  • 使用netty作为通信框架

  • 消息编解码:protostuff、kryo、java

  • spring

  • 使用SPI来根据配置动态选择负载均衡算法等

由于代码过多,这里只讲几处改动点。

3.1 动态负载均衡算法

1.编写LoadBalance的实现类

负载均衡算法实现类

2.自定义注解 @LoadBalanceAno

/**
 * 负载均衡注解
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface LoadBalanceAno {

    String value() default "";
}

/**
 * 轮询算法
 */
@LoadBalanceAno(RpcConstant.BALANCE_ROUND)
public class FullRoundBalance implements LoadBalance {

    private static Logger logger = LoggerFactory.getLogger(FullRoundBalance.class);

    private volatile int index;

    @Override
    public synchronized Service chooseOne(List<Service> services) {
        // 加锁防止多线程情况下,index超出services.size()
        if (index == services.size()) {
            index = 0;
        }
        return services.get(index++);
    }
}

3.新建在resource目录下META-INF/servers文件夹并创建文件

enter description here

4.RpcConfig增加配置项loadBalance

/**
 * @author 2YSP
 * @date 2020/7/26 15:13
 */
@ConfigurationProperties(prefix = "sp.rpc")
public class RpcConfig {

    /**
     * 服务注册中心地址
     */
    private String registerAddress = "127.0.0.1:2181";

    /**
     * 服务暴露端口
     */
    private Integer serverPort = 9999;
    /**
     * 服务协议
     */
    private String protocol = "java";
    /**
     * 负载均衡算法
     */
    private String loadBalance = "random";
    /**
     * 权重,默认为1
     */
    private Integer weight = 1;

   // 省略getter setter
}

5.在自动配置类RpcAutoConfiguration根据配置选择对应的算法实现类

/**
     * 使用spi匹配符合配置的负载均衡算法
     *
     * @param name
     * @return
     */
    private LoadBalance getLoadBalance(String name) {
        ServiceLoader<LoadBalance> loader = ServiceLoader.load(LoadBalance.class);
        Iterator<LoadBalance> iterator = loader.iterator();
        while (iterator.hasNext()) {
            LoadBalance loadBalance = iterator.next();
            LoadBalanceAno ano = loadBalance.getClass().getAnnotation(LoadBalanceAno.class);
            Assert.notNull(ano, "load balance name can not be empty!");
            if (name.equals(ano.value())) {
                return loadBalance;
            }
        }
        throw new RpcException("invalid load balance config");
    }

 @Bean
    public ClientProxyFactory proxyFactory(@Autowired RpcConfig rpcConfig) {
        ClientProxyFactory clientProxyFactory = new ClientProxyFactory();
        // 设置服务发现着
        clientProxyFactory.setServerDiscovery(new           ZookeeperServerDiscovery(rpcConfig.getRegisterAddress()));

        // 设置支持的协议
        Map<String, MessageProtocol> supportMessageProtocols = buildSupportMessageProtocols();
        clientProxyFactory.setSupportMessageProtocols(supportMessageProtocols);
        // 设置负载均衡算法
        LoadBalance loadBalance = getLoadBalance(rpcConfig.getLoadBalance());
        clientProxyFactory.setLoadBalance(loadBalance);
        // 设置网络层实现
        clientProxyFactory.setNetClient(new NettyNetClient());

        return clientProxyFactory;
    }

3.2 本地服务列表缓存

使用Map来缓存数据

/**
 * 服务发现本地缓存
 */
public class ServerDiscoveryCache {
    /**
     * key: serviceName
     */
    private static final Map<String, List<Service>> SERVER_MAP = new ConcurrentHashMap<>();
    /**
     * 客户端注入的远程服务service class
     */
    public static final List<String> SERVICE_CLASS_NAMES = new ArrayList<>();

    public static void put(String serviceName, List<Service> serviceList) {
        SERVER_MAP.put(serviceName, serviceList);
    }

    /**
     * 去除指定的值
     * @param serviceName
     * @param service
     */
    public static void remove(String serviceName, Service service) {
        SERVER_MAP.computeIfPresent(serviceName, (key, value) ->
                value.stream().filter(o -> !o.toString().equals(service.toString())).collect(Collectors.toList())
        );
    }

    public static void removeAll(String serviceName) {
        SERVER_MAP.remove(serviceName);
    }


    public static boolean isEmpty(String serviceName) {
        return SERVER_MAP.get(serviceName) == null || SERVER_MAP.get(serviceName).size() == 0;
    }

    public static List<Service> get(String serviceName) {
        return SERVER_MAP.get(serviceName);
    }
}

ClientProxyFactory,先查本地缓存,缓存没有再查询zookeeper。

/**
     * 根据服务名获取可用的服务地址列表
     * @param serviceName
     * @return
     */
    private List<Service> getServiceList(String serviceName) {
        List<Service> services;
        synchronized (serviceName){
            if (ServerDiscoveryCache.isEmpty(serviceName)) {
                services = serverDiscovery.findServiceList(serviceName);
                if (services == null || services.size() == 0) {
                    throw new RpcException("No provider available!");
                }
                ServerDiscoveryCache.put(serviceName, services);
            } else {
                services = ServerDiscoveryCache.get(serviceName);
            }
        }
        return services;
    }

问题: 如果服务端因为宕机或网络问题下线了,缓存却还在就会导致客户端请求已经不可用的服务端,增加请求失败率。解决方案: 由于服务端注册的是临时节点,所以如果服务端下线节点会被移除。只要监听zookeeper的子节点,如果新增或删除子节点就直接清空本地缓存即可。

DefaultRpcProcessor

/**
 * Rpc处理者,支持服务启动暴露,自动注入Service
 * @author 2YSP
 * @date 2020/7/26 14:46
 */
public class DefaultRpcProcessor implements ApplicationListener<ContextRefreshedEvent> {



    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        // Spring启动完毕过后会收到一个事件通知
        if (Objects.isNull(event.getApplicationContext().getParent())){
            ApplicationContext context = event.getApplicationContext();
            // 开启服务
            startServer(context);
            // 注入Service
            injectService(context);
        }
    }

    private void injectService(ApplicationContext context) {
        String[] names = context.getBeanDefinitionNames();
        for(String name : names){
            Class<?> clazz = context.getType(name);
            if (Objects.isNull(clazz)){
                continue;
            }

            Field[] declaredFields = clazz.getDeclaredFields();
            for(Field field : declaredFields){
                // 找出标记了InjectService注解的属性
                InjectService injectService = field.getAnnotation(InjectService.class);
                if (injectService == null){
                    continue;
                }

                Class<?> fieldClass = field.getType();
                Object object = context.getBean(name);
                field.setAccessible(true);
                try {
                    field.set(object,clientProxyFactory.getProxy(fieldClass));
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
    // 添加本地服务缓存
                ServerDiscoveryCache.SERVICE_CLASS_NAMES.add(fieldClass.getName());
            }
        }
        // 注册子节点监听
        if (clientProxyFactory.getServerDiscovery() instanceof ZookeeperServerDiscovery){
            ZookeeperServerDiscovery serverDiscovery = (ZookeeperServerDiscovery) clientProxyFactory.getServerDiscovery();
            ZkClient zkClient = serverDiscovery.getZkClient();
            ServerDiscoveryCache.SERVICE_CLASS_NAMES.forEach(name ->{
                String servicePath = RpcConstant.ZK_SERVICE_PATH + RpcConstant.PATH_DELIMITER + name + "/service";
                zkClient.subscribeChildChanges(servicePath, new ZkChildListenerImpl());
            });
            logger.info("subscribe service zk node successfully");
        }

    }

    private void startServer(ApplicationContext context) {
        ...

    }
}

ZkChildListenerImpl

/**
 * 子节点事件监听处理类
 */
public class ZkChildListenerImpl implements IZkChildListener {

    private static Logger logger = LoggerFactory.getLogger(ZkChildListenerImpl.class);

    /**
     * 监听子节点的删除和新增事件
     * @param parentPath /rpc/serviceName/service
     * @param childList
     * @throws Exception
     */
    @Override
    public void handleChildChange(String parentPath, List<String> childList) throws Exception {
        logger.debug("Child change parentPath:[{}] -- childList:[{}]", parentPath, childList);
        // 只要子节点有改动就清空缓存
        String[] arr = parentPath.split("/");
        ServerDiscoveryCache.removeAll(arr[2]);
    }
}

3.3 nettyClient支持TCP长连接

这部分的改动最多,先增加新的sendRequest接口。

添加接口

实现类NettyNetClient

/**
 * @author 2YSP
 * @date 2020/7/25 20:12
 */
public class NettyNetClient implements NetClient {

    private static Logger logger = LoggerFactory.getLogger(NettyNetClient.class);

    private static ExecutorService threadPool = new ThreadPoolExecutor(4, 10, 200,
            TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000), new ThreadFactoryBuilder()
            .setNameFormat("rpcClient-%d")
            .build());

    private EventLoopGroup loopGroup = new NioEventLoopGroup(4);

    /**
     * 已连接的服务缓存
     * key: 服务地址,格式:ip:port
     */
    public static Map<String, SendHandlerV2> connectedServerNodes = new ConcurrentHashMap<>();

    @Override
    public byte[] sendRequest(byte[] data, Service service) throws InterruptedException {
  ....
        return respData;
    }

    @Override
    public RpcResponse sendRequest(RpcRequest rpcRequest, Service service, MessageProtocol messageProtocol) {

        String address = service.getAddress();
        synchronized (address) {
            if (connectedServerNodes.containsKey(address)) {
                SendHandlerV2 handler = connectedServerNodes.get(address);
                logger.info("使用现有的连接");
                return handler.sendRequest(rpcRequest);
            }

            String[] addrInfo = address.split(":");
            final String serverAddress = addrInfo[0];
            final String serverPort = addrInfo[1];
            final SendHandlerV2 handler = new SendHandlerV2(messageProtocol, address);
            threadPool.submit(() -> {
                        // 配置客户端
                        Bootstrap b = new Bootstrap();
                        b.group(loopGroup).channel(NioSocketChannel.class)
                                .option(ChannelOption.TCP_NODELAY, true)
                                .handler(new ChannelInitializer<SocketChannel>() {
                                    @Override
                                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                                        ChannelPipeline pipeline = socketChannel.pipeline();
                                        pipeline
                                                .addLast(handler);
                                    }
                                });
                        // 启用客户端连接
                        ChannelFuture channelFuture = b.connect(serverAddress, Integer.parseInt(serverPort));
                        channelFuture.addListener(new ChannelFutureListener() {
                            @Override
                            public void operationComplete(ChannelFuture channelFuture) throws Exception {
                                connectedServerNodes.put(address, handler);
                            }
                        });
                    }
            );
            logger.info("使用新的连接。。。");
            return handler.sendRequest(rpcRequest);
        }
    }
}

每次请求都会调用sendRequest()方法,用线程池异步和服务端创建TCP长连接,连接成功后将SendHandlerV2缓存到ConcurrentHashMap中方便复用,后续请求的请求地址(ip+port)如果在connectedServerNodes中存在则使用connectedServerNodes中的handler处理不再重新建立连接。

SendHandlerV2

/**
 * @author 2YSP
 * @date 2020/8/19 20:06
 */
public class SendHandlerV2 extends ChannelInboundHandlerAdapter {

    private static Logger logger = LoggerFactory.getLogger(SendHandlerV2.class);

    /**
     * 等待通道建立最大时间
     */
    static final int CHANNEL_WAIT_TIME = 4;
    /**
     * 等待响应最大时间
     */
    static final int RESPONSE_WAIT_TIME = 8;

    private volatile Channel channel;

    private String remoteAddress;

    private static Map<String, RpcFuture<RpcResponse>> requestMap = new ConcurrentHashMap<>();

    private MessageProtocol messageProtocol;

    private CountDownLatch latch = new CountDownLatch(1);

    public SendHandlerV2(MessageProtocol messageProtocol,String remoteAddress) {
        this.messageProtocol = messageProtocol;
        this.remoteAddress = remoteAddress;
    }

    @Override
    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
        this.channel = ctx.channel();
        latch.countDown();
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        logger.debug("Connect to server successfully:{}", ctx);
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.debug("Client reads message:{}", msg);
        ByteBuf byteBuf = (ByteBuf) msg;
        byte[] resp = new byte[byteBuf.readableBytes()];
        byteBuf.readBytes(resp);
        // 手动回收
        ReferenceCountUtil.release(byteBuf);
        RpcResponse response = messageProtocol.unmarshallingResponse(resp);
        RpcFuture<RpcResponse> future = requestMap.get(response.getRequestId());
        future.setResponse(response);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        logger.error("Exception occurred:{}", cause.getMessage());
        ctx.close();
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        super.channelInactive(ctx);
        logger.error("channel inactive with remoteAddress:[{}]",remoteAddress);
        NettyNetClient.connectedServerNodes.remove(remoteAddress);

    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        super.userEventTriggered(ctx, evt);
    }

    public RpcResponse sendRequest(RpcRequest request) {
        RpcResponse response;
        RpcFuture<RpcResponse> future = new RpcFuture<>();
        requestMap.put(request.getRequestId(), future);
        try {
            byte[] data = messageProtocol.marshallingRequest(request);
            ByteBuf reqBuf = Unpooled.buffer(data.length);
            reqBuf.writeBytes(data);
            if (latch.await(CHANNEL_WAIT_TIME,TimeUnit.SECONDS)){
                channel.writeAndFlush(reqBuf);
                // 等待响应
                response = future.get(RESPONSE_WAIT_TIME, TimeUnit.SECONDS);
            }else {
                throw new RpcException("establish channel time out");
            }
        } catch (Exception e) {
            throw new RpcException(e.getMessage());
        } finally {
            requestMap.remove(request.getRequestId());
        }
        return response;
    }
}

RpcFuture

package cn.sp.rpc.client.net;

import java.util.concurrent.*;

/**
 * @author 2YSP
 * @date 2020/8/19 22:31
 */
public class RpcFuture<T> implements Future<T> {

    private T response;
    /**
     * 因为请求和响应是一一对应的,所以这里是1
     */
    private CountDownLatch countDownLatch = new CountDownLatch(1);
    /**
     * Future的请求时间,用于计算Future是否超时
     */
    private long beginTime = System.currentTimeMillis();

    @Override
    public boolean cancel(boolean mayInterruptIfRunning) {
        return false;
    }

    @Override
    public boolean isCancelled() {
        return false;
    }

    @Override
    public boolean isDone() {
        if (response != null) {
            return true;
        }
        return false;
    }

    /**
     * 获取响应,直到有结果才返回
     * @return
     * @throws InterruptedException
     * @throws ExecutionException
     */
    @Override
    public T get() throws InterruptedException, ExecutionException {
        countDownLatch.await();
        return response;
    }

    @Override
    public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
        if (countDownLatch.await(timeout,unit)){
            return response;
        }
        return null;
    }

    public void setResponse(T response) {
        this.response = response;
        countDownLatch.countDown();
    }

    public long getBeginTime() {
        return beginTime;
    }
}

此处逻辑,第一次执行 SendHandlerV2#sendRequest() 时channel需要等待通道建立好之后才能发送请求,所以用CountDownLatch来控制,等待通道建立。自定义Future+requestMap缓存来实现netty的请求和阻塞等待响应,RpcRequest对象在创建时会生成一个请求的唯一标识requestId,发送请求前先将RpcFuture缓存到requestMap中,key为requestId,读取到服务端的响应信息后(channelRead方法),将响应结果放入对应的RpcFuture中。SendHandlerV2#channelInactive() 方法中,如果连接的服务端异常断开连接了,则及时清理缓存中对应的serverNode。

四、压力测试

测试环境:

  • (英特尔)Intel(R) Core(TM) i5-6300HQ CPU @ 2.30GHz 4核

  • windows10家庭版(64位)

  • 16G内存

1.本地启动zookeeper 2.本地启动一个消费者,两个服务端,轮询算法 3.使用ab进行压力测试,4个线程发送10000个请求

ab -c 4 -n 10000 http://localhost:8080/test/user?id=1

测试结果 :

测试结果

从图片可以看出,10000个请求只用了11s,比之前的130+秒耗时减少了10倍以上。

五、下载源码

首先点击右下方在看,再长按下方二维码关注哦,并后台回复

【p017】即可下载。

二维码


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

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

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

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

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

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
Mythos:首个实现自主漏洞挖掘闭环的通用AI安全模型 漏洞挖掘正从依赖人工经验与工具链的静态分析,转向基于系统本质建模的因果推理过程。现代AI安全能力的核心已不再是参数规模,而是模型在推理时对内存管理、进程调度、网络协议等底层计算原语的理解深度与动态计算资源调度能力。Mythos通过多阶段红队博弈训练和测试时计算(Test-time Compute)优化,首次在真实攻击链(目标识别→POC生成→权限提升)中实现端到端无人工干预闭环,其发现FreeBSD RCE、FFmpeg越界读等漏洞的过程,体现的是跨抽象层推理而非模式匹配。该能力已推动企业安全范式从合规驱动 阅读详情

相关推荐

这次我设计了一款TPS百万级别的分布式、高性能、可扩展的RPC框架

次准备下手的是RPC框架项目。为什么要对RPC框架项目下手呢,因为在如今分布式、微服务乃至云原生不断发展的过程中,RPC作为底层必不可少通信组件,被广泛应用在分布式、微服务和云原生项目中。

weixin_70730532的博客 596

手撸RPC【gw-rpc】

在之前的博文中,我们学习了Netty的基础知识,了解了其原理和组件。在本篇博文中,我们将结合实际案例,分享一个基于Netty的简化版RPC(远程过程调用)实现。通过这个案例,我们不仅可以学习Netty的使用和原理,还能够对RPC的设计有一个整体的学习。

HGW的博客 1445

Github-RPCServerClient:RPC服务器客户端

Github-RPCServerClient RPCServerClient • 这个项目有一个或多个Servlets 或JSPs 来处理请求; 它还有一个内存会话数据表,其中包含一些用于垃圾收集过期条目的机制。 它有一个基于八卦的组成员服务,因此每个服务器都知道所有其他服务器的地址。 SvrID 标识最初创建会话 ID 的服务器,而 sess_num 是该服务器中的全局变量的值,每次创建新会话 ID 时都会增加该值。 对于多个服务器,sess_num 值将不是全局唯一的; 但包含服务器唯一 SvrID 的 SessID 将根据需要在全球范围内唯一。会话版本号是会话中每个请求递增的数字; 它唯一标识给定会话数据的版本。 Cookie 随现有会话中的每个客户端请求一起发送。 它包含 SessID 和会话版本号。 分布式会话状态数据库由多个服务器实例组成,这些实例使用简单的远程过程调用 (R

十三.Netty入门到超神系列-手撸简单版RPC框架(仿Dubbo)

前言 学过dubbo的应该知道dubbo底层基于Netty实现,为了加强对Netty的理解,这篇文章我们来仿照dubbo手撸一个简易版本的RPC框架 结构理解 先来看一张图 原理还是比较简单 : 代理 + 线程池 + Netty 下面做一些解释: 首先需要定义一个统一的API接口,例:UserApi , 服务端(provider)需要实现这个接口,提供相应的方法UserApiImpl#save,客户端通过远程来调用该接口。 然后需要约定一个协议,服务器如何才能识别到客户端要调用哪个接口?:我这里用 “接

墨家巨子@俏如来 1088

SLF4J StaticLoggerBinder报错全解析:从依赖冲突到类加载的根治方案

在Java应用开发中,日志系统是监控、调试和问题排查的核心基础设施。SLF4J作为日志门面(Facade),通过统一的API接口实现了业务代码与具体日志实现(如Logback、Log4j2)的解耦,其工作原理依赖于运行时在类路径上查找并绑定具体的日志实现。当出现“Failed to load class org.slf4j.impl.StaticLoggerBinder”错误时,意味着SLF4J无法完成这一关键绑定,导致日志功能静默失效,这在依赖管理复杂的微服务架构和持续集成环境中尤为常见。该问题的技术价值

weixin_30892889的博客 459

Vmware虚拟机一打开就蓝屏解决方法

Vmware虚拟机一打开就蓝屏解决方法 问题: 一打开Vmware虚拟机就蓝屏,如下图所示: 解决方法1: 启用和关闭windows功能(对话框)——>虚拟机平台(选项打对勾,默认没勾选)——>确定后重启——>再进应该就好了。 解决方法2: ①.查看电脑中的Hyper-V服务是否关闭 1.打开控制面板-程序-程序和功能 2.双击启用或关闭Windows功能 3.把Hyper-V前面的勾去掉 如果后期发下没有反应,或者电脑本身Hyper-V的服务没有打开,可以先打开在关闭,试

m0_55901666的博客 26万+

徒手撸了一个API网关,理解更透彻了,代码已上传github,自取~

千里之行始于足下,开始以为写一个网关会很难,但当你实际开始行动时就会发现其实没那么难,所以迈出第一步很重要。过程中也遇到了很多问题,还在github上给soul和nacos这两个开源项目提了两个issue,后来发现是自己的问题,尴尬😅。

程序员高级码农的博客 1158

基本模型 PINNs : Physics Informed Neural Networks

系列最开始当然要提到很经典的文章 —— Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations 。 这篇文章是布朗大学的助理教授Maziar Rais...

waitingwinter的博客 3万+

徒手撸了一个 API 网关,理解更透彻了,代码已上传github,自取~

点击上方“逆锋起笔”,公众号回复编程资源领取大佬们推荐的学习资料 来源 |cnblogs.com/2YSP/p/14223892.html一、背景最近在github上看了soul网关的...

code小生 633

Openclaw错误分析与解决方案之:Agent couldn’t generate a response.

Openclaw错误分析与解决方案之:Agent couldn't generate a response. Note: some tool actions may have already been executed — please verify before retrying.

多媒体编程、网络编程、系统编程、网络安全编程、驱动编程 1319

【国产MCU】-认识CH32V307及开发环境搭建

CH32V307是[沁恒](https://www.wch.cn/)推出的一款基于32位RISC-V设计的互联型微控制器,配备了硬件堆栈区、快速中断入口,在标准RISC-V基础上大大提高了中断响应速度。加入单精度浮点指令集,扩充堆栈区,具有更高的运算性能。扩展串口UART数量到8组,电机定时器到4组。提供USB2.0高速接口(480Mbps)并内置了PHY收发器,以太网MAC升级到千兆并集成了10M-PHY模块。

视觉与物联智能 2347

error c4996: getversion: 被声明为已否决_徒手撸了一个API网关,理解更透彻了,代码已上传github,自取~...

点击上方蓝色字体,选择“设为星标”回复”666“获取面试宝典一、背景最近在github上看了soul网关的设计,突然就来了兴趣准备自己从零开始写一个高性能的网关。经过两周时间的开发,我的网关ship-gate核心功能基本都已完成,最大的缺陷就是前端功底太差没有管理后台?。二、设计2.1 技术选型网关是所有请求的入口,所以要求有很高的吞吐量,为了实现这点可以使用请求异步化来解决。目前一般有...

weixin_39747511的博客 963

2023年美高赛HiMCM:A题蒲公英 思路

蒲公英,通常称为蒲公英,是一种原产于欧亚大陆的植物,现在在世界各地都可以找到[1]。这种植物很容易通过其亮黄色的花朵(图1)和独特的“马勃”种子头(图2)来识别。该头部的每颗种子都附着在一个类似降落伞的结构上,称为“冠毛”,有利于风的传播[2]。如果处于“马勃”阶段的单个蒲公英毗邻一块开阔的一公顷土地,请创建一个数学模型来预测蒲公英在 1、2、3、6 和 12个月内的传播情况。确保您的模型考虑了各种气候条件(例如温带、干旱和热带气候)对蒲公英生长的影响。2. 蒲 公英、人类和其他植物之间的关系很复杂。

斌擎科技 7404

徒手撸一个简单的RPC框架(附源码)

点击上方“后端技术精选”,选择“置顶公众号”技术文章第一时间送达!作者:不学无数的程序员juejin.im/post/5c4481a4f265da613438aec3之前...

Java笔记虾 610

一周一个Unity小游戏2D反弹球游戏 - 球反弹的方向

本文将实现当球在球板上反弹时,会根据球板移动的方向来给球施加反弹的力,例如当球板往左移动时反弹球,则球应向左上方反弹,若球板往右移动时反弹球,则球应向右上方反弹。

Giver的博客 753

手把手带你实现DAF-Net:零代码基础入门红外与可见光图像融合(从理论到实战)

本文介绍了红外与可见光图像融合技术及DAF-Net网络的应用。红外图像能捕捉热源但缺乏细节,可见光图像纹理丰富但在低光环境下表现不佳。DAF-Net采用双分支特征提取和动态注意力融合架构,能智能分配特征权重实现优势互补。文章详细讲解了环境配置、数据集准备(如TNO数据集)和预处理方法,并提供了DAF-Net的核心代码实现,包括特征提取、注意力融合和图像重建模块。通过该技术可在安防、自动驾驶等领域获得更优质的融合图像,提升视觉感知能力。

m0_71589036的博客 235

秋招看到github上不错的项目,但不知道该咋学?

作者:阿秀阿秀的学习笔记:https://interviewguide.cn你好,我是阿秀。昨天的文章中提到了校招过程中简历上相对而言比较重要的两个地方:实习经历和项目经历,昨天已经聊过实习相关话题:超级纠结!又想去实习又想全力准备秋招...今天来聊一聊项目经历。打算找开发技术岗的本科学弟学妹或者研究生师弟师妹的简历上可以没有实习经历,但绝不能没有项目经历,因为项目经历是...

博客 2677

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

最简RPC框架实现

【博文总目录>>>】|【项目源码>>>】 RPC概述 RPC(Remote Proceduce Call 远程过程调用) 一般用来实现部署在不同机器上的系统之间的方法调用,使程序能够像访问本地系统资源一样,通过网络传输过去访问远端系统资源。 RPC 调用过程 1、Client 客户端调用方法实现,负责发起RPC调用。 2、ClientStub/SereverStub 可以看作

https://github.com/Wang-Jun-Chao 1999

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

上一篇: 天猫二面:内存耗尽后 Redis 会发生什么?
下一篇: 字符串拼接还在用StringBuilder?快试试Java8中的StringJoiner吧,真香!
公众号-芋道源码
博客等级 码龄10年 1637粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值