<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[strive for the best 的博客]]></title><description><![CDATA[]]></description><link>https://blog.csdn.net/xystrive</link><language>zh-cn</language><generator>https://blog.csdn.net/</generator><copyright><![CDATA[Copyright &copy; xystrive]]></copyright><item><title><![CDATA[15.操作系统——文件IO,page cache保证内存与磁盘一致性与设备管理]]></title><link>https://blog.csdn.net/xystrive/article/details/125692926</link><guid>https://blog.csdn.net/xystrive/article/details/125692926</guid><author>xystrive</author><pubDate>Sat, 09 Jul 2022 19:26:01 +0800</pubDate><description><![CDATA[Linux 存储系统的 I/O 软件分层，分为三个层次，分别是文件系统层、通用块层、设备层。常见的IO分为三类：
缓冲与非缓冲 I/O
直接与非直接 I/O
阻塞与非阻塞 I/O VS 同步与异步 I/O阻塞 I/O、非阻塞 I/O，还是基于非阻塞 I/O 的多路复用都是同步调用。因为它们在 read 调用时，内核将数据从内核空间拷贝到应用程序空间，过程都是需要等待的，也就是说这个过程是同步的，如果内核实现的拷贝效率不高，read 调用就会在这个同步过程中等待比较长的时间。1.缓冲与非缓冲IO
根据是否利用]]></description><category></category></item><item><title><![CDATA[MySQL学习笔记7——MySQL主备一致性问题，主备高可用问题]]></title><link>https://blog.csdn.net/xystrive/article/details/125666463</link><guid>https://blog.csdn.net/xystrive/article/details/125666463</guid><author>xystrive</author><pubDate>Thu, 07 Jul 2022 21:07:58 +0800</pubDate><description><![CDATA[状态1A主B备，从A更新同步到B。
需要主备切换的时候，B主A备。备库要设置成只读：主库到备库的数据怎么同步的，单主模式
假设有一个更新语句，执行过程如上，其中主库内部又一个线dump_thread，专门用来服务备库的长连接。
一个事务日志同步的完整过程是这样的binlog拿走之后可以直接被备库使用一种是statement，一种是row，一种是mix。至少用mix。因为：row格式的好处：方便恢复数据即使我执行的是delete语句，row格式的binlog也会把被删掉的行的整行信息保存起来。所以，如果你在执]]></description><category></category></item><item><title><![CDATA[MySQL学习笔记6——MySQL完整性问题，性能瓶颈问题]]></title><link>https://blog.csdn.net/xystrive/article/details/125647858</link><guid>https://blog.csdn.net/xystrive/article/details/125647858</guid><author>xystrive</author><pubDate>Thu, 07 Jul 2022 16:24:21 +0800</pubDate><description><![CDATA[了解了binlog之后，我们看InnoDB如何执行更新语句的。我们注意到写入redo log 的步骤分为prepare和commit两个阶段。这就是两阶段提交，主要为了让两份日志保持逻辑一致binlog会记录所有操作，并追加写入，系统定期做整库备份。假设我们找到的整库备份与需求记录点差一天，我们只需要从这个点开始根据binlog重做这一天所有的操作即可。假设不使用两阶段提交，而先写某一个日志，写完了再写另一个
假设场景为，ID=2，这一行c=0；要将其加1，更新完第一个日志，之后再写第二个日志的时候发生了c]]></description><category></category></item><item><title><![CDATA[MongoDB vs MySQL vs Hive]]></title><link>https://blog.csdn.net/xystrive/article/details/125528531</link><guid>https://blog.csdn.net/xystrive/article/details/125528531</guid><author>xystrive</author><pubDate>Wed, 29 Jun 2022 20:51:12 +0800</pubDate><description><![CDATA[mysql 是关系型数据库优点：缺点：不是关系型，属于文档型数据库，文档（多个键值对有序存放）是基础单元，类似于关系模型的行。
存储方式： 虚拟内存+持久化。
架构特点：可以通过副本集、分片实现高可用。
适合场景：事件的记录，内容管理或者博客平台等等。
数据处理：数据是存储在硬盘上的，只不过需要经常读取的数据会被加载到内存中，将数据存储在物理内存中，从而达到高速读写。优点缺点： 不支持事务。hive首先明确并不是一个数据库，而是数据仓库。
Hive 不适合用于联机事务处理 (OLTP)，也不提供实时查询功能]]></description><category></category></item><item><title><![CDATA[TCC方案 详解]]></title><link>https://blog.csdn.net/xystrive/article/details/125509412</link><guid>https://blog.csdn.net/xystrive/article/details/125509412</guid><author>xystrive</author><pubDate>Wed, 29 Jun 2022 16:45:41 +0800</pubDate><description><![CDATA[TCC是 try预处理 confirm确认 cancel撤销三个操作。
try 预处理：业务检查及资源预留
confirm确认： 业务确认
cancel 撤销：实现与try相反的回滚操作。首先发起try操作，任何一个分支事务try操作失败，都要全体分支事务cancel.
若全部成功，则对全体confirm。三个阶段
一个管理器：TM事务管理器，可以实现为独立服务，或者让全局事务的发起者充当TM，目的是为了成为公用组件，以复用功能。
TM发起全局事务时生成全局事务记录，每条记录有全局事务ID，用来记录事务上下]]></description><category></category></item><item><title><![CDATA[MySQL学习笔记5——优化问题（短连接，慢查询，QPS激增）]]></title><link>https://blog.csdn.net/xystrive/article/details/125508577</link><guid>https://blog.csdn.net/xystrive/article/details/125508577</guid><author>xystrive</author><pubDate>Tue, 28 Jun 2022 20:14:49 +0800</pubDate><description><![CDATA[正常的短连接模式就是连接到数据库后，执行很少的SQL语句就断开，下次需要的时候再重连。
如果使用的是短连接，在业务高峰期的时候，就可能出现连接数突然暴涨的情况。解决方法：（有损）在MySQL中，会引发性能问题的慢查询，大体有以下三种可能：1.索引设计问题
可以创建online DDL,直接执行alter table，比较理想的是能够在备库先执行。假设你现在的服务是一主一备，主库A、备库B，这个方案的
大致流程是这样的：2.语句没写好
可能的情况：解决方法：
改写SQL语句来处理。MySQL 5.7提供了查询]]></description><category></category></item><item><title><![CDATA[Spark 详解]]></title><link>https://blog.csdn.net/xystrive/article/details/125486622</link><guid>https://blog.csdn.net/xystrive/article/details/125486622</guid><author>xystrive</author><pubDate>Mon, 27 Jun 2022 17:16:41 +0800</pubDate><description><![CDATA[为了跟 Hadoop 配合而开发出来的,不是为了取代 Hadoop, Spark 运算比 Hadoop 的 MapReduce 框架快的原因是因为 Hadoop 在一次 MapReduce 运算之后,会将数据的运算结果从内存写入到磁盘中,第二次 Mapredue 运算时在从磁盘中读取数据,所以其瓶颈在2次运算间的多余 IO 消耗. Spark 则是将数据一直缓存在内存中,直到计算得到最后的结果,再将结果写入到磁盘,所以多次运算的情况下, Spark 是比较快的.
在核心框架 Spark 的基础上,主要提供四]]></description><category></category></item><item><title><![CDATA[MySQL学习笔记4——全局锁，表锁，行锁，死锁检测]]></title><link>https://blog.csdn.net/xystrive/article/details/125357395</link><guid>https://blog.csdn.net/xystrive/article/details/125357395</guid><author>xystrive</author><pubDate>Sun, 19 Jun 2022 15:15:40 +0800</pubDate><description><![CDATA[根据加锁的范围，MySQL里面的锁大致可以分成全局锁、表级锁和行锁三类。全局锁就是对整个数据库实例加锁，Flush tables with read lock (FTWRL)
当你需要让整个库处于只读状态的时候，可以使用这个命令，之后其他线程的以下语句会被阻塞：数据更新语句（数据的增删改）、数据定义语句（包括建表、修改表结构等）和更新类事务的提交语句。
典型应用场景：全库逻辑备份，不加锁的话，备份系统备份的得到的库不是一个逻辑时间点，这个视图是逻辑不一致的。怎么解决一致性视图问题？可重复度隔离级别官方自带的]]></description><category></category></item><item><title><![CDATA[MySQL学习笔记3——索引]]></title><link>https://blog.csdn.net/xystrive/article/details/125209863</link><guid>https://blog.csdn.net/xystrive/article/details/125209863</guid><author>xystrive</author><pubDate>Thu, 09 Jun 2022 20:45:14 +0800</pubDate><description><![CDATA[比较常见的索引模型有三种，哈希表，有序数组，搜索树。为了处理多个key经过哈希函数映射到同一个数组位置的问题，解决方法一般是拉出一个链表
如上图，维护一个身份证信息-姓名的表，根据身份证号查找名字。
可以看见2和4两个虽然key值映射到的都是N，因此由此拉出一个链表，按顺序遍历这个链表，直到找到对应值问题在于，key值并不是递增的，只是单纯的往链表后追加，非有序带来的问题就是查询速度慢
所以，哈希表适用于只有等值查询（筛选出一个字段等于特定值的所有记录）的场景假设是有序排列的，那么查找自然很方便，用二分法即]]></description><category></category></item><item><title><![CDATA[11.算法进阶之分布式篇——一致性哈希算法——流量分配与负载均衡]]></title><link>https://blog.csdn.net/xystrive/article/details/125170303</link><guid>https://blog.csdn.net/xystrive/article/details/125170303</guid><author>xystrive</author><pubDate>Wed, 08 Jun 2022 21:02:07 +0800</pubDate><description><![CDATA[在分布式环境中，我们倾向于比较均衡的利用每台机器，不至于单点过载，也能发挥集群的最大价值。
比较常见的方法是轮询与随机分配，一般按照实例多少加以权值，所以一般采用的是加权轮询以及加权随机。但是大多数策略问题在于：无法应对带有多种状态的请求或者服务有状态的请求：
我们再分布式KV缓存系统中，往往会把数据水平切分到不同节点来存储，为了保证系统可用性，冗余是必要的，对于这样的系统，某个key值应该在某一个确定的节点上获取，而不是随便访问一个节点都能得到全局的key 这样的服务我们认为是有状态的。再比如，dag中某]]></description><category></category></item><item><title><![CDATA[10.算法进阶之分布式篇——分布式环境下如何生成唯一ID——UUID]]></title><link>https://blog.csdn.net/xystrive/article/details/125167432</link><guid>https://blog.csdn.net/xystrive/article/details/125167432</guid><author>xystrive</author><pubDate>Tue, 07 Jun 2022 16:31:29 +0800</pubDate><description><![CDATA[UUID——全局唯一ID——universally unique identifie。一般来说常用的基于时间进行排序，因为时间是自然递增的。但是全局唯一ID的两个核心要求是：在分布式环境下，很有可能多台机器同时产生了同一个ID，这样就无法唯一的标识某项业务。我们可以独立部署一个服务，专门用于生成ID。其他需要ID的服务，都调用这一个接口，这样在一台机器上我们就可以利用本地的时钟或者计数器来分发ID。问题一：时钟回拨
计算机底层的时钟，主要依靠石英钟，本身是有一定的误差的，计算机定期请求NTP服务，来同步当前]]></description><category></category></item><item><title><![CDATA[9.算法进阶之分布式篇——Raft分布式系统达成共识]]></title><link>https://blog.csdn.net/xystrive/article/details/125149970</link><guid>https://blog.csdn.net/xystrive/article/details/125149970</guid><author>xystrive</author><pubDate>Mon, 06 Jun 2022 17:35:19 +0800</pubDate><description><![CDATA[先搞清楚分布式一致性到底解决的是什么问题
我们知道数据库中 redo log经常用以记录数据变更，数据在被日志记录之后才会被应用。
如果多个节点存储的是同样的东西，我们怎么保证在经过一番更改之后，这些内容还是一致的呢？客户端通常只会向分布式系统中的某个服务器发起请求，然后由这个服务器的一致性模块，在多个复制状态机之间进行消息的同步，正常情况下，多个节点同步都会成功，这样不同节点的日志自然也都是一致的，所有的节点都会以相同的顺序包含相同的请求，从外界看起来，行为也就像是一台机器一样。但是如果服务器发生了故障，]]></description><category></category></item><item><title><![CDATA[8.算法进阶之分布式篇——Pagerank算法计算网页排名]]></title><link>https://blog.csdn.net/xystrive/article/details/125149120</link><guid>https://blog.csdn.net/xystrive/article/details/125149120</guid><author>xystrive</author><pubDate>Mon, 06 Jun 2022 16:44:14 +0800</pubDate><description><![CDATA[谷歌三驾马车——mapreduce,page rank,google file system。PageRank 算法不止可以让用户搜索到自己关心的内容，也往往能让质量更高的网页得以排到更前的位置，同时它也是一个典型的 MapReduce 的应用场景。思想源于学术论文的引用次数，高引用的文章一般来说被认为是质量高的文章。被更多超链接指向的网页，可以推断它往往会有更好的质量，因为当时许多 HomePage 类的导航网站都会链接到一些提供优质服务的网站，如果一个网站质量很差，自然也不会被太多链接所指向。但不同网页]]></description><category></category></item><item><title><![CDATA[7.算法进阶之分布式篇——MapReduce大规模分布式计算]]></title><link>https://blog.csdn.net/xystrive/article/details/125123076</link><guid>https://blog.csdn.net/xystrive/article/details/125123076</guid><author>xystrive</author><pubDate>Sat, 04 Jun 2022 17:18:15 +0800</pubDate><description><![CDATA[在大量的数据处理需求下，程序是分布式运行的，但是每个业务如果都需要针对雷同的问题各自做出雷同的处理，效率太低。例子
假设一个 number 数组中，我们希望统计出数值大于 5 的那些数向上取整的和。这个问题很简单，常规的写法自然是遍历整个数组，写一个 if-else 判断出大于 5 的数，然后用一个变量做累计求和。但是这个写法引入了状态，在循环里你既需要关心 filter 的逻辑，又要关心累计求和的逻辑，不够清晰。
但是如果这样写：
通过三个原语区分开控制逻辑和计算逻辑。如果我们把输入数据表示成一个键值对K]]></description><category></category></item><item><title><![CDATA[6.算法进阶——字符串匹配问题——BM算法]]></title><link>https://blog.csdn.net/xystrive/article/details/125113566</link><guid>https://blog.csdn.net/xystrive/article/details/125113566</guid><author>xystrive</author><pubDate>Fri, 03 Jun 2022 17:00:38 +0800</pubDate><description><![CDATA[最简单的暴力方法大家应该都会写，我们来看一下优化。
最主要的问题在于，能不呢利用之前已经匹配的一部分，进行继续匹配，而不是从头开始基于预处理来避免不必要的重复。从模式串的末尾，往前匹配
坏字符的作用是跳过一些肯定不可能成立的匹配位置，描述的是主串上的失配字符。

