Dubbo高可用_3

最新推荐文章于 2025-01-17 15:10:42 发布
最新推荐文章于 2025-01-17 15:10:42 发布
阅读量236 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Dubble
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Be_nurturing/article/details/107353287

1、zookeeper宕机与dubbo直连

现象：zookeeper注册中心宕机，还可以消费dubbo暴露的服务。

原因：

健壮性

监控中心宕掉不影响使用，只是丢失部分采样数据

数据库宕掉后，注册中心仍能通过缓存提供服务列表查询，但不能注册新服务

注册中心对等集群，任意一台宕掉后，将自动切换到另一台

注册中心全部宕掉后，服务提供者和服务消费者仍能通过本地缓存通讯

服务提供者无状态，任意一台宕掉后，不影响使用

服务提供者全部宕掉后，服务消费者应用将无法使用，并无限次重连等待服务提供者恢复

高可用：通过设计，减少系统不能提供服务的时间；

案例 ：① 比如zookeeper注册中心宕机了，消费者以上面的红色部分连接到消费者的服务，因为有缓存，

             ② zookeeper宕机了（我是将zookeeper服务停掉了），还可以通过dubbo直连的方式绕过注册中心找到提供者

@Service
public class OrderServiceImpl implements OrderService{
	
//	@Autowired
	@Reference(url="127.0.0.1:20882")
	UserService userService;
	public List<UserAddress> initOrder(String userId){
		List<UserAddress> addressList = userService.getUserAddressList(userId);
		System.out.println(addressList);
		return addressList;
	}
}

只需要在Reference 中加上提供者的地址，就可以找到消费者，实现了高可用

2、集群下dubbo负载均衡配置

在集群负载均衡时，Dubbo 提供了多种均衡策略，缺省为 random 随机调用

<dubbo:consumer loadbalance="random"/>

1.Random:安权重随机

2.RoundRobin: 轮询

3.LeastActive ：最少活跃数（正在处理的数）慢的机器，收到的请求少

负载均衡策略

①Random LoadBalance

随机，按权重设置随机概率。

在一个截面上碰撞的概率高，但调用量越大分布越均匀，而且按概率使用权重后也比较均匀，有利于动态调整提供者权重。

我们看到每台机器后面都设置了权重，总的权重就是350 ，1号机器占了2/7,2号占了4/7,3号占了1/7 ，大量的访问来了，就有对应概率的访问量到达每一台机器，每次请求随机到那一台机器是不确定的

②RoundRobin LoadBalance

轮循，按公约后的权重设置轮循比率。

存在慢的提供者累积请求的问题，比如：第二台机器很慢，但没挂，当请求调到第二台时就卡在那，久而久之，所有请求都卡在调到第二台上。

           1）如果先不考虑后面设置的权重，只按照轮询的方式第一次访问到1号机器，第二次访问2号，第三次访问3号，依次循环

           2）如果考虑后面的权重，第一次访问1号，第二次访问2号，第三次访问2号，第一轮结束了，第二轮继续，第四次访问1号，第五次方位2号，第六次本应该方位3号，可以按照权重比，3号只会被访问一次，第一轮已经访问过一次，所以会这次来到2号，第7次还是访问2号。这就是基于权重的轮询

③LeastActive LoadBalance

最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差。

使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大。

orderService 会统计每台服务器上一次的时间，总会访问活动时间最小的机器访问

④ConsistentHash LoadBalance

一致性 Hash，相同参数的请求总是发到同一提供者。

第一次id=1 访问到1号机器，id=2访问到2号，id=3访问到3号机器，因为参数一直没有变化过，无论多少次访问每次访问都会落到同一台机器上。

测试负载均衡机制实验

boot-user-service-provider 项目中需要修改2出代码

@Component
@Service
public class UserServiceImpl implements UserService {
	
	public List<UserAddress> getUserAddressList(String userId) {
       //只增加一行打印，用于控制台便于区分 分别 1 ，2 ，3
		System.out.println("UserService.....3...."); 
		UserAddress address1 = new UserAddress(1,"东长安街89号","1","王老师","13278977","1");
		UserAddress address2 = new UserAddress(2,"西长安街90号","1","李老师","13278988","1");
		return Arrays.asList(address1,address2);
	}

}

 MyDbubboConfig只修改protocolConfig() 方法中的端口号，分别是20880，20881,20882，分别对应上面的UserServiceImpl  打印的1,2,3 修改一次，启动一次


