<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[qq_38197844的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/qq_38197844</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; qq_38197844]]></copyright><item><title><![CDATA[Redis内存淘汰机制（MySQL里有2000w数据，Redis中只存20w数据，如何保证redis中的数据都是热点数据？）]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109551109</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109551109</guid><author>qq_38197844</author><pubDate>Sat, 07 Nov 2020 19:31:17 +0800</pubDate><description><![CDATA[redis提供了6种数据淘汰策略：
	volatile-lru：从已设置过期时间的数据集中挑选最近最少使用的数据淘汰。
		volatile-ttl：从已设置过期时间的数据集中挑选将要过期的数据淘汰。
		volatile-random：从已设置过期时间的数据集中任意选择数据淘汰。
		allkeys-lru（最常用）：当内存不足以容纳新写入数据时，在键空间中，移出最近最少使用的key。
		allkeys-random：当内存不足以容纳新写入数据时，从数据集中任意选择数据淘汰。
		no-eviction]]></description><category></category></item><item><title><![CDATA[Redis设置过期时间]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109551100</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109551100</guid><author>qq_38197844</author><pubDate>Sat, 07 Nov 2020 19:30:30 +0800</pubDate><description><![CDATA[使用redis在set key的时候可以给一个expire time，就是过期时间，通过过期时间可以指定这个key可以存活的时间。假设设置了一批key只能存活1个小时的时间，那么1个小时之后redis是怎么对这些key进行删除的？
	定期删除：redis默认是每隔100ms就随机抽取一些设置了过期时间的key，检查是否过期，如果过期就删除。（这里是随机抽取，因为假如redis存了几十万个key，每隔100ms就遍历所有设置过期时间的key，会给cpu带来很大的负载。）
		惰性删除：定期删除导致可能很多过期]]></description><category></category></item><item><title><![CDATA[Redis和Memcached区别]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109551089</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109551089</guid><author>qq_38197844</author><pubDate>Sat, 07 Nov 2020 19:29:42 +0800</pubDate><description><![CDATA[1. Redis不光支持简单的key-value型数据库，同时还支持list、set、String、hash等数据结构，而memcached只支持简单的数据类型String
	2. Redis支持数据持久化，数据可以从内存持久化到磁盘，下次启动再加载，而memcached把数据全部存储在内存中。
	3. Redis是单线程网络IO模型，memcached是多线程、非阻塞复用的网络模型。
	4. Redis比memcached快
...]]></description><category></category></item><item><title><![CDATA[TCP协议如何保证可靠传输]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109306146</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109306146</guid><author>qq_38197844</author><pubDate>Tue, 27 Oct 2020 10:41:07 +0800</pubDate><description><![CDATA[1. 应⽤数据被分割成 TCP 认为最适合发送的数据块。 

2. TCP 给发送的每⼀个包进⾏编号，接收⽅对数据包进⾏排序，把有序数据传送给应⽤层。 

3. 校验和： TCP 将保持它⾸部和数据的检验和。这是⼀个端到端的检验和，⽬的是检测数据在传 

输过程中的任何变化。如果收到段的检验和有差错，TCP 将丢弃这个报⽂段和不确认收到此报⽂ 

段。 

4. TCP 的接收端会丢弃重复的数据。 

5. 流量控制： TCP 连接的每⼀⽅都有固定⼤⼩的缓冲空间，TCP的接收端只允许发送端发送接收端 

缓]]></description><category></category></item><item><title><![CDATA[Spring事务]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109293662</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109293662</guid><author>qq_38197844</author><pubDate>Mon, 26 Oct 2020 17:18:37 +0800</pubDate><description><![CDATA[Spring 管理事务的⽅式有⼏种？ 

1. 编程式事务，在代码中硬编码。(不推荐使⽤) 

2. 声明式事务，在配置⽂件中配置（推荐使用）


声明式事务⼜分为两种： 

1. 基于XML的声明式事务 

2. 基于注解的声明式事务


Spring 事务中哪⼏种事务传播⾏为?

⽀持当前事务的情况：


1. TransactionDefinition.PROPAGATION_REQUIRED： 如果当前存在事务，则加⼊该事务；如果当前没有事务，则创建⼀个新的事务。 

2. Transaction.]]></description><category></category></item><item><title><![CDATA[Spring框架中用到了哪些设计模式？]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109293325</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109293325</guid><author>qq_38197844</author><pubDate>Mon, 26 Oct 2020 17:07:22 +0800</pubDate><description><![CDATA[1. IOC和DI设计模式。

2. 工厂设计模式：Spring使用工厂模式通过BeanFactory和ApplicationContext创建bean对象。

3. 单例设计模式：Spring中的Bean对象默认都是单例的。

4. 代理设计模式：AOP是基于动态代理实现的。

5. 适配器模式：SpringAOP的增强/通知（Advice）以及SpringMVC中的Controller都用到了适配器模式
...]]></description><category></category></item><item><title><![CDATA[Spring bean]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109292932</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109292932</guid><author>qq_38197844</author><pubDate>Mon, 26 Oct 2020 16:51:04 +0800</pubDate><description><![CDATA[SpringBean的作用域：

singleton（默认）：为单例模式，唯一的bean实例，当为这个的时候，spring中的对象只创建一次，即外界调用多少次这个对象，都是同一个对象。

prototype：多例模式，每次请求都会创建一个新的bean实例对象，actionBean一定要使用prototype多例，其他基本全是默认singleton。

Spring 中的单例 bean 的线程安全问题了解吗？

单例 bean 存在线程问题，主要是因为当多个线程操作同⼀个对象的时候，对这个对象的⾮静态成员变量]]></description><category></category></item><item><title><![CDATA[Spring AOP和Aspect AOP有什么区别？]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109287043</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109287043</guid><author>qq_38197844</author><pubDate>Mon, 26 Oct 2020 11:50:00 +0800</pubDate><description><![CDATA[1. Spring AOP属于运行时的增强，而Aspect AOP属于编译时的增强。SpringAOP是基于代理（Proxying），而AspectAOP是基于字节码操作。

2. 如果切面比较少，两者差不多，如果切面太多，最好使用AspectAOP，它比SpringAOP快很多。
...]]></description><category></category></item><item><title><![CDATA[谈谈对SpringIOC和AOP的理解]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109286800</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109286800</guid><author>qq_38197844</author><pubDate>Mon, 26 Oct 2020 11:45:44 +0800</pubDate><description><![CDATA[IOC：控制反转，是一种设计思想，将原本在程序中需要手动创建的对象交给spring框架来管理。（本来对象A需要对象B，需要用对象A来创建对象B，而现在，反转了，对象的创建全部由spring框架来完成，A需要对象B，不需要自己创建，由spring在特定的时候提供给A所需要的对象B，这就是IOC，控制反转，即把自己创建对象反转成交个程序帮忙创建对象。）IOC是由依赖注入实现的（DI），很大程度上简化了应用的开发。

AOP：面向切面编程，就是将那些公共的部分封装起来，减少代码的冗余，降低模块耦合度。AOP是基于]]></description><category></category></item><item><title><![CDATA[滑动窗⼝和流量控制]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109188673</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109188673</guid><author>qq_38197844</author><pubDate>Tue, 20 Oct 2020 20:25:37 +0800</pubDate><description><![CDATA[TCP利用滑动窗口实现流量控制。流量控制是为了控制发送方发送速率。接收方发送的确认报文中的窗口字段可以控制发送方窗口大小，从而影响发送方的发送速率。将窗口字段设置为0，则发送方不能发送数据。
...]]></description><category></category></item><item><title><![CDATA[四次挥手为什么客户端最后还要等待2MSL？]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109187488</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109187488</guid><author>qq_38197844</author><pubDate>Tue, 20 Oct 2020 19:38:15 +0800</pubDate><description><![CDATA[MSL就是指最大的报文生存时间。

第一，保证客户端发送的最后一个ACK报文能够到达服务器，因为这个ACK报文可能丢失，站在服务器的角度看我已经发送了FIN+ACK报文请求断开了，客户端还没有给我回应，应该是我发送的请求断开报文它没有收到，于是服务器重新发了一次，客户端就能在这2MSL时间段内收到重传的报文，接着给出回应报文，并且会重启2MSL计时器。

第二，客户端发送完最后一个确认报文后，在这个2MSL时间中，就可以使本连接持续的时间内所产生的所有报文段都从网络中消失，这样新的连接中不会出现旧链接的请求]]></description><category></category></item><item><title><![CDATA[堆内存中对象分配的基本策略？]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109168488</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109168488</guid><author>qq_38197844</author><pubDate>Mon, 19 Oct 2020 20:36:43 +0800</pubDate><description><![CDATA[堆空间的基本结构：



上图所示的eden区、s0区、s1区都属于新生代，tentired区属于老年代。对象会先在eden区域分配，在一次新生代垃圾回收之后，如果对象还存活，会进入s0和s1区域，并且对象的年龄还会加一，当对象年龄增加到一定程度，就会晋升到老年代中。大对象和长期存活的对象会直接进入老年代。
...]]></description><category></category></item><item><title><![CDATA[sleep（）和wait（）的区别和共同点]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109131330</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109131330</guid><author>qq_38197844</author><pubDate>Sat, 17 Oct 2020 12:29:55 +0800</pubDate><description><![CDATA[区别：

1. sleep方法没有释放锁，但是wait释放了锁

2. wait（）被调用后不会自动苏醒，需要别的线程调用同一对象的notify（）/notifyAll（）方法；而sleep（）执行后会自动苏醒。

3. wait（）通常用于线程之间的通信，而sleep（）一般是用于暂停。

共同点：两者都可以暂停线程的执行
...]]></description><category></category></item><item><title><![CDATA[什么是线程死锁？如何避免死锁？]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109131207</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109131207</guid><author>qq_38197844</author><pubDate>Sat, 17 Oct 2020 12:25:50 +0800</pubDate><description><![CDATA[线程死锁：多个线程同时被阻塞，他们中的一个或者全部在等待某个资源被释放，由于线程被无限期的阻塞，因此程序不可能正常终止。产生死锁必须具备的四个条件：

1.互斥条件：该资源任意时刻只由一个线程占用。

2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。

3. 不剥夺条件：线程已获得的资源在未使用完之前不能被其他线程强行剥夺，只有自己使用完之后才释放资源。

4. 循环等待条件：若干个进程之间形成一种头尾相接的循环等待资源关系。

如何避免线程死锁（破坏其中一个条件即可）：

1. ]]></description><category></category></item><item><title><![CDATA[表级锁和行级锁的对比]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109129644</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109129644</guid><author>qq_38197844</author><pubDate>Sat, 17 Oct 2020 10:27:13 +0800</pubDate><description><![CDATA[MyISAM采用表级锁，InnoDB支持行级锁和表级锁，一般默认是行级锁。

表级锁：MySQL中锁定粒度最大的一种锁，对当前操作的整张表加锁，实现简单，资源消耗也少，加锁快，不会出现死锁。但是锁定粒度大，触发锁冲突的概率最高，并发度低。

行级锁：MySQL中锁定粒度最小的一种锁，只针对当前操作的行进行加锁。行级锁能大大减少数据库操作的冲突。加锁的开销也大，加锁慢，会出现死锁。加锁粒度最小，并发度高。
...]]></description><category></category></item><item><title><![CDATA[事务隔离级别有哪些？MySQL的默认隔离级别是？]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109100535</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109100535</guid><author>qq_38197844</author><pubDate>Thu, 15 Oct 2020 16:58:13 +0800</pubDate><description><![CDATA[SQL标准定义了四个隔离级别：

READ-UNCOMMITTED(读未提交)：最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读。

READ-COMMITTED(读已提交)：允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读和不可重复读仍有可能发生。

REPEATABLE-READ(可重复读)：对同一字段的多次读取结果都是一致的，除非数据是被本身事务所修改，可以阻止脏读和不可重复读，但是幻读仍有可能发生。

SERIALIZABLE(可串行化)：最高的隔离级别，完全服从A]]></description><category></category></item><item><title><![CDATA[并发事务带来哪些问题？]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109062077</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109062077</guid><author>qq_38197844</author><pubDate>Tue, 13 Oct 2020 22:42:55 +0800</pubDate><description><![CDATA[多个事务并发运行，经常会通过操作相同的数据来完成各自的任务（多个用户对同一数据进行操作），并发虽然是必须的，但是会导致以下的问题。

1. 脏读：当一个事务正在访问数据并且对数据进行了修改，而这种修改还没有提交到数据库中，这时另一个事务也访问了这个数据，然后使用了这个数据。因为这个数据是还没有提交的数据，那么另一个事务读到的这个数据是“脏数据”，依据“脏数据”做的操作是不正确的。

2. 不可重复读：指在一个事务内多次读同一数据。在这个事务还没有结束的时，另一个事务也访问该数据。那么，在第一个事务中的两次读]]></description><category></category></item><item><title><![CDATA[事务的四个特性]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109060335</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109060335</guid><author>qq_38197844</author><pubDate>Tue, 13 Oct 2020 20:46:35 +0800</pubDate><description><![CDATA[ACID

1. 原子性：事务是最小的执行单位，不可分割，事务的原子性确保动作要么全部完成，要么完全不起作用。

2. 一致性：事务执行前后，数据保持一致，多个事务对同一个数据读取的结果是相同的。

3. 隔离性：并发访问数据库时，一个用户的事务不被其他事务干扰，各并发事务之间数据库相互独立的。

4. 持久性：一个事务被提交后，它对数据库中数据的改变是持久的。


...]]></description><category></category></item><item><title><![CDATA[什么是事务]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109060245</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109060245</guid><author>qq_38197844</author><pubDate>Tue, 13 Oct 2020 20:35:48 +0800</pubDate><description><![CDATA[事务是逻辑上的一种操作，要么都执行，要么都不执行。举个例子就是：A给B转账1000块，A余额减少1000，B账户增加1000，如果银行系统崩溃，A减少了但是B没有增加，这就不对了，事务保证这两个操作要么同时成功，要么同时失败。
...]]></description><category></category></item><item><title><![CDATA[MyISAM和InnoDB的区别]]></title><link>https://blog.youkuaiyun.com/qq_38197844/article/details/109059547</link><guid>https://blog.youkuaiyun.com/qq_38197844/article/details/109059547</guid><author>qq_38197844</author><pubDate>Tue, 13 Oct 2020 20:24:04 +0800</pubDate><description><![CDATA[5.5版本以前，MyISAM是MySQL的默认数据库引擎，虽然性能极佳，而且提供了大量的特性，但是MyISAM不支持事务和行级锁，最大的缺陷是崩溃后无法安全恢复；5.5版本以后，MySQL引入了InnoDB（事务性数据库引擎），而且默认存储引擎为InnoDB。大多数情况下我们使用的是InnoDB，但是某些情况下使用MyISAM也是比较合适的，比如读密集的情况下。

两者对比：

1. 是否支持行级锁：MyISAM只有表级锁，而InnoDB支持行级锁和表级锁，默认为行级锁。

2. 是否支持事务和崩溃后的安全]]></description><category></category></item></channel></rss>