当我们对其s和p之后，从p的末尾即p[6]开始匹配。发现和s[6]不一致，此时s中不匹配的s[6]=S，就是坏字符发现坏字符之后。检查模式串p中是否有S，没有，直接从S[7]开始匹配因为没有就说明了，模式串中任何一个部分都不可能与目前的s重叠，跳过]]></description><category></category></item><item><title><![CDATA[5.算法进阶——kafka消息查询（二分法）——稀疏索引与B+树索引的对比]]></title><link>https://blog.csdn.net/xystrive/article/details/125106442</link><guid>https://blog.csdn.net/xystrive/article/details/125106442</guid><author>xystrive</author><pubDate>Thu, 02 Jun 2022 20:40:15 +0800</pubDate><description><![CDATA[Kafka 是一款性能强大且相当常用的分布式消息队列，常常用于对流量进行消峰、解耦系统和异步处理部分逻辑以提高性能的场景。
在kafka中，所有的消息都以日志的形式存储。这种日志只允许追加新数据，不允许修改之前文件内容日志文件的存储方式：每个topic有多个partition，每个patition有多个有序日志段
即如何为日志文件建立一个索引，这里很关键的一个问题在于offset是自然线性增长的，是有序的我们来看一个topic中一个patition的日志文件格式：
我理解前面属于相较于物理第一个文件的绝对偏]]></description><category></category></item><item><title><![CDATA[4.算法进阶——外部排序，如何用有限的内存对TB级数据进行排序]]></title><link>https://blog.csdn.net/xystrive/article/details/125105873</link><guid>https://blog.csdn.net/xystrive/article/details/125105873</guid><author>xystrive</author><pubDate>Thu, 02 Jun 2022 20:19:26 +0800</pubDate><description><![CDATA[内存是有限的，而所谓外部排序的这个外：指的是外部存储。
已知1GB的内存如果要处理1TB，至少要读1024次。
所以大体思路一定是：将文件分段，用常见内部排序方法进行排序完了之后，再合并。即思路上大体是归并排序1.内部排序
我们分成一段一段之后，主要目的是使得内存能够装下这一段数据。
一般来说，快速排序在大部分场景下都是最快的2.归并阶段
因为需要归并n多个段，此时的内存肯定无法装下超过一个段的内容。此时最大的时间消耗来自IO。
内存的读写操作是很快的，但是外部磁盘中读写，可能比内...]]></description><category></category></item><item><title><![CDATA[MySQL学习笔记2——事务隔离，MVCC突破数据库并发读写性能瓶颈]]></title><link>https://blog.csdn.net/xystrive/article/details/124991202</link><guid>https://blog.csdn.net/xystrive/article/details/124991202</guid><author>xystrive</author><pubDate>Thu, 26 May 2022 20:30:45 +0800</pubDate><description><![CDATA[我们在之前数据库的基础篇大致谈过一些事务的隔离级别的内容具体见添加链接描述