@Configuration
public class MyDubboConfig {
	
	/**
	 * <dubbo:application name="boot-user-service-provider">
	 * </dubbo:application>	
	 * 对应下面的代码
	 * @return
	 */
	@Bean
	public ApplicationConfig applicationConfig(){
		ApplicationConfig applicationConfig = new ApplicationConfig();
		applicationConfig.setName("boot-user-service-provider");
		return applicationConfig;	
	}
	
	/**
	 * <dubbo:registry protocol="zookeeper" address="10.5.96.48:2181">
	 * </dubbo:registry>
	 * @return
	 */
	@Bean
	public RegistryConfig registryConfig(){
		RegistryConfig registryConfig = new RegistryConfig();
		registryConfig.setProtocol("zookeeper");
		registryConfig.setAddress("10.5.96.48:2181");
		return registryConfig;
	}
	
	/**
	 * <!-- 3 指定通信规则  通信协议，通信端口-->
	<dubbo:protocol name="dubbo" port="20880"></dubbo:protocol>
	 * @return
	 */
	@Bean
	public ProtocolConfig protocolConfig(){
		ProtocolConfig protocolConfig = new ProtocolConfig();
		protocolConfig.setName("dubbo");
		protocolConfig.setPort(20882);
		return protocolConfig;
	}
	
	/**
	 * <dubbo:service interface="com.atguigu.gmail.service.UserService" 
	ref="userServiceImpl01" version="1.0.0">
	<dubbo:method name="getUserAddressList" timeout="3000"></dubbo:method>
	</dubbo:service>
	 */
	public ServiceConfig<UserService> userServiceConfig(UserService userService){
		ServiceConfig<UserService> serviceConfig = new ServiceConfig();
		serviceConfig.setInterface(UserService.class);
		serviceConfig.setRef(userService);
		serviceConfig.setVersion("1.0.0");
		
		//配置每一个method的信息
		MethodConfig methodConfig = new MethodConfig();
		methodConfig.setName("getUserAddressList");
		methodConfig.setTimeout(1000);
		
		//将method 的设置关联到service 配置中
		List<MethodConfig> methods = new ArrayList<>();
		methods.add(methodConfig);
		serviceConfig.setMethods(methods);
		return serviceConfig;
		
	}

}

 主启动类

@EnableDubbo(scanBasePackages="com.atguigu.gmail")
@SpringBootApplication
public class ProviderApp 
{
    public static void main( String[] args )
    {
        SpringApplication.run(ProviderApp.class, args);
    }
}

 System.out.println("UserService.....1...."); 对应 protocolConfig.setPort(20880);启动一次主启动类，一次类推，一共启动三次

可视化控制台可以看到有三个服务提供者

然后我们浏览器访问访问 http://localhost:8083/initOrder?uid=1 ，多次刷新，然后可以看到dubbo是随机访问每台服务提供者的

如果修改负载均衡的机制，具体的值可以参考http://dubbo.apache.org/zh-cn/docs/user/demos/loadbalance.html

@Service
public class OrderServiceImpl implements OrderService{
	//修改负载均衡的机制
	@Reference(loadbalance="roundrobin")
	UserService userService;

	public List<UserAddress> initOrder(String userId){
		
		List<UserAddress> addressList = userService.getUserAddressList(userId);
		System.out.println(addressList);
		return addressList;
	}
}

 如果是安全权重修改服务提供者的 在@Service中设置对应的权重，这样的是写死的方法

@Component
@Service(weight=100)//暴露服务
public class UserServiceImpl implements UserService {
	
	public List<UserAddress> getUserAddressList(String userId) {
		System.out.println("UserService.....3....");
		UserAddress address1 = new UserAddress(1,"东长安街89号","1","王老师","13278977","1");
		UserAddress address2 = new UserAddress(2,"西长安街90号","1","李老师","13278988","1");
		return Arrays.asList(address1,address2);
	}
}

利用可视化控制台，红色框中的按钮，就可以设置对应服务提供中的权重进行负载均衡按权重轮询了，还是访问上面的连接，然后看控制台的信息，可以区分访问了那台机器，可以通过权重调整机器被访问的次数。

3、整合hystrix，服务熔断与降级处理

1、服务降级

什么是服务降级？

