<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[Lavender-csdn的博客]]></title><description><![CDATA[好好学习]]></description><link>https://blog.youkuaiyun.com/kidchildcsdn</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; kidchildcsdn]]></copyright><item><title><![CDATA[服务熔断Hystrix]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120624234</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120624234</guid><author>kidchildcsdn</author><pubDate>Thu, 07 Oct 2021 14:40:24 +0800</pubDate><description><![CDATA[Hystrix是什么

在微服务架构中，我们是将一个单体应用拆分成多个服务单元，各个服务单元之间通过注册中心彼此发现和消费对方提供的服务，每个服务单元都是单独部署，在各自的服务进程中运行，服务之间通过远程调用实现信息交互，那么当某个服务响应太慢或者故障，又或者因为网络波动或者故障，则会造成调用者延迟或者调用失败，当大量请求到达，则会造成请求的堆积，导致调用者的线程挂起，从而引发调用者也无法响应，调用者也发生故障。

比如电商中的用户下单，我们有两个服务，一个下订单服务，一个减库存服务，当用户下订单时调用下订]]></description><category></category></item><item><title><![CDATA[走进包装类]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120614355</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120614355</guid><author>kidchildcsdn</author><pubDate>Tue, 05 Oct 2021 16:03:46 +0800</pubDate><description><![CDATA[引入

Java认为一切皆对象，引用数据类型就是对象。但是在Java中8中基本数据类型不是对象，只是表示一种数据的类型形式。

Java为了一切皆对象的思想统一，把8中基本数据类型转换成对应的类，这个类称为基本数据类型的包装类。


/**
 * 基本数据类型       包装类（引用数据类型）
 * byte               Byte
 * short              Short
 * int                Integer（特殊）
 * long           ]]></description><category></category></item><item><title><![CDATA[泛型是什么]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120611799</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120611799</guid><author>kidchildcsdn</author><pubDate>Tue, 05 Oct 2021 15:13:57 +0800</pubDate><description><![CDATA[什么是泛型？

泛型就是一个标签：&lt;数据类型&gt;

泛型可以在编译阶段约束只能操作某种数据类型。

注意：JDK1.7开始之后，泛型后面的声明可以省略不写！！

泛型和集合都只支持引用数据类型，不支持基本数据类型。

泛型的好处：泛型在编译阶段约束了操作的数据类型，从而不会出现类型转换异常。体现的是Java的严谨性和规范性，数据类型，经常需要进行统一。

自定义泛型类

泛型类的概念：使用了泛型定义的类就是泛型类

泛型类的格式：


修饰符 class 类名&lt;泛型变量&gt;{

}


]]></description><category></category></item><item><title><![CDATA[客户端负载均衡Ribbon]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120603207</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120603207</guid><author>kidchildcsdn</author><pubDate>Tue, 05 Oct 2021 09:50:14 +0800</pubDate><description><![CDATA[Spring Cloud中的Ribbon是什么？

我们通常说的负载均衡是指将一个请求均匀地分摊到不同的节点单元上执行，负载均衡分为硬件负载均衡和软件负载均衡；

硬件负载均衡：比如F5、深信服、Array等；

软件负载均衡：比如Nginx、LVS、HAProxy等；

硬件负载均衡或者软件负载均衡，他们都会维护一个可用的服务端清单，通过心跳检测来剔除故障的服务端节点以保证清单中都是可以正常访问的服务端节点。当客户端发送请求到负载均衡设备的时候，该设备按照某种算法（比如轮询、权重、最小连接数等）从维护的可]]></description><category></category></item><item><title><![CDATA[服务注册中心-Eureka]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120602424</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120602424</guid><author>kidchildcsdn</author><pubDate>Mon, 04 Oct 2021 13:18:46 +0800</pubDate><description><![CDATA[Eureka注册中心高可用集群概述

在微服务架构的这种分布式系统中，需要充分考虑各个微服务组件的高可用性问题，不能单点故障，由于注册中心eureka本身也是一个服务，如果它只有一个节点，那么它有可能发生故障，这样我们就不能注册与查询服务了，所以我们需要一个高可用的服务注册中心，这就需要通过注册中心集群来解决。

eureka服务注册中心它本身也是一个服务，它也可以看做是一个提供者，又可以看做是一个消费者，之前通过配置eureka.client.register-with-eureka=false让注册中心]]></description><category></category></item><item><title><![CDATA[走进服务注册中心---Eureka]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120595728</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120595728</guid><author>kidchildcsdn</author><pubDate>Sun, 03 Oct 2021 20:15:11 +0800</pubDate><description><![CDATA[Spring cloud的整体架构



原始方式：服务的消费者直接通过访问服务提供者的url去调用里面的方法：



import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import.]]></description><category></category></item><item><title><![CDATA[微服务架构概述]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120585440</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120585440</guid><author>kidchildcsdn</author><pubDate>Sat, 02 Oct 2021 14:53:23 +0800</pubDate><description><![CDATA[系统进化理论概述

在系统架构与设计的实践中，经历了两个阶段，一个阶段是早些年常见的集中式系统，一个阶段是近年来流行的分布式系统

集中式系统

集中式系统也叫单体应用，就是把所有的程序、功能、模块都集中到一个项目中，部署在一台服务器上，从而对外提供应用；

分布式系统

分布式系统就是把所有的程序、功能拆分成不同的子系统，部署在多台不同的服务器上，这些子系统相互协作共同对外提供服务，而对用户而言他并不知道后台是多个子系统和多台服务器在提供服务，在使用上和集中式系统一样。

集中式系统跟分布式系统是相反的两]]></description><category></category></item><item><title><![CDATA[并查集--leetcode]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120248378</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120248378</guid><author>kidchildcsdn</author><pubDate>Sun, 12 Sep 2021 12:28:47 +0800</pubDate><description><![CDATA[并查集作用：

1、合并两个集合

2、判断两个点是否在同一个集合中

模板：


// 找到父节点
public static int find(int x) {
	if(p[x]!=x) p[x] = find(x);
	return p[x];
}

1、547. 省份数量



以下为java代码：


class Solution {
    static int[] p;
    public int findCircleNum(int[][] isConnected) {
        in]]></description><category></category></item><item><title><![CDATA[前缀和+哈希---leetcode]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120247512</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120247512</guid><author>kidchildcsdn</author><pubDate>Sun, 12 Sep 2021 10:44:40 +0800</pubDate><description><![CDATA[前缀和的基本概念



题目：560. 和为 K 的子数组

考察S[R]-S[L-1]是否等于k，哈希表的作用可以快速插入一个数、可以快速找到一个数、可以统计数出现的次数。

以下为Java代码：


class Solution {
    public int subarraySum(int[] nums, int k) {
        int result = 0;
		int sum = 0;  //表示前缀和
		Map&lt;Integer,Integer&gt; map = new H.]]></description><category></category></item><item><title><![CDATA[字符串处理专题--Leetcode]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120113157</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/120113157</guid><author>kidchildcsdn</author><pubDate>Sun, 05 Sep 2021 15:58:45 +0800</pubDate><description><![CDATA[1、49. 字母异位词分组



思路：定义一个map，key值为每个排好序的字符串，value为字符串本身，key的类型为String，value的类型为ArrayList&lt;String&gt;。所以以上例子的map为


map={

    "aet":{"ate","eat","tea"},

    "abt":{bat},

    "ant":{"nat","tan"}

}


以下为java代码


class Solution {
    public L...]]></description><category></category></item><item><title><![CDATA[双指针（滑动窗口）解题---Leetcode]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/119979202</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/119979202</guid><author>kidchildcsdn</author><pubDate>Sun, 29 Aug 2021 16:43:14 +0800</pubDate><description><![CDATA[算法思想：

1、在字符串 S 中使用双指针中的左右指针技巧，初始化 left = right = 0，把索引闭区间 [left, right] 称为一个「窗口」。

2、先不断地增加 right 指针扩大窗口 [left, right]，直到窗口中的字符串符合要求。

3、此时，停止增加 right，转而不断增加 left 指针缩小窗口 [left, right]，直到窗口中的字符串不再符合要求。同时，每次增加 left，都要更新一轮结果。

4、重复第 2 和第 3 步，直到 right 到达字符串 S]]></description><category></category></item><item><title><![CDATA[并发数据一致性解决方案]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/115260912</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/115260912</guid><author>kidchildcsdn</author><pubDate>Sat, 27 Mar 2021 11:05:17 +0800</pubDate><description><![CDATA[乐观锁、悲观锁、分布式锁

乐观锁

从数据库层面来看，就是在表中加入一个版本号字段version，这样每次修改数据的时候，都需要比较版本号。

从代码层面讲：



从乐观锁的层面讲，也能解决超卖、数据不一致的问题。

缺点：

不适用高并发场景，会导致失败率很高，锁冲突比较大，影响用户体验，前端处理那边只能不断重试。可以设置乐观锁冲突的最大重试次数，减少一些无用访问。

悲观锁



假设现在有5个请求对共享资源进行访问，首先T1过来，对该资源加锁，一直到事务提交之后才会释放锁，如果当前是一个长事务，那]]></description><category></category></item><item><title><![CDATA[Spring循环依赖问题]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/115213328</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/115213328</guid><author>kidchildcsdn</author><pubDate>Thu, 25 Mar 2021 20:22:22 +0800</pubDate><description><![CDATA[学习地址：https://www.bilibili.com/video/BV1ET4y1N7Sp?p=2

1、什么是Spring循环依赖？

2、循环依赖怎么解决？

3、Spring中为什么要使用三级缓存来解决循环依赖？二级缓存能不能解决循环依赖问题？

什么是Spring循环依赖



首先了解Bean的创建与管理过程：



结论：获取Bean的时候先从单例池中获取，如果没有则创建并添加到单例池。

获取Bean

找bean工厂，调用两次单例池。第一次通过beanName获取，如果单例池中并没有这]]></description><category></category></item><item><title><![CDATA[Redisson实现Redis分布式锁以及Redlock分布式锁]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/114980719</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/114980719</guid><author>kidchildcsdn</author><pubDate>Thu, 18 Mar 2021 17:28:08 +0800</pubDate><description><![CDATA[首先看一段模拟扣减库存的代码：


import lombok.extern.slf4j.Slf4j;
import org.redisson.Redisson;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.]]></description><category></category></item><item><title><![CDATA[IO那些事儿（BIO、NIO、AIO、多路复用、select、poll、epoll）]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/114777361</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/114777361</guid><author>kidchildcsdn</author><pubDate>Sun, 14 Mar 2021 17:18:07 +0800</pubDate><description><![CDATA[这篇文章真没想着怎么怎么深入这些概念，只能说尽可能自己在学习的过程中说清楚，加深理解和印象，毕竟基本上全是操作系统底层的原理，现在更多对本科学的操作系统的印象停留在：虚拟存储、页面置换算法这些东西。说实话，底层的东西觉得难，学起来吃力、忘得也就快了。

IO

简单一点，就是对输入数据和输出数据的处理，读写数据。

BIO

同步阻塞。基于线程的驱动模型。BIO最重要的是理解"B"是什么，blocking，阻塞的意思，直接看一段代码，这段代码是网络编程服务器端的一段代码。总体大意就是服务器端与客户端要连接，]]></description><category></category></item><item><title><![CDATA[leetcode组合总数回溯法超时，试试动态规划]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/114731751</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/114731751</guid><author>kidchildcsdn</author><pubDate>Sat, 13 Mar 2021 10:58:33 +0800</pubDate><description><![CDATA[leetcode377. 组合总和 Ⅳ

题目描述：

给定一个由正整数组成且不存在重复数字的数组，找出和为给定目标正整数的组合的个数。



根据前几道组合总和的做题轨迹，直接使用回溯：


class Solution {
    public int count=0; //记录满足组合的个数
    public int combinationSum4(int[] nums, int target) {
        int cursum = 0;
        backtrack(nums,ta]]></description><category></category></item><item><title><![CDATA[为什么建议InnoDB表必须建立主键，并且推荐使用整型的自增主键]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/114708383</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/114708383</guid><author>kidchildcsdn</author><pubDate>Fri, 12 Mar 2021 21:54:57 +0800</pubDate><description><![CDATA[推荐一个国外的数据结构在线演示网站：https://www.cs.usfca.edu/~galles/visualization/Algorithms.html

UUID：32个16进制数字，全球唯一，本地生成，性能高，没有网络耗时，但是非常长，占用大量的存储空间，并且作为主键建立索引和基于索引查询的时候会存在性能问题，一般这种方式不采用。

为什么InnoDB表必须建立主键



InnoDB中采用的是聚簇索引，表数据文件本身就是按照B+Tree组织的一个索引结构文件，主键索引默认就是B+Tree，由.]]></description><category></category></item><item><title><![CDATA[回溯法解算法题-leetcode中的组合排列求子集问题]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/114699131</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/114699131</guid><author>kidchildcsdn</author><pubDate>Fri, 12 Mar 2021 17:37:01 +0800</pubDate><description><![CDATA[回溯算法的模板：


List&lt;Object&gt; list = new ArrayList&lt;&gt;();
public void backtrack(路径，选择列表){
    //设置结束条件
    if 满足结束条件{
        lista.dd(路径);
        return;
    }
    //候选节点的选择
    for(int i=start;i&lt;选择列表的长度;i++){
        //做选择  是否要将当前节点添加到list中
     ]]></description><category></category></item><item><title><![CDATA[数据库分库分表带来的问题]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/114678265</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/114678265</guid><author>kidchildcsdn</author><pubDate>Thu, 11 Mar 2021 21:08:01 +0800</pubDate><description><![CDATA[在对数据库中的数据进行拆分的时候，也会带来以下问题：

事务问题；
	跨表分页、排序、函数问题；
	全局主键避重问题；
	数据迁移、扩容问题。
事务问题

目前数据库能够实现本地事务，也就是在同一个数据库中，可以允许一组操作要么全都正确执行，要么都不执行，从而确保数据库的一致性。单从分区角度出发，实际上仍然是一张表，一个库中，它不会存在事务一致性的问题，但是会使得事务变得非常复杂。

而单库分表和分库分表会涉及到分布式事务，目前数据库并不支持跨库事务，所以在这一块需要解决分布式事务可能带来的不一致性。

分]]></description><category></category></item><item><title><![CDATA[动态规划-最长递增子序列和最长连续递增子序列]]></title><link>https://blog.youkuaiyun.com/kidchildcsdn/article/details/114365470</link><guid>https://blog.youkuaiyun.com/kidchildcsdn/article/details/114365470</guid><author>kidchildcsdn</author><pubDate>Thu, 04 Mar 2021 12:24:23 +0800</pubDate><description><![CDATA[leetcode674. 最长连续递增序列

题目描述：

给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。

连续递增的子序列 可以由两个下标 l 和 r（l &lt; r）确定，如果对于每个 l &lt;= i &lt; r，都有 nums[i] &lt; nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。




class Solution {
    publ.]]></description><category></category></item></channel></rss>