<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[sinat_34620530的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/sinat_34620530</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; sinat_34620530]]></copyright><item><title><![CDATA[浅谈Callable与Future]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/109511649</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/109511649</guid><author>sinat_34620530</author><pubDate>Thu, 05 Nov 2020 18:18:18 +0800</pubDate><description><![CDATA[Callable
java5引入java.util.concurrent包，其中包含了locks包、atomic包、线程池（Executors）、阻塞队列（BlockingQueue）、Callable、Future等相关多线程解决方案。
Callable的出现解决Runable没有返回值，无法抛出异常的问题。同时先线程池Executors 提供了许多方法，可以操控 Callable 在线程池中运行。
Future
Executors 执行 Callable 时会返回一个 Future 对象。使用 Futu]]></description><category></category></item><item><title><![CDATA[Java的引用机制]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/109363026</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/109363026</guid><author>sinat_34620530</author><pubDate>Thu, 29 Oct 2020 16:25:50 +0800</pubDate><description><![CDATA[java引用机制
对于Java中这几种引用的理解，有助于理解JVM的回收内存的机制。先说下在JVM执行垃圾回收时，如何处理它们所引用的对象：

1）强引用，任何时候都不会被垃圾回收器回收，如果内存不足，宁愿抛出OutOfMemoryError。
2）软引用，只有在内存将满的时候才会被垃圾回收器回收，如果还有可用内存，垃圾回收器不会回收。
3）弱引用，只要垃圾回收器运行，就肯定会被回收，不管还有没有可用内存。
4）虚引用，虚引用等于没有引用，任何时候都有可能被垃圾回收。



强引用（Strong Refer]]></description><category></category></item><item><title><![CDATA[SpringBoot Bean加载优先级问题]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/109356091</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/109356091</guid><author>sinat_34620530</author><pubDate>Thu, 29 Oct 2020 14:31:14 +0800</pubDate><description><![CDATA[spring容器载入bean顺序是不确定的，spring框架没有约定特定顺序逻辑规范。但spring保证如果A依赖B(如beanA中有@Autowired B的变量)，那么B将先于A被加载。

同一个类中加载顺序

Constructor &gt;&gt; @Autowired &gt;&gt;@ PostConstruct&gt;&gt;@Bean

@DependsOn控制顺序

如果A不依赖B，但是A需要在B后面初始化，可以使用@DependsOn（value=“Bbeanname”）。B的@Bea.]]></description><category></category></item><item><title><![CDATA[IDEA 快捷键mac版]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/109072291</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/109072291</guid><author>sinat_34620530</author><pubDate>Wed, 14 Oct 2020 14:23:45 +0800</pubDate><description><![CDATA[打开设置	command+,
代开项目结构 command+;
查找			command+F
全局查找		command+shift+F
全局替换		command+shift+R
查找方法引用 	option+F7
格式化 		command+option+L
下一个错误	F2
上一个错误	shift+F2
下一行		shift+回车
自定义方法块	command+option+T
单元测试类	shift+command+T
优化Import	control+shift+O
调试
下一步		F8
进入方法]]></description><category></category></item><item><title><![CDATA[http的理解]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/108507849</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/108507849</guid><author>sinat_34620530</author><pubDate>Thu, 10 Sep 2020 09:52:18 +0800</pubDate><description><![CDATA[http的三个特点：
1.http协议是无状态的
就是说每次HTTP请求都是独立的，任何两个请求之间没有什么必然的联系。但是在实际应用当中并不是完全这样的，引入了Cookie和Session机制来关联请求。
2.多次http请求
在客户端请求网页时多数情况下并不是一次请求就能成功的，服务端首先是响应HTML页面，然后浏览器收到响应之后发现HTML页面还引用了其他的资源，例如，CSS，JS文件，图片等等，还会自动发送HTTP请求这些需要的资源。现在的HTTP版本支持管道机制，可以同时请求和响应多个请求，大大提]]></description><category></category></item><item><title><![CDATA[SpringAOP的实现]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/108454308</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/108454308</guid><author>sinat_34620530</author><pubDate>Mon, 07 Sep 2020 19:28:18 +0800</pubDate><description><![CDATA[AOP 代理其实是由 AOP 框架动态生成的一个对象，该对象可作为目标对象使用。AOP 代理包含了目标对象的全部方法，但 AOP 代理中的方法与目标对象的方法存在差异：AOP 方法在特定切入点添加了增强处理，并回调了目标对象的方法。
Spring 的 AOP 代理由 Spring 的 IoC 容器负责生成、管理，其依赖关系也由 IoC 容器负责管理。因此，AOP 代理可以直接使用容器中的其他 Bean 实例作为目标，这种关系可由 IoC 容器的依赖注入提供。
Spring提供了两种方式来生成代理对象: JD]]></description><category></category></item><item><title><![CDATA[在静态方法和非静态方法上加 Synchronized的区别]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/108454261</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/108454261</guid><author>sinat_34620530</author><pubDate>Mon, 07 Sep 2020 19:25:56 +0800</pubDate><description><![CDATA[Synchronzied 修饰非静态方法==》对象锁
Synchronzied 修饰静态方法==》其实是类锁，因为是静态方法，它把整个类锁起来了；
情况1：同一个对象在两个线程中分别访问该对象的两个同步方法
结果：会产生互斥。
解释：因为锁针对的是对象，当对象调用一个synchronized方法时，其他同步方法需要等待其执行结束并释放锁后才能执行。
情况2：不同对象在两个线程中调用同一个同步方法
结果：不会产生互斥。
解释：因为是两个对象，锁针对的是对象，并不是方法，所以可以并发执行，不会互斥。形象的来说就]]></description><category></category></item><item><title><![CDATA[Spring事务传播行为]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/108454168</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/108454168</guid><author>sinat_34620530</author><pubDate>Mon, 07 Sep 2020 19:20:43 +0800</pubDate><description><![CDATA[所谓事务传播机制，也就是在事务在多个方法的调用中是如何传递的，是重新创建事务还是使用父方法的事务？父方法的回滚对子方法的事务是否有影响？这些都是可以通过事务传播机制来决定的。

事务的传播行为，默认值为 Propagation.REQUIRED。可以手动指定其他的事务传播行为，如下：
Propagation.REQUIRED
如果当前存在事务，则加入该事务，如果当前不存在事务，则创建一个新的事务。
Propagation.SUPPORTS
如果当前存在事务，则加入该事务；如果当前不存在事务，则以非事务的方式]]></description><category></category></item><item><title><![CDATA[线程的生命周期]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/108454107</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/108454107</guid><author>sinat_34620530</author><pubDate>Mon, 07 Sep 2020 19:16:49 +0800</pubDate><description><![CDATA[线程的生命周期包含5个阶段，包括：新建、就绪、运行、阻塞、销毁。

新建：就是刚使用new方法，new出来的线程；
就绪：就是调用的线程的start()方法后，这时候线程处于等待CPU分配资源阶段，谁先抢的CPU资源，谁开始执行;
运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run方法定义了线程的操作和功能;
阻塞：在运行状态的时候，可能因为某些原因导致运行状态的线程变成了阻塞状态，比如sleep()、wait()之后线程就处于了阻塞状态，这个时候需要其他机制将处于阻塞状态的线程唤醒，比如调]]></description><category></category></item><item><title><![CDATA[数据库隔离级别]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/108454043</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/108454043</guid><author>sinat_34620530</author><pubDate>Mon, 07 Sep 2020 19:14:32 +0800</pubDate><description><![CDATA[多用户并发操作可能会发生的问题
1. 脏读
脏读是指一个事务读取了未提交事务执行过程中的数据。
2. 不可重复读
不可重复读是指对于数据库中的某个数据，一个事务执行过程中多次查询返回不同查询结果，这就是在事务执行过程中，数据被其他事务提交修改了。
不可重复读同脏读的区别在于，脏读是一个事务读取了另一未完成的事务执行过程中的数据，而不可重复读是一个事务执行过程中，另一事务提交并修改了当前事务正在读取的数据。
3. 虚读(幻读)
幻读是事务非独立执行时发生的一种现象，例如事务T1批量对一个表中某一列列值为1的数]]></description><category></category></item><item><title><![CDATA[乐观锁与悲观锁]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/108454009</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/108454009</guid><author>sinat_34620530</author><pubDate>Mon, 07 Sep 2020 19:11:33 +0800</pubDate><description><![CDATA[悲观锁：每次访问数据线程都是处于阻塞的状态，这样提高安全性，像读锁，写锁都是用到了悲观锁，以及synchronize关键字（独占锁）；
缺点：

可能会导致优先级高的线程等待优先级低的线程导致优先级倒序；
加锁，放锁次数过多，引起性能问题

乐观锁：每次访问数据线程都是运行状态，这样可以提高数据吞吐量。就假定不会发生并发冲突，最后通过比较数据来查看是否真的发生了冲突，并交由用户来决定。最典型的实现方式是CAS（compare and swap）
像乐观锁适用于写比较少的情况下（多读场景），即冲突真的很少发生]]></description><category></category></item><item><title><![CDATA[java为什么是单继承]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/108453965</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/108453965</guid><author>sinat_34620530</author><pubDate>Mon, 07 Sep 2020 19:09:16 +0800</pubDate><description><![CDATA[    Java是从C++语言上优化而来，而C++也是面向对象的， c++是多继承，经常出问题。
    假设说Java是可以多继承的，比方说，我现在有一个A类，我又编写了两个类B类和C类，并且B类和C类分别继承了A类，并且对A类的同一个方法进行了重写。接下来，我再写了一个D类，并且D类以多继承的方式同时集成了B类和C类，那么D类也会继承B类和C类从A类中重写的方法，那么问题来了，D类也开始犯迷糊了，我到底应该哪个继承哪个类中的方法呢，因为类是结构性的，这样就会造成结构上的混乱。这就是多继承的菱形继承问题。]]></description><category></category></item><item><title><![CDATA[java内存泄漏的原因]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/108453934</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/108453934</guid><author>sinat_34620530</author><pubDate>Mon, 07 Sep 2020 19:07:24 +0800</pubDate><description><![CDATA[静态集合类
各种连接，如数据库连接、网络连接和IO连接等
变量不合理的作用域：一般而言，一个变量的定义的作用范围大于其使用范围，很有可能会造成内存泄漏。另一方面，如果没有及时地把对象设置为null，很有可能导致内存泄漏的发生。
内部类持有外部类：
改变哈希值
缓存泄漏
监听器和回调
内存泄漏八种原因总结


...]]></description><category></category></item><item><title><![CDATA[微服务架构的特点和适用场景]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/108453893</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/108453893</guid><author>sinat_34620530</author><pubDate>Mon, 07 Sep 2020 19:05:12 +0800</pubDate><description><![CDATA[微服务的特点：

单一职责原则：每个服务应该负责单独的功能，正是SOLID原则之一。
独立部署、升级、扩展和替换：每个服务都可以单独部署及重新部署而不影响整个系统。这使得服务很容易升级。
支持异构/多种语言：每个服务的实现细节都与其他服务无关，这使得服务之间能够解耦，团队可以针对每个服务选择最合适的开发语言、工具和方法。
轻量级：微服务通常有轻量级的分布式服务框架承载，采用了P2P通信，无中心节点，性能可以线性增长；第三方软件依赖减少，减少类冲突和冗余依赖，集成和升级更方便。

微服务使用场景：

团队规模]]></description><category></category></item><item><title><![CDATA[Springcloud 主要组件]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/108453866</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/108453866</guid><author>sinat_34620530</author><pubDate>Mon, 07 Sep 2020 19:03:14 +0800</pubDate><description><![CDATA[Eureka：注册中心
   Eureka就好比是一个公司的后台，负责管理、记录服务提供者的信息。我们只要将我们的微服务注册到Eureka中去，我们的服务调用者在调用微服务的时候，就无需自己寻找服务，而是把自己的需求告诉Eureka，然后Eureka会把符合你需求的服务告诉你，从而完成微服务的调用。
Eureka架构中的三个核心角色：
①服务注册中心
Eureka的服务端应用，提供服务注册和发现功能，就是刚刚我们建立的eureka-demo
②服务提供者
提供服务的应用，可以是SpringBoot应用，..]]></description><category></category></item><item><title><![CDATA[阻塞队列]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/108326076</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/108326076</guid><author>sinat_34620530</author><pubDate>Mon, 31 Aug 2020 20:44:03 +0800</pubDate><description><![CDATA[什么是阻塞队列？
java.util.concurrent
public interface BlockingQueue extends Queue
阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是：在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。




方法\处理方式]]></description><category></category></item><item><title><![CDATA[CountDownLatch]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/108328309</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/108328309</guid><author>sinat_34620530</author><pubDate>Mon, 31 Aug 2020 20:01:45 +0800</pubDate><description><![CDATA[简单易懂的文章

]]></description><category></category></item><item><title><![CDATA[JAVA线程池ExecutorService]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/108324995</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/108324995</guid><author>sinat_34620530</author><pubDate>Mon, 31 Aug 2020 17:33:24 +0800</pubDate><description><![CDATA[线程池的优势

降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗；
提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创建便能立即执行；
方便线程并发数的管控。因为线程若是无限制的创建，可能会导致内存占用过多而产生OOM，并且会造成cpu过度切换（cpu切换线程是有时间成本的（需要保持当前执行线程的现场，并恢复要执行线程的现场））。
提供更强大的功能，延时定时线程池。

线程池主要参数
public ThreadPoolExecutor(int corePoolSi]]></description><category></category></item><item><title><![CDATA[WeakHashMap]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/108290838</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/108290838</guid><author>sinat_34620530</author><pubDate>Sat, 29 Aug 2020 10:08:31 +0800</pubDate><description><![CDATA[java引用机制
对于Java中这几种引用的理解，有助于理解JVM的回收内存的机制。先说下在JVM执行垃圾回收时，如何处理它们所引用的对象：

1）强引用，任何时候都不会被垃圾回收器回收，如果内存不足，宁愿抛出OutOfMemoryError。
2）软引用，只有在内存将满的时候才会被垃圾回收器回收，如果还有可用内存，垃圾回收器不会回收。
3）弱引用，只要垃圾回收器运行，就肯定会被回收，不管还有没有可用内存。
4）虚引用，虚引用等于没有引用，任何时候都有可能被垃圾回收。



强引用（Strong Refer]]></description><category></category></item><item><title><![CDATA[JAVA面试题2020]]></title><link>https://blog.youkuaiyun.com/sinat_34620530/article/details/107951670</link><guid>https://blog.youkuaiyun.com/sinat_34620530/article/details/107951670</guid><author>sinat_34620530</author><pubDate>Wed, 12 Aug 2020 10:32:25 +0800</pubDate><description><![CDATA[Springcloud 主要组件
请分别说明适合使用容器和虚拟机的场景
请描述微服务架构的特点和适用场景
清楚描述常见的23种java设计模式（中的三种）
请说明CMS或G1垃圾回收器的特点和优化思路
描述HDFS客户端向服务器端写入文件的过程
当节点故障时，HBase节点如何保证数据不丢失
Web开发考虑哪几个方面的安全问题
请说明关系数据库几种事务等级的级别
Linux系统通过应用的端口获取应用的内存和cpu使用情况
为保证关系型数据库的性能，需要在数据库结构设计时考虑哪些因素
举例3种java并发集.]]></description><category></category></item></channel></rss>