当服务器压力剧增的情况下，根据实际业务情况及流量，对一些服务和页面有策略的不处理或换种简单的方式处理，从而释放服务器资源以保证核心交易正常运作或高效运作。

可以通过服务降级功能临时屏蔽某个出错的非关键服务，并定义降级后的返回策略。

向注册中心写入动态配置覆盖规则：

RegistryFactory registryFactory = ExtensionLoader.getExtensionLoader(RegistryFactory.class).getAdaptiveExtension();
Registry registry = registryFactory.getRegistry(URL.valueOf("zookeeper://10.20.153.10:2181"));
registry.register(URL.valueOf("override://0.0.0.0/com.foo.BarService?category=configurators&dynamic=false&application=foo&mock=force:return+null"));

服务降级的两种方式

  1. mock=force:return+null 表示消费方对该服务的方法调用都直接返回 null 值，不发起远程调用。用来屏蔽不重要服务不可用时对调用方的影响。
  2. 还可以改为 mock=fail:return+null 表示消费方对该服务的方法调用在失败后，再返回 null 值，不抛异常。用来容忍不重要服务不稳定时对调用方的影响。

    第一种测试 

             我们值提供一个Provider 的启动类，OrderService 调用UerService ，

服务消费者只有一个，此时我们点击屏蔽，也是是第一种我们OrderService 就不会去远程调用服务直接反悔了null

浏览器访问http://localhost:8083/initOrder?uid=1 所有的控制台都不会有打印的信息，浏览器返回空白的页面

第一种测试 

     还是上面的截图，我们先回复，然后点击容错

OrderServiceImpl 我们设置超时时间1000ms

@Service
public class OrderServiceImpl implements OrderService{

	@Reference(loadbalance="roundrobin",timeout=1000)
	UserService userService;

	public List<UserAddress> initOrder(String userId){
		
		List<UserAddress> addressList = userService.getUserAddressList(userId);
		System.out.println(addressList);
		return addressList;
	}
}

UserServiceImpl 设置超时2000，让调用超时

@Component
@Service//暴露服务
public class UserServiceImpl implements UserService {
	
	public List<UserAddress> getUserAddressList(String userId) {
		UserAddress address1 = new UserAddress(1,"东长安街89号","1","王老师","13278977","1");
		UserAddress address2 = new UserAddress(2,"西长安街90号","1","李老师","13278988","1");
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return Arrays.asList(address1,address2);
	}
}

浏览器访问http://localhost:8083/initOrder?uid=1 所有的控制台都不会有打印的信息，浏览器返回空白的页面

如果要是不容错，访问超时页面会报错

 

2、集群容错

在集群调用失败时，Dubbo 提供了多种容错方案，缺省为 failover 重试。

集群容错模式

Failover Cluster

失败自动切换，当出现失败，重试其它服务器。通常用于读操作，但重试会带来更长延迟。可通过 retries="2" 来设置重试次数(不含第一次)。 如果一台机器服务坏了，会自动切换调用其他机器的服务

重试次数配置如下：<dubbo:service retries="2" />

或  <dubbo:reference retries="2" />

或   <dubbo:reference>

             <dubbo:method name="findFoo" retries="2" />

      </dubbo:reference>

Failfast Cluster 

          快速失败，只发起一次调用，失败立即报错。通常用于非幂等性的写操作，比如新增记录。

Failsafe Cluster

           失败安全，出现异常时，直接忽略。通常用于写入审计日志等操作。

Failback Cluster

          失败自动恢复，后台记录失败请求，定时重发。通常用于消息通知操作。

Forking Cluster

          并行调用多个服务器，只要一个成功即返回。通常用于实时性要求较高的读操作，但需要浪费更多服务资源。可通过 forks="2" 来设置最大并行数。

Broadcast Cluster

        广播调用所有提供者，逐个调用，任意一台报错则报错 [2]。通常用于通知所有提供者更新缓存或日志等本地资源信息。

集群模式配置

         按照以下示例在服务提供方和消费方配置集群模式

<dubbo:service cluster="failsafe" />

或   <dubbo:reference cluster="failsafe" />

3、整合hystrix

Hystrix 旨在通过控制那些访问远程系统、服务和第三方库的节点，从而对延迟和故障提供更强大的容错能力。Hystrix具备拥有回退机制和断路器功能的线程和信号隔离，请求缓存和请求打包，以及监控和配置等功能

