【微服务】SpringCloud微服务剔除下线源码解析

news2025/8/1 18:31:47

💖 Spring家族及微服务系列文章

✨【微服务】SpringCloud微服务续约源码解析

✨【微服务】SpringCloud微服务注册源码解析

✨【微服务】Nacos2.x服务发现？RPC调用？重试机制？

✨【微服务】Nacos通知客户端服务变更以及重试机制

✨【微服务】Nacos服务发现源码分析

✨【微服务】SpringBoot监听器机制以及在Nacos中的应用

✨【微服务】Nacos服务端完成微服务注册以及健康检查流程

✨【微服务】Nacos客户端微服务注册原理流程

✨【微服务】SpringCloud中使用Ribbon实现负载均衡的原理

✨【微服务】SpringBoot启动流程注册FeignClient

✨【微服务】SpringBoot启动流程初始化OpenFeign的入口

✨Spring Bean的生命周期

✨Spring事务原理

✨SpringBoot自动装配原理机制及过程

✨SpringBoot获取处理器流程

✨SpringBoot中处理器映射关系注册流程

✨Spring5.x中Bean初始化流程

✨Spring中Bean定义的注册流程

✨Spring的处理器映射器与适配器的架构设计

✨SpringMVC执行流程图解及源码

目录

💖 Spring家族及微服务系列文章

一、前言

二、微服务剔除下线源码解析

1、EurekaBootStrap#contextInitialized()

1.1、初始化注册中心上下文

1.2、openForTraffic()逻辑

1.3、postInit()执行任务

1.4、剔除任务

2、服务剔除下线

2.1、AbstractInstanceRegistry#evict()逻辑

2.1、判断是否过期

2.2、从本地列表异常下线处理

一、前言

    上一篇SpringCloud微服务续约源码解析已经分析了心跳机制是什么、底层实现、客户端发送心跳的主要代码、注册中心处理心跳的过程，这节跟它是紧密关联的。联系的枢纽就是lastUpdateTimestamp最后更新时间戳，它是Lease租约类的一个用volatile关键字修饰的对其他线程透明可见的字段。那么Eureka是如何使用该字段判断服务是否过期的？然后进行服务的剔除下线？需要借助什么机制？该机制是什么时候能触发的？带着这些问题，我们下面来探究一番：

二、微服务剔除下线源码解析

EurekaBootStrap是Eureka项目里面的，用于启动Eureka服务器的类：
Eureka 服务器使用类路径中eureka.server.props指定的EurekaServerConfig进行配置。Eureka客户端组件也是通过使用eureka.client.props指定的配置 EurekaInstanceConfig初始化的。如果服务器在AWS云中运行，则eureka服务器将其绑定到指定的弹性ip。

1、EurekaBootStrap#contextInitialized()

    @Override
    public void contextInitialized(ServletContextEvent event) {
        try {
            initEurekaEnvironment();
            // 初始化注册中心上下文
            initEurekaServerContext();

            ServletContext sc = event.getServletContext();
            sc.setAttribute(EurekaServerContext.class.getName(), serverContext);
        } catch (Throwable e) {
            logger.error("Cannot bootstrap eureka server :", e);
            throw new RuntimeException("Cannot bootstrap eureka server :", e);
        }
    }

它这里也使用了事件机制，但是不是基于Spring的，感兴趣的可以去了解下。初始化注册中心上下文，即下面的处理逻辑：