为什么事务要隔离
ACID四大特性分别是，atomicity原子性.consistency一致性，isolation隔离性以及durability持久性。
这里为什么需要隔离性，因为在实际工程当中，经常会出现一些问题，这些问题大致是：
脏读
不可重复读
幻读
为了解决上述问题，因此强调隔离性。
事务的四种隔离级别

读未提交：某事务还未commit，他的改变就能被别的事务看到。这种情况会出现上述三种问题。对锁的要求很低，即读不需.]]></description><category></category></item><item><title><![CDATA[3.算法进阶——双端队列 详解]]></title><link>https://blog.csdn.net/xystrive/article/details/124990836</link><guid>https://blog.csdn.net/xystrive/article/details/124990836</guid><author>xystrive</author><pubDate>Thu, 26 May 2022 19:39:30 +0800</pubDate><description><![CDATA[前提回顾
我们在这一篇
添加链接描述
里也大致介绍过双端队列这种数据结构。
回顾一下，大致是说有一个指针数组，里面每个指针指向一段连续的空间。
这样只需要在头部和尾部放两个指针即可执行双向的操作。
而后遍历指针所指的连续空间时，需要四个指针，两个指向头尾，一个指向正在遍历，第四个则指向当前连续空间在指针数组中所存放的位置。
补充
因为主要原理在之前的博客中基本已经介绍过了，这里只做一些补充。
首先明确deque和普通的queue共同点在于：
语义上来说并不支持数组基于下标在指定位置的修改、插入和删除的操作。]]></description><category></category></item><item><title><![CDATA[14.算法——拓扑排序（课程表问题210，207）]]></title><link>https://blog.csdn.net/xystrive/article/details/124733680</link><guid>https://blog.csdn.net/xystrive/article/details/124733680</guid><author>xystrive</author><pubDate>Thu, 12 May 2022 17:02:37 +0800</pubDate><description><![CDATA[问题介绍
我理解主要是这么一个图论问题，在一群节点中，每个节点都有自己的入度和出度，一条有向边的方向可以理解为先后问题。而后我们对这些节点进行排序，保证先访问入度为0的节点。
主要是看有没有环的问题。
这样讲可能有些玄幻，举个例子。
课程表问题

在这个题目中，数组pre的first代表要想修1必须修0，即一条从0到1的有向边。
解法：广度优先
队列表示访问，入度为0的先访问（出队），访问到某一个节点之后，与其相邻节点的入度减一，如果减一之后出现新入度为0的节点，继续入队。
看最后访问数组的size和原数组]]></description><category></category></item></channel></rss>