1、配置spring-cloud-starter-netflix-hystrix

spring boot官方提供了对hystrix的集成，直接在服务提供者boot-user-service-provider项目的pom.xml里加入依赖：


		<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
	</dependencies>
<!-- 上面是依赖的最后的部分，前面的已经有了就不写了 --> 
<!-- 下面也是新增的配置-->
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>Finchley.SR1</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

然后在服务提供者Application类上增加@EnableHystrix来启用hystrix starter：

@EnableDubbo(scanBasePackages="com.atguigu.gmail")
@SpringBootApplication
@EnableHystrix //开启服务容错
public class ProviderApp 
{

2、配置Provider端

在Dubbo的Provider上增加@HystrixCommand配置，这样子调用就会经过Hystrix代理。

@Service(version = "1.0.0")
public class HelloServiceImpl implements HelloService {
    @HystrixCommand(commandProperties = {
     @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),
     @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "2000") })
    @Override
    public String sayHello(String name) {
        // System.out.println("async provider received: " + name);
        // return "annotation: hello, " + name;
        throw new RuntimeException("Exception to show hystrix enabled.");
    }
}

3、配置Consumer端

对于Consumer端，则可以增加一层method调用，并在method上配置@HystrixCommand。当调用出错时，会走到fallbackMethod = "reliable"的调用里。

@Component
@Service//暴露服务
public class UserServiceImpl implements UserService {
	
	@HystrixCommand //这个方法被Hystrix 代理
	public List<UserAddress> getUserAddressList(String userId) {
		UserAddress address1 = new UserAddress(1,"东长安街89号","1","王老师","13278977","1");
		UserAddress address2 = new UserAddress(2,"西长安街90号","1","李老师","13278988","1");
		
		if(Math.random() > 0.5){
			throw new RuntimeException();
		}
		return Arrays.asList(address1,address2);
	}
}

服务消费方导入依赖pom.xml

<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>
				spring-cloud-starter-netflix-hystrix
			</artifactId>
		</dependency>
	</dependencies>
<!-- 上面是依赖的最后的部分，前面的已经有了就不写了 --> 
<!-- 下面也是新增的配置-->
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>Finchley.SR1</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

服务方消费方开启服务容错

@EnableDubbo
@SpringBootApplication
@EnableHystrix //开启服务容错
public class ConsumerApp

OrderServiceImpl

@Service
public class OrderServiceImpl implements OrderService{
	
//	@Autowired
	@Reference
	UserService userService;

	/**
	 * 一旦远程调用方法失败，调用hello方法
	 */
	@HystrixCommand(fallbackMethod="hello")
	public List<UserAddress> initOrder(String userId){
		List<UserAddress> addressList = userService.getUserAddressList(userId);
		System.out.println(addressList);
		return addressList;
	}
	
	//远程服务错误 回调hello方法返回数据
	public List<UserAddress> hello(String userId){
		return Arrays.asList(new UserAddress(10, "测试地址", "1", "测试", "测试", "Y"));
	}

}

启动服务提供者，启动服务消费者，浏览器多次访问http://localhost:8083/initOrder?uid=1 ，会有不同的结果！运行将可以自行查看。

4、Dubbo 声明式缓存

参数与返回值：key/value形式

<doubbo:reference interface="com.xxx.ProduceService" cache="lru"/>
<!--1 lru:基于最近最少使用原则删除多余缓存 -->
<!--2 threadlocal:当前线程缓存 -->

1 lru:基于最近最少使用原则删除多余缓存 
2 threadlocal:当前线程缓存   只把缓存 放在客户端请求的缓存中

5、Dubbo 异步调用（待完善）**********

<dubbo:reference id="orderService" interface="com.xxx.OrderService">
     <dubbo:method name="submit" async="true" />
     <dubbo:method name="cancle" async="true" />
</dubbo:reference>

并发请求多个服务 submit和cancel 是两个异步调用的方式，官方不建议这么使用异步调用

6、Dubbo 事件通知（回调）

<dubbo:method name="xxx" async="true" onreturn="callBack.onOrderSubmit"/>

注册到ioc容器中 

<bean id="callBack" class="com.xxx.callback.CallBack"></bean>

异步回调类

/**
  * 回调方法类
  **/
public class CallBack{

   public void onOrderSubmit(OrderEntiry result,OrderEntiry form){
          System.out.println("生成了一单，金额" +result.getMoney());
   }

}