1.1、初始化注册中心上下文

    protected void initEurekaServerContext() throws Exception {
        EurekaServerConfig eurekaServerConfig = new DefaultEurekaServerConfig();

        // For backward compatibility
        JsonXStream.getInstance().registerConverter(new V1AwareInstanceInfoConverter(), XStream.PRIORITY_VERY_HIGH);
        XmlXStream.getInstance().registerConverter(new V1AwareInstanceInfoConverter(), XStream.PRIORITY_VERY_HIGH);

        logger.info("Initializing the eureka client...");
        logger.info(eurekaServerConfig.getJsonCodecName());
        ServerCodecs serverCodecs = new DefaultServerCodecs(eurekaServerConfig);

        ApplicationInfoManager applicationInfoManager = null;

        if (eurekaClient == null) {
            EurekaInstanceConfig instanceConfig = isCloud(ConfigurationManager.getDeploymentContext())
                    ? new CloudInstanceConfig()
                    : new MyDataCenterInstanceConfig();
            
            applicationInfoManager = new ApplicationInfoManager(
                    instanceConfig, new EurekaConfigBasedInstanceInfoProvider(instanceConfig).get());
            
            EurekaClientConfig eurekaClientConfig = new DefaultEurekaClientConfig();
            eurekaClient = new DiscoveryClient(applicationInfoManager, eurekaClientConfig);
        } else {
            applicationInfoManager = eurekaClient.getApplicationInfoManager();
        }

        PeerAwareInstanceRegistry registry;
        if (isAws(applicationInfoManager.getInfo())) {
            registry = new AwsInstanceRegistry(
                    eurekaServerConfig,
                    eurekaClient.getEurekaClientConfig(),
                    serverCodecs,
                    eurekaClient
            );
            awsBinder = new AwsBinderDelegate(eurekaServerConfig, eurekaClient.getEurekaClientConfig(), registry, applicationInfoManager);
            awsBinder.start();
        } else {
            registry = new PeerAwareInstanceRegistryImpl(
                    eurekaServerConfig,
                    eurekaClient.getEurekaClientConfig(),
                    serverCodecs,
                    eurekaClient
            );
        }

        PeerEurekaNodes peerEurekaNodes = getPeerEurekaNodes(
                registry,
                eurekaServerConfig,
                eurekaClient.getEurekaClientConfig(),
                serverCodecs,
                applicationInfoManager
        );

        serverContext = new DefaultEurekaServerContext(
                eurekaServerConfig,
                serverCodecs,
                registry,
                peerEurekaNodes,
                applicationInfoManager
        );

        EurekaServerContextHolder.initialize(serverContext);

        serverContext.initialize();
        logger.info("Initialized server context");

        // Copy registry from neighboring eureka node
        int registryCount = registry.syncUp();
        registry.openForTraffic(applicationInfoManager, registryCount);

        // Register all monitoring statistics.
        EurekaMonitors.registerAllStats();
    }

做一些初始化工作，重点关注registry.openForTraffic(applicationInfoManager, registryCount);的调用，进入下面处理逻辑：

1.2、openForTraffic()逻辑


    @Override
    public void openForTraffic(ApplicationInfoManager applicationInfoManager, int count) {
        // Renewals happen every 30 seconds and for a minute it should be a factor of 2.
        // 更新每30秒发生一次，一分钟应该是2倍。
        this.expectedNumberOfClientsSendingRenews = count;
        updateRenewsPerMinThreshold();
        logger.info("Got {} instances from neighboring DS node", count);
        logger.info("Renew threshold is: {}", numberOfRenewsPerMinThreshold);
        this.startupTime = System.currentTimeMillis();
        if (count > 0) {
            this.peerInstancesTransferEmptyOnStartup = false;
        }
        DataCenterInfo.Name selfName = applicationInfoManager.getInfo().getDataCenterInfo().getName();
        boolean isAws = Name.Amazon == selfName;
        if (isAws && serverConfig.shouldPrimeAwsReplicaConnections()) {
            logger.info("Priming AWS connections for all replicas..");
            primeAwsReplicas(applicationInfoManager);
        }
        // 更改服务实例状态为UP
        logger.info("Changing status to UP");
        applicationInfoManager.setInstanceStatus(InstanceStatus.UP);
        // 调用父类初始化
        super.postInit();
    }

更改服务实例状态为UP，调用父类初始化。

