<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[qq_35387404的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/qq_35387404</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; qq_35387404]]></copyright><item><title><![CDATA[HashMap 1.8 源码分析]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/120030119</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/120030119</guid><author>qq_35387404</author><pubDate>Wed, 01 Sep 2021 00:28:38 +0800</pubDate><description><![CDATA[HashMap 1.8 源码分析
一、红黑树
一、性质：


每个结点不是红色就是黑色


不可能有连在一起的红色结点


根结点都是黑色


叶子结点的(NIL)，一定是黑色


任意一个结点到其叶子结点的(NIL)的路径上黑色结点数相同



二、HashMap JDK 1.8源码分析
一、简介

2、存储流程

3、基础参数
 /** 
   * 主要参数 同  JDK 1.7 
   * 即：容量、加载因子、扩容阈值（要求、范围均相同）
   */

  // 1. 容量（capacity）： 必须]]></description><category></category></item><item><title><![CDATA[设计模式 之 建造者模式]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/120008454</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/120008454</guid><author>qq_35387404</author><pubDate>Tue, 31 Aug 2021 00:33:04 +0800</pubDate><description><![CDATA[建造者模式
盖房项目需求


需要建房子：这一过程为打桩、砌墙、封顶


房子有各种各样的，比如普通房，高楼，别墅，各种房子的过程虽然一样，但是要求不要相同的.


通过以上需求，我们可以采用如下方式进行设计
抽象房子House
public abstract class AbstractHouse {
	private String baise;
	private String wall;
	private String roofed;

	public void setBaise(String bais]]></description><category></category></item><item><title><![CDATA[设计模式 之 原型模式]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/119992435</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/119992435</guid><author>qq_35387404</author><pubDate>Mon, 30 Aug 2021 10:50:06 +0800</pubDate><description><![CDATA[原型设计
介绍：

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。
当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

下面，我们通过业务需求来讲解原型设计，需求如下：
现在有一只羊tom，姓名为: ]]></description><category></category></item><item><title><![CDATA[设计模式 之 工厂模式]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/119966417</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/119966417</guid><author>qq_35387404</author><pubDate>Sat, 28 Aug 2021 12:12:32 +0800</pubDate><description><![CDATA[工厂模式
首先来看传统的设计模式
现在有一个需求：生产 小米手机
手机接口
//手机接口
public interface Phone {
    void make();
}

小米手机类
//小米手机类
public class MiPhone implements Phone {
    public MiPhone() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-ge]]></description><category></category></item><item><title><![CDATA[设计模式 之 单例模式]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/119947769</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/119947769</guid><author>qq_35387404</author><pubDate>Fri, 27 Aug 2021 10:38:35 +0800</pubDate><description><![CDATA[单例模式
定义：

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。
例如：比如Hibernate的SessionFactory，它充当数据存储源的代理，并负责创建Session对象。SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就够，这是就会使用到单例模式。

单例模式有八种方式：加粗表示推荐使用（饿汉式虽然可能造成内存浪费，但是不存在线程安全问题）]]></description><category></category></item><item><title><![CDATA[线程安全集合类概述]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/119942228</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/119942228</guid><author>qq_35387404</author><pubDate>Thu, 26 Aug 2021 22:50:48 +0800</pubDate><description><![CDATA[线程安全集合类概述



遗留的安全集合：

Hashtable
Vector



修饰的安全集合：使用 Collections 装饰的线程安全集合

Collections.synchronizedCollection
Collections.synchronizedList
Collections.synchronizedMap
Collections.synchronizedSet
Collections.synchronizedNavigableMap
Collections.synchroniz]]></description><category></category></item><item><title><![CDATA[CyclicBarrier]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/119941906</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/119941906</guid><author>qq_35387404</author><pubDate>Thu, 26 Aug 2021 22:31:01 +0800</pubDate><description><![CDATA[CyclicBarrier
定义 ：

​		循环栅栏，用来进行线程协作，等待线程满足某个计数。构造时设置『计数个数』，每个线程执行到某个需要“同步”的时刻调用 await() 方法进行等待，当等待的线程数满足『计数个数』时，继续执行

CyclicBarrier cb = new CyclicBarrier(2); // 个数为2时才会继续执行
new Thread(()-&gt;{
         System.out.println("线程1开始.."+new Date());
         t]]></description><category></category></item><item><title><![CDATA[CountDownLatch]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/119941445</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/119941445</guid><author>qq_35387404</author><pubDate>Thu, 26 Aug 2021 22:04:54 +0800</pubDate><description><![CDATA[CountDownLatch
作用：

允许一个或多个线程等待其他线程完成操作

构造：

​        CountDownLatch的构造函数接收一个int类型的参数作为计数器，如果你想等待N个点完
成，这里就传入N。

使用：

​        当我们调用CountDownLatch的countDown方法时，N就会减1，CountDownLatch的await方法
会阻塞当前线程，直到N变成零。由于countDown方法可以用在任何地方，所以这里说的N个
点，可以是N个线程，也可以是1个线程里的]]></description><category></category></item><item><title><![CDATA[数据结构小记]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/119939454</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/119939454</guid><author>qq_35387404</author><pubDate>Thu, 26 Aug 2021 20:14:59 +0800</pubDate><description><![CDATA[数据结构
数组

固定长度

一旦申请完毕 长度固定


索引从0开始
连续

无论从逻辑上
还是物理上都是连续


随机存取

指的是数组的可以通过下标索引直接方位对应元素



链表

由节点组成
在物理上可以不连续
删除 插入 是很快的
双向链表 和 单项链表
不具备随机存取

单链表成环
单链表反转



栈

先进后出

队列

先进先出

双栈实现一个队列
package CeShi;

import java.util.Stack;

/**
 * @author muzi
 * @descr]]></description><category></category></item><item><title><![CDATA[1、HashMap put 一个元素会引起什么]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/119939428</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/119939428</guid><author>qq_35387404</author><pubDate>Thu, 26 Aug 2021 20:12:33 +0800</pubDate><description><![CDATA[1、HashMap put 一个元素会引起什么
JDK1.7中：创建HashMap时并不为table数组初始化（即创建时table是空数组），在第一次进行put操作的时候，才会进行初始化
过程分为如下几个阶段：


table初始化：第一次进入put方法，如果table = {} (即数组还没有初始化)，那么进行初始化操作


key判NULL：如果key为null，那么调用putForNullKey(value)方法，找到遍历table[0]寻找key = null，替换value值，如果找不到，就在该桶]]></description><category></category></item><item><title><![CDATA[StampedLock]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/119939414</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/119939414</guid><author>qq_35387404</author><pubDate>Thu, 26 Aug 2021 20:11:55 +0800</pubDate><description><![CDATA[StampedLock

优点

戳 stamp
校验戳
乐观读


缺点

不支持条件变量
不支持重入


应用

限流
资源数与线程数相同的时候（数据库连接池）


原理

acquire：执行try方法 执行一次 state–；如果state = 0，下一次再try就会阻塞放入阻塞队列；
release：执行tryrelease方法将state++；如果成功 调用doreleaseShared方法唤醒阻塞结点，如果try成功，从阻塞队列取出，同时唤醒后继share结点，但是如果后继结点try失败，还是]]></description><category></category></item><item><title><![CDATA[ReentrantReadWriteLock读写锁]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/119939403</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/119939403</guid><author>qq_35387404</author><pubDate>Thu, 26 Aug 2021 20:11:21 +0800</pubDate><description><![CDATA[ReentrantReadWriteLock读写锁

使用

读-读不互斥
读-写，写-读，写-写都互斥


注意事项

读锁不支持条件变量
重入时锁升级不支持（读锁后加写锁）
重入时锁降级支持（写锁后加读锁）


应用缓存

问题分析

HashMap线程不安全
多线程同时读取操作，任然会多次读取数据库
多线程修改数据库时，可能会造成脏数据（要先修改数据库，再清空缓存）但是仍然会有可能出现脏数据，但是再读一次就是正确的数据了


实现

使用读写锁
给写的方法添加写锁
给读的方法在读取的时候添加读锁，在查]]></description><category></category></item><item><title><![CDATA[Java：手把手带你源码分析HashMap 1.7]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/119803873</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/119803873</guid><author>qq_35387404</author><pubDate>Fri, 20 Aug 2021 22:16:42 +0800</pubDate><description><![CDATA[HashMap源码分析JDK1.71、简介2、数据结构2.1  具体描述2.2  示意图2.3  存储流程2.4  数组元素 &amp; 链表结点的 实现类3、基础知识：HashMap中的重要参数（变量）5、源码分析步骤1：HashMap类构造函数步骤2：向HashMap添加数据（成对 放入 键 - 值对）分析1：初始化哈希表分析2：当 key ==null时，将该 key-value 的存储位置规定为数组table 中的第1个位置，即table [0]分析3：计算存放数组 table 中的位置（即 数组下]]></description><category></category></item><item><title><![CDATA[为什么需要两个幸存区]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/119788432</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/119788432</guid><author>qq_35387404</author><pubDate>Wed, 18 Aug 2021 21:03:29 +0800</pubDate><description><![CDATA[JVM堆新生代幸存区为什么需要幸存区?为什么一个幸存区不行？两个幸存区是如何工作的？
为什么需要幸存区?
先不去想为什么有两个Survivor区，第一个问题是，设置Survivor区的意义在哪里？

首先：如果没有Survivor（幸存区），Eden区每进行一次Minor GC，存活的对象就会被送到老年代。其次：随着Minor GC的次数增加，老年代很快被填满，触发Major GC（因为Major GC一般伴随着Minor GC，也可以看做触发了Full GC）。最终：由于老年代的内存空间远大于新生代，进行]]></description><category></category></item><item><title><![CDATA[JVM四种引用]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/119745143</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/119745143</guid><author>qq_35387404</author><pubDate>Tue, 17 Aug 2021 00:24:48 +0800</pubDate><description><![CDATA[JVM四种引用概述详解一、强引用（Strong Reference）二、软引用（Soft Reference）三、弱引用（Weak Reference）四、虚引用（Phantom Reference）

引言


在 JDK1.2 版之后，Java 对引用的概念进行了扩充，将引用分为：
强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）、虚引用（Phantom Reference）这 4 种引用强度依次逐渐减弱。
除强引用外，其他 3 ]]></description><category></category></item><item><title><![CDATA[final finally finalize 区别及用法]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/119741850</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/119741850</guid><author>qq_35387404</author><pubDate>Mon, 16 Aug 2021 21:12:57 +0800</pubDate><description><![CDATA[final finally finalize 区别及用法区别一、性质不同二、作用三、简单区别四、中等区别五、详细区别
区别
一、性质不同
1、final为关键字
2、finalize()为方法
3、finally为区块标志，用于try-catch-finally语句
二、作用
（1）final为用于标识常量的关键字，final标识的关键字存储在常量池中（在这里final常量的具体用法将在下面进行介绍）；
（2）finalize()方法在Object中进行了定义，用于在对象“消失”时，由JVM进行调用用于对对]]></description><category></category></item><item><title><![CDATA[大白话详谈Java代理]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/119683716</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/119683716</guid><author>qq_35387404</author><pubDate>Fri, 13 Aug 2021 22:17:19 +0800</pubDate><description><![CDATA[大白话谈Java代理引言一、静态代理1、目标接口2、目标类3、代理类4、执行结果二、动态代理1、JDK动态代理代理类执行结果2、CGLIB动态代理代理类执行结果三、Spring Aop 代理探究1、切面类2、目标接口3、目标类4、xml文件5、CGLIB动态代理执行结果6、JDK动态代理执行结果
引言
代理是什么？为什么要使用代理
代理模式（Proxy）是通过代理对象访问目标对象，这样可以在目标对象基础上增强额外的功能，如添加权限，访问控制和审计等功能。
相当于现在有一个目标类和一些目标方法，但是规定了你不]]></description><category></category></item><item><title><![CDATA[大白话谈Java反射]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/119683168</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/119683168</guid><author>qq_35387404</author><pubDate>Fri, 13 Aug 2021 20:37:09 +0800</pubDate><description><![CDATA[大白话谈Java反射一、正射二、反射三、常用反射API1、通过反射获取Class对象2、通过反射创建类对象3、通过反射获取类属性、方法、构造器
一、正射
反射之中包含了一个「反」字，所以想要解释反射就必须先从「正」开始解释。
一般情况下，我们使用某个类时必定知道它是什么类，是用来做什么的。于是我们直接对这个类进行实例化，之后使用这个类对象进行操作。
	A a = new A();
    a.setA("muzi");

上面这样子进行类对象的初始化，我们可以理解为「正」。
二、反射
而反射则是一开始并不知]]></description><category></category></item><item><title><![CDATA[Java类加载的顺序]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/119655918</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/119655918</guid><author>qq_35387404</author><pubDate>Thu, 12 Aug 2021 23:25:12 +0800</pubDate><description><![CDATA[Java类加载的顺序
类加载优于类实例化对象

类加载：程序从上到下，加载静态的初始化语句，初始化块和构造方法
类创建对象：程序从上到下，加载非静态的初始化语句，初始化块和构造方法


类初始化变量初始值

类初始化变量的默认值如下：

	byte、short、int ：0

    long ：0L

    float ：0.0f

    double ：0.0d

	char ：空字符（即：/u0000）

	boolean ：false

	引用类型 ：null


代码示例
public cla]]></description><category></category></item><item><title><![CDATA[“equals“和“==“的区别]]></title><link>https://blog.youkuaiyun.com/qq_35387404/article/details/119654925</link><guid>https://blog.youkuaiyun.com/qq_35387404/article/details/119654925</guid><author>qq_35387404</author><pubDate>Thu, 12 Aug 2021 22:46:38 +0800</pubDate><description><![CDATA["equals"和"=="的区别为什么说重写equals方法就要重写hashCode方法

Object类 equals方法实际是调用的 "=="方法，即比较Object对象的hashCode值

public boolean equals(Object obj) {
        return (this == obj);
    }


如果是基本数据类型，那么"=="比较的就是值，如果是引用类型，那么引用类型的对象内存放的值实际上是引用的地址，所以比较的就是地址


所以在定义一个类的时候，如果需要]]></description><category></category></item></channel></rss>