1.正常业务返回时，配置onreturn ,异常抛出时onthrow

7、Dubbo 回声测试  测试阶段用

8、泛化调用（应急的办法）

泛化--抽象

当项目A没有得到项目B接口描述，它还想要rpc调用它，有没有办法？

java反射：不知道对象B的class是什么，想要调用，用反射

<dubbo:reference id="otherService" interface="com.xxx.OtherService" generic="true"/>

 

 

Dubbo 的心跳设计，值得学习！
KHOST的博客
05-29 489
前言 谈到RPC肯定绕不开TCP通信，而主流的RPC框架都依赖于Netty等通信框架，这时候我们还要考虑是使用长连接还是短连接： 短连接：每次通信结束后关闭连接，下次通信需要重新创建连接；优点就是无需管理连接，无需保活连接； 长连接：每次通信结束不关闭连接，连接可以复用，保证了性能；缺点就是连接需要统一管理，并且需要保活； 主流的RPC框架都会追求性能选择使用长连接，所以如何保活连接就是一个重要的话题，也是本文的主题，下面会重点介绍一些保活策略； 为什么需要保...
Dubbo小案例
yw_2022的博客
01-29 3012
Dubbo小案例
Dubbo
wyy的博客
10-07 118
文章目录一、Dubbo架构二、Dubbo支持的协议三、Dubbo支持的注册中心 一、Dubbo架构 1 架构图 2 架构说明 2.1 虚线 虚线表示异步，实线表示同步。异步不阻塞线程性能高，同步阻塞线程必须等待响应结果才能继续执行，相对性能低。 2.2 Provider 提供者。编写持久层、业务层和事务代码。 2.3 Container 容器（Spring容器），Dubbo完全基于Spring实现的。 2.4 Registry 注册中心。放置所有Provider对外提供的信息。包含Provider的IP
dubbo之心跳机制
XiaoGong1688的博客
01-09 1998
在网络传输中，怎么确保通道连接的可用性是一个很重要的问题，简单的说，在网络通信中有客户端和服务端，一个负责发送请求，一个负责接收请求，在保证连接有效性的背景下，这两个物体扮演了什么角色，心跳机制能有效的保证连接的可用性，那它的机制是什么，下文中将会详细讲解。 1|0网络层的可用性 首先讲一下TCP,在dubbo中的通信是基于TCP的，TCP本身并没有长短连接的区别，在短连接中，每次通信时，都会创建Socket,当该次通信结束后，就会调用socket.close()；而在长连接中，每次通...
Dubbo心跳逻辑演进
最新发布
weixin_37838106的博客
01-17 783
1> HeartbeatTimerTask 主要用于定时发送心跳请求<2> ReconnectTimerTask 主要用于心跳失败之后处理重连，断连的逻辑。
dubbo_rpc_hession_rmi
05-23
在IT行业中，分布式服务框架是实现大规模系统高可用、高性能的关键技术之一，而Dubbo、Hessian和RMI则是其中的三个重要组件。本篇将深入解析这些技术及其在实际应用中的示例。 首先，Dubbo是阿里巴巴开源的一款高...
dubbo入门 dubbo_demo.zip
09-02
Dubbo是一款高性能、轻量级的开源Java RPC框架，它致力于提供面向服务的治理方案，使得分布式系统开发更为便捷。在这个压缩包中，我们很可能会找到一个简单的示例项目，用于演示如何配置和运行Dubbo服务。 【描述】...
dubbo高可用篇
09-11
现在分布式架构师开发的潮流，在工作，面试中经常会遇到和别问到，这里提供分布式架构dubbo框架实战的高级篇视频教程百度云分享，希望对大家有帮助。...高可用篇地址：http://u.download.csdn.net/upload
dubbo_user_book
09-12
- **性能测试报告**：定期进行性能测试，确保服务的高可用性和稳定性。 - **测试覆盖率报告**：确保代码的测试覆盖率达到预期标准。 #### 版本历史 Dubbo自1.7.x系列以来，持续迭代更新，引入了许多新特性，例如： ...
尚硅谷_Dubbo_最新_8月
09-03
本套视频从分布式系统的基本概念出发，由浅入深，讲解了RPC原理，Dubbo基本使用，Dubbo高可用场景以及Dubbo原理，涉及了分布式系统中服务注册、服务发现、负载均衡、灰度发布、集群容错、服务降级等核心概念的讲解及...
Dubbo源码解析-Exchanger的实现
恐龙弟旺仔的博客
12-07 750
前言： 在介绍完Protocol层之后，下面来到Exchanger层。 它在整个Dubbo架构中如下所示： 主要作用：作为信息交换层，封装请求响应模式，同步转为异步。 将Server包装为ExchangeServer；将client包装为ExchangeClient。 本文就来分析下这几个重点类。 1.ExchangeClient 客户端的创建 先来看下其入口：DubboProtocol.initClient() 来创建ExchangeClient，最终交由HeaderExchan
Dubbo进阶（十）：心跳机制
热门推荐
程铭程铭你快成名的博客
05-20 1万+
Dubbo客户端和Dubbo服务端之间存在心跳，目的是维持provider和consumer之间的长链接。由Dubbo客户端主动发起，可参见Dubbo源码 HeartbeatTimerTask。 Dubbo心跳时间heartbeat默认是60s，超过heartbeat时间没有收到消息，就发送心跳消息(provider，consumer同样)，若是连着3次(heartbeatTimeout为heartbeat*3)没有收到心跳响应，provider会关闭channel，而consumer会进行重连；不管是pr
spring-cloud-starter-dubbo不设置心跳间隔导致生产者重启no Provider问题记录
qq_37436172的博客
11-05 1064
dubbo在建立连接后会起一个任务，检查连接的是否有效，如果已经时间，会重新连接。问题出在时间间隔上面。 从元数据读取heartbeat这个key，如果没有，那么使用默认的60秒，我们项目没有设置这个心跳时间，那么默认就是60秒。
Dubbo超时和重连机制
weixin_33877092的博客
04-13 495
dubbo启动时默认有重试机制和超时机制。超时机制的规则是如果在一定的时间内，provider没有返回，则认为本次调用失败，重试机制在出现调用失败时，会再次调用。如果在配置的调用次数内都失败，则认为此次请求异常，抛出异常。 如果出现超时，通常是业务处理太慢，可在服务提供方执行：jstack PID &gt; jstack.log 分析线程都卡在哪个方法调用上，这里就是慢的原因。如果不能调优性能，...
stm32 mqtt 如何判断心跳包发送成功_Dubbo 现有心跳方案总结以及改进建议
weixin_39979332的博客
11-29 1078
1 前言设计一个好的心跳机制并不是一件容易的事，就我所熟知的几个 RPC 框架，它们的心跳机制可以说大相径庭，这篇文章我将探讨一下如何设计一个优雅的心跳机制，主要从 Dubbo 的现有方案以及一个改进方案来做分析。2 预备知识因为后续我们将从源码层面来进行介绍，所以一些服务治理框架的细节还需要提前交代一下，方便大家理解。2.1 客户端如何得知请求失败了？高性能的 RPC 框架几乎都会选择使用 Ne...
真强啊！建议每一位Java程序员都读读Dubbo心跳设计的源码...
勇往直前的专栏
07-20 266
# 前言 谈到RPC肯定绕不开TCP通信，而主流的RPC框架都依赖于Netty等通信框架，这时候我们还要考虑是使用长连接还是短连接： 短连接：每次通信结束后关闭连接，下次通信需要重新创建连接；优点就是无需管理连接，无需保活连接； 长连接：每次通信结束不关闭连接，连接可以复用，保证了性能；缺点就是连接需要统一管理，并且需要保活； 主流的RPC框架都会追求性能选择使用长连接，所以如何保活连接就是一个重要的话题，也是本文的主题，下面会重点介绍一些保活策略； # 为什么需要保活 上面介绍的长连接、短连接并
如何设计一个优雅的心跳机制
cqdgmow8442的博客
01-16 2048
来源：Fate/stay night [Heaven's Feel] lost butterfly1 前言在前一篇文章《聊聊 TCP 长连接和心跳那些事》中，我们已经聊过了 TCP 中的 KeepAlive，以及在应用层设计心跳...
Dubbo高可用架构视频教程详解
本篇《Dubbo视频教程--高可用架构篇》将详细讲解Dubbo在实现高可用架构方面的技术和策略。 首先，我们需要明确什么是高可用架构。高可用架构是指系统能够在规定的条件和时间内正常运行，即使在部分组件失效的情况下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值