1.3、postInit()执行任务

    protected void postInit() {
        renewsLastMin.start();
        if (evictionTaskRef.get() != null) {
            evictionTaskRef.get().cancel();
        }
        evictionTaskRef.set(new EvictionTask());
        evictionTimer.schedule(evictionTaskRef.get(),
                serverConfig.getEvictionIntervalTimerInMs(),
                serverConfig.getEvictionIntervalTimerInMs());
    }

终于来到剔除任务了，前面说了什么，就是一些初始化的工作。它这里的执行器是Timer，跟Nacos不一样，区别的话感兴趣的就自行去搞个明白。我们进入下面的分析：

1.4、剔除任务

 EvictionTask是TimerTask类型任务。

class EvictionTask extends TimerTask {

        private final AtomicLong lastExecutionNanosRef = new AtomicLong(0l);

        @Override
        public void run() {
            try {
                long compensationTimeMs = getCompensationTimeMs();
                logger.info("Running the evict task with compensationTime {}ms", compensationTimeMs);
                evict(compensationTimeMs);
            } catch (Throwable e) {
                logger.error("Could not run the evict task", e);
            }
        }

        /**
         * 计算一个补偿时间，该时间定义为自上一次迭代以来该任务的实际执行时间，与配置的执行时间量相比较。
         * 这对于时间变化(例如由于时钟偏差或 gc)导致实际的驱逐任务根据配置的周期在所需时间之后执行的情况
         * 非常有用。
         */
        long getCompensationTimeMs() {
            long currNanos = getCurrentTimeNano();
            long lastNanos = lastExecutionNanosRef.getAndSet(currNanos);
            if (lastNanos == 0l) {
                return 0l;
            }

            long elapsedMs = TimeUnit.NANOSECONDS.toMillis(currNanos - lastNanos);
            long compensationTime = elapsedMs - serverConfig.getEvictionIntervalTimerInMs();
            return compensationTime <= 0l ? 0l : compensationTime;
        }

        long getCurrentTimeNano() {  // for testing
            return System.nanoTime();
        }

    }

主要逻辑：

  1. 计算一个补偿时间，该时间定义为自上一次迭代以来该任务的实际执行时间，与配置的执行时间量相比较。这对于时间变化(例如由于时钟偏差或 gc)导致实际的驱逐任务根据配置的周期在所需时间之后执行的情况 非常有用。
  2. 调用evict(compensationTimeMs)剔除处理，下面分析：

2、服务剔除下线

2.1、AbstractInstanceRegistry#evict()逻辑

public void evict(long additionalLeaseMs) {
        logger.debug("Running the evict task");

        if (!isLeaseExpirationEnabled()) {
            // DS: 租约到期目前已禁用。
            logger.debug("DS: lease expiration is currently disabled.");
            return;
        }

        
        // 我们首先收集所有过期的物品，以随机的顺序驱逐它们。对于大型驱逐集，如果我们不这样做，
        // 我们可能会在自我保护启动之前删除整个应用程序。通过随机化，影响应该均匀地分布在所有应用程序中。
        List<Lease<InstanceInfo>> expiredLeases = new ArrayList<>();
        for (Entry<String, Map<String, Lease<InstanceInfo>>> groupEntry : registry.entrySet()) {
            Map<String, Lease<InstanceInfo>> leaseMap = groupEntry.getValue();
            if (leaseMap != null) {
                for (Entry<String, Lease<InstanceInfo>> leaseEntry : leaseMap.entrySet()) {
                    Lease<InstanceInfo> lease = leaseEntry.getValue();
                    // 判断租约是否过期
                    if (lease.isExpired(additionalLeaseMs) && lease.getHolder() != null) {
                        // 添加到过期续租集合
                        expiredLeases.add(lease);
                    }
                }
            }
        }

        // To compensate for GC pauses or drifting local time, we need to use current registry size as a base for
        // triggering self-preservation. Without that we would wipe out full registry.
        // 为了补偿 GC 暂停或漂移的本地时间，我们需要使用当前的注册表大小作为触发自我保存的基础。
        // 没有这个，我们就会清除整个注册表。
        // 获取注册表租约总数
        int registrySize = (int) getLocalRegistrySize();
        // 计算注册表租约的阈值 （总数乘以 续租百分比 默认85%），得出要续租的数量
        int registrySizeThreshold = (int) (registrySize * serverConfig.getRenewalPercentThreshold());
        // 理论要剔除的数量 = 总数-要续租的数量
        int evictionLimit = registrySize - registrySizeThreshold;
        // 实际剔除的数量 =  min(实际租期到期服务实例个数，理论剔除数量)
        int toEvict = Math.min(expiredLeases.size(), evictionLimit);
        // 将要剔除数量大于0，把它们下线处理，从本地注册表移除掉以保证高可用
        if (toEvict > 0) {
            logger.info("Evicting {} items (expired={}, evictionLimit={})", toEvict, expiredLeases.size(), evictionLimit);

            Random random = new Random(System.currentTimeMillis());
            for (int i = 0; i < toEvict; i++) {
                // 选择一个随机的项目(Knuth 洗牌算法)
                int next = i + random.nextInt(expiredLeases.size() - i);
                Collections.swap(expiredLeases, i, next);
                Lease<InstanceInfo> lease = expiredLeases.get(i);

                String appName = lease.getHolder().getAppName();
                String id = lease.getHolder().getId();
                EXPIRED.increment();
                // 注册表: {}/{}的租约已过期
                logger.warn("DS: Registry: expired lease for {}/{}", appName, id);
                // 服务下线
                internalCancel(appName, id, false);
            }
        }
    }

主要逻辑：

  1. 判断租约到期是否禁用，如果禁用return。默认启用
  2. 首先收集所有过期的租约，以随机的顺序剔除它们。对于大型剔除集，如果不这样做，可能会在自我保护启动之前删除整个应用程序。通过随机化，影响应该均匀地分布在所有应用程序中。判断租约是否过期，如果过期添加到过期租约集合，继续遍历到。
  3. 为了补偿 GC 暂停或漂移的本地时间，需要使用当前的注册表大小作为触发自我保存的基础。没有这个，就会清除整个注册表。1）获取注册表租约总数；2）计算注册表租约的阈值 （总数乘以 续租百分比 默认85%），得出要续租的数量；3）理论要剔除的数量 = 总数-要续租的数量；4）实际剔除的数量 =  min(实际租期到期服务实例个数，理论剔除数量)；
  4. 将要剔除数量大于0，把它们下线处理，从本地注册表移除掉以保证高可用：选择一个随机的项目(Knuth 洗牌算法)，调用internalCancel(appName, id, false)下线处理。

2.1、判断是否过期

    public boolean isExpired(long additionalLeaseMs) {
        return (evictionTimestamp > 0 || System.currentTimeMillis() > (lastUpdateTimestamp + duration + additionalLeaseMs));
    }

如果是cancel()处理前面的值就大于0，一般是判断后面部分逻辑：如果当前系统时间戳小于后面的时间戳之和，则没有过期；否则大于就是过期了。

2.2、从本地列表异常下线处理

cancel(String，String，boolean)方法被PeerAwareInstanceRegistry重写了，因此每个取消请求都被复制到对等点。然而，对于在远程对等点中被视为有效取消的过期，这是不需要的，因此自我保存模式不会启用。

    protected boolean internalCancel(String appName, String id, boolean isReplication) {
        // 加锁
        read.lock();
        try {
            CANCEL.increment(isReplication);
            // 根据appName从本地注册表获取租约服务实例
            Map<String, Lease<InstanceInfo>> gMap = registry.get(appName);
            Lease<InstanceInfo> leaseToCancel = null;
            if (gMap != null) {
                // 根据唯一ID从本地移除服务实例，下线
                leaseToCancel = gMap.remove(id);
            }
            recentCanceledQueue.add(new Pair<Long, String>(System.currentTimeMillis(), appName + "(" + id + ")"));
            InstanceStatus instanceStatus = overriddenInstanceStatusMap.remove(id);
            if (instanceStatus != null) {
                logger.debug("Removed instance id {} from the overridden map which has value {}", id, instanceStatus.name());
            }
            if (leaseToCancel == null) {
                // 下线失败，因为租约信息中不存在该服务实例
                CANCEL_NOT_FOUND.increment(isReplication);
                logger.warn("DS: Registry: cancel failed because Lease is not registered for: {}/{}", appName, id);
                return false;
            } else {
                // 通过更新剔除时间取消租约。
                leaseToCancel.cancel();
                // 从租约获取服务实例
                InstanceInfo instanceInfo = leaseToCancel.getHolder();
                String vip = null;
                String svip = null;
                if (instanceInfo != null) {
                    instanceInfo.setActionType(ActionType.DELETED);
                    recentlyChangedQueue.add(new RecentlyChangedItem(leaseToCancel));
                    instanceInfo.setLastUpdatedTimestamp();
                    vip = instanceInfo.getVIPAddress();
                    svip = instanceInfo.getSecureVipAddress();
                }
                // 使特定应用程序的缓存失效
                invalidateCache(appName, vip, svip);
                logger.info("Cancelled instance {}/{} (replication={})", appName, id, isReplication);
            }
        } finally {
            // 释放锁
            read.unlock();
        }

        synchronized (lock) {
            if (this.expectedNumberOfClientsSendingRenews > 0) {
                // Since the client wants to cancel it, reduce the number of clients to send renews.
                this.expectedNumberOfClientsSendingRenews = this.expectedNumberOfClientsSendingRenews - 1;
                updateRenewsPerMinThreshold();
            }
        }

        return true;
    }

主要逻辑：

  1. 获取锁后，根据appName从本地注册表获取租约服务实例
  2. 根据唯一ID从本地移除服务实例，下线
  3. 如果需下线租约信息为空，则下线失败，因为租约信息中不存在该服务实例，return假；否则可能通过更新剔除时间取消租约，从租约获取服务实例以便使特定应用程序的缓存失效
  4. 释放锁

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/16144.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

SpringBoot SpringBoot 开发实用篇 4 数据层解决方案 4.4 Redis 下载安装与基本使用

SpringBoot SpringBoot 开发实用篇 4 数据层解决方案 4.4 Redis 下载安装与基本使用

SpringBoot 【黑马程序员SpringBoot2全套视频教程&#xff0c;springboot零基础到项目实战&#xff08;spring boot2完整版&#xff09;】 SpringBoot 开发实用篇 文章目录SpringBootSpringBoot 开发实用篇4 数据层解决方案4.4 Redis 下载安装与基本使用4.4.1 问题引入4.4.2 …
阅读更多...
Linux Mint（Ubuntu）上 安装 效率神器 utools

Linux Mint（Ubuntu）上 安装 效率神器 utools

Linux Mint&#xff08;Ubuntu&#xff09;上 安装 效率神器 utools 我的 Windows 系统的笔记本只有 256G 固态&#xff0c;磁盘已经快用满了&#xff0c;最近想装个 Linux 玩玩&#xff0c;1 选择了 Linux Mint&#xff0c;然后就在闲置的移动硬盘上安装了 Linux Mint 21 cin…
阅读更多...
Centos 安装Java库的多种方式

Centos 安装Java库的多种方式

安装jdk(介绍三种方法) 查看java版本&#xff1a;java -version 方法一&#xff1a;利用yum源来安装jdk&#xff08;此方法不需要配置环境变量&#xff09; 查看yum库中的java安装包 &#xff1a;yum -y list java* 安装需要的jdk版本的所有java程序&#xff1a;yum -y instal…
阅读更多...
纯正体验，极致商务 | 丽亭酒店聚焦未来赛道，实现共赢发展

纯正体验，极致商务 | 丽亭酒店聚焦未来赛道，实现共赢发展

10月28日&#xff0c;锦江酒店(中国区)“齐鲁集锦 共话未来”投资人交流会在济南盛大召开&#xff0c;面向华东地区投资人&#xff0c;行业专家、商旅客、品牌代表齐聚一堂&#xff0c;共同聚焦酒店市场投资新价值&#xff0c;商讨新时代酒店行业新机遇&#xff0c;多维探索酒店…
阅读更多...
蓝牙数据包协议解析

蓝牙数据包协议解析

1.前言 由于工作需要&#xff0c;初次接触蓝牙。从最基础的知识开始了解。 引用wiki中的介绍&#xff1a; 蓝牙&#xff08;英语&#xff1a;Bluetooth&#xff09;&#xff0c;一种无线通讯技术标准&#xff0c;用来让固定与移动设备&#xff0c;在短距离间交换资料&#xff…
阅读更多...
第一章：Spring流程执行步骤

第一章：Spring流程执行步骤

Spring执行流程图 注意观察&#xff1a;每一个执行步骤的结果都会返回到DispatcherServlet &#xff0c;然后再出发调用&#xff0c; 所以是请求接口的入口也是出口。 简单了解几个大类的走的流程和具体功能 DispatcherServlet 类 中文调度应用程序&#xff0c;而Servlet就…
阅读更多...
libusb系列-007-Qt下使用libusb1.0.26源码

libusb系列-007-Qt下使用libusb1.0.26源码

libusb系列-007-Qt下使用libusb1.0.26源码 文章目录libusb系列-007-Qt下使用libusb1.0.26源码摘要安装编译环境确认需要的文件开始编译错误1&#xff1a;找不到文件错误2&#xff1a;expected错误3&#xff1a;SCM_CREDENTALS错误4&#xff1a;类型冲突错误5 assert断言错误错误…
阅读更多...
低代码平台和无代码平台有什么区别

低代码平台和无代码平台有什么区别

低代码&#xff08;LowCode&#xff09;/无代码(NoCode)”是技术界近几年的热门词汇之一&#xff0c;随着企业数字化发展的深入&#xff0c;越来越多的场景化需求要求企业具备更加灵活敏捷的应用开发能力&#xff0c;传统应用开发模式周期长、技术人员能力要求高&#xff0c;无…
阅读更多...
OWASP API SECURITY TOP 10

OWASP API SECURITY TOP 10

目录 1. API 安全风险 2. 细说TOP10 1. Broken Object Level Authorization 2. Broken User Authentication 3 Excessive Data Exposure 4 Lack of Resources & Rate Limiting 5 Broken Function Level Authorization 6 Mass Assignment 7 security misconfigura…
阅读更多...
redis哨兵系列1

redis哨兵系列1

需要配合源码一起康~ 9.1 哨兵基本概念 官网手册yyds&#xff1a;https://redis.io/docs/manual/sentinel/ redis主从模式&#xff0c;如果主挂了&#xff0c;需要人工将从节点提升为主节点&#xff0c;通知应用修改主节点的地址。不是很友好&#xff0c;so Redis 2.8之后开…
阅读更多...
同花顺_代码解析_技术指标_EJK

同花顺_代码解析_技术指标_EJK

本文通过对同花顺中现成代码进行解析&#xff0c;用以了解同花顺相关策略设计的思想 目录 EMV ENV EXPMA JF_ZNZX KD KDJ KDJFS EMV 简易波动指标 1.EMV 由下往上穿越0 轴时&#xff0c;视为中期买进参考信号&#xff1b; 2.EMV 由上往下穿越0 轴时&#xff0c;视为中…
阅读更多...
根据以下电路图，补全STM32F103RCT6的IO口初始化程序

根据以下电路图，补全STM32F103RCT6的IO口初始化程序

void KEY_Init(void)//接按键的端口初始化程序 { RCC->APB2ENR|______________; //使能PORTA时钟 JTAG_Set(SWD_ENABLE); GPIOA->CRL&__________________; // PA3设置成下拉输入 GPIOA->CRL|__________________; } void LED_Init(void)//接LED的端…
阅读更多...
【Qt】控件探幽——QLineEdit

【Qt】控件探幽——QLineEdit

注1&#xff1a;本系列文章使用的Qt版本为Qt 6.3.1 注2&#xff1a;本系列文章常规情况下不会直接贴出源码供复制&#xff0c;都以图片形式展示。所有代码&#xff0c;自己动手写一写&#xff0c;记忆更深刻。 本文目录QLineEdit探幽1、设置数据/获取数据2、只读&#xff08;re…
阅读更多...
【15-项目中服务的远程调用之OpenFeign订单模块与商品模块集成使用OpenFeign的案例】

【15-项目中服务的远程调用之OpenFeign订单模块与商品模块集成使用OpenFeign的案例】

一.知识回顾 【0.三高商城系统的专题专栏都帮你整理好了&#xff0c;请点击这里&#xff01;】 【1-系统架构演进过程】 【2-微服务系统架构需求】 【3-高性能、高并发、高可用的三高商城系统项目介绍】 【4-Linux云服务器上安装Docker】 【5-Docker安装部署MySQL和Redis服务】…
阅读更多...
【面试题】圣杯布局和双飞翼布局

【面试题】圣杯布局和双飞翼布局

圣杯布局和双飞翼布局的特点&#xff1a; 三栏布局&#xff0c;中间一栏最先加载和渲染&#xff08;内容最重要&#xff09;两侧内容固定&#xff0c;中间内容随着宽度自适应一般用于PC页面 圣杯布局和双飞翼布局的实现方式&#xff1a; 使用float布局两侧使用margin负值&am…
阅读更多...
git 、gitLub 提交后查看显示全部删除又全部新增

git 、gitLub 提交后查看显示全部删除又全部新增

问题&#xff1a; git提交后删除的行数与增加的行数一样&#xff0c;没有修改git也会去全部删除又全部新增 大概是下面你这个样子&#xff1a; 原因&#xff1a; 换行符的原因&#xff0c;win、mac、linux/Unix 换行符是不一样的&#xff0c;提交的文件换行符和git服务器的不…
阅读更多...
【Unity300个技巧】牛顿的学问！如何优雅地使用力？

【Unity300个技巧】牛顿的学问！如何优雅地使用力？

Unity 提供了一个完备且强大物理引擎。但在刚接触的时候&#xff0c;你可能会对它与现实物理规律对应有一些疑惑。 比如&#xff1a; 现实中 1N 的力在 Unity 中怎么表现&#xff1f;Unity 中物体的质量是计算的&#xff1f;Unity 中给物体添加力的方法是 rb.AddForce()&#x…
阅读更多...
ICME 论文Latex模版要求

ICME 论文Latex模版要求

2023年模版获取链接&#xff1a; 链接: https://pan.baidu.com/s/1Hjk4nnybQN6LE23SGfbxKQ 提取码: 27dj --来自百度网盘超级会员v4的分享 论文写作要求&#xff1a; 所有手稿必须是英文的&#xff1b; 论文长度不应超过6页&#xff0c;包括所有文本、图形和参考文献&#…
阅读更多...
Qt 设置CPU亲缘性，把进程和线程绑定到CPU核心上(Linux)

Qt 设置CPU亲缘性，把进程和线程绑定到CPU核心上(Linux)

Qt 设置CPU亲缘性&#xff0c;把进程和线程绑定到CPU核心上(Linux) 文章目录Qt 设置CPU亲缘性&#xff0c;把进程和线程绑定到CPU核心上(Linux)摘要1 什么是CPU亲缘性2 目的3 API 介绍3.1 进程绑定到CPU3.2 线程绑定到CPU4 实际操作4.1 实操代码主进程串口线程USB线程程序运行资…
阅读更多...
iOS开发M1芯片遇到的问题

iOS开发M1芯片遇到的问题

pod失败执行&#xff1a; sudo arch -x86_64 gem install ffi Then arch -x86_64 pod install M1芯片的Mac无法在模拟器上运行项目building for iOS Simulator或could not find module for target.. 真机上可运行&#xff0c;模拟器上不行&#xff0c;并出现以下错误&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023