Java 提供了很多同步工具，最近看Java锁的时候，看到了 CountDownLatch 和 Semaphore，同时了解到还有 CyclicBarrier，就想对它们做一个一定的了解。

CountDownLatch

CountDownLatch 是在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。使用一个计数器进行实践，计数器初始值为线程的数量。每当一个线程完成后，计数器的值就会减一。当计数器的值为0时，便是所有线程都完成了任务，然后等待的线程就可以恢复执行任务了。

用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 CyclicBarrier。

初始化

1

CountDownLatch countDownLatch = new CountDownLatch(1);

CountDownLatch 是一次性的，计数值在构建的时候就已经初始化完成了。

await

提供两种方法是当前线程处于等待状态

1
2
3
4
5
6
7

public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}
public boolean await(long timeout, TimeUnit unit)
    throws InterruptedException {
    return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}

声明：如果本文有错误，希望指出。

在之前的一篇博文中简单介绍了 Java 中的一些锁：Java 中各种锁。
最近在极客时间上买了杨晓峰的《Java核心技术36讲》，今天看到关于标题的东西，于是想记录下自己的学习。
Synchronized 和 ReentrantLock 这两个都是可重入锁，指的是同一线程在外层函数获取锁之后，内层函数仍然可以获取该锁，且不受影响。

Synchronized 可重入测试源码

Synchronized 锁的原理

1
2
3
4
5
6
7
8
9
10
11
12

public class SynchronizedTest {

    public synchronized void doSth() {
        System.out.println("doSth");
    }

    public void method() {
        synchronized (SynchronizedTest.class) {
            System.out.println("method");
        }
    }
}

使用javac SynchronizedTest.java 和 javap -c -s -v -l SynchronizedTest 命令查看编译后的Test.class的字节码，可以很容易看出在代码块上和方法上是有区别的。代码块上使用 monitorenter/monitorexit 指令来实现的；方法上是使用 ACC_SYNCHRONIZED。详情看下面的图片，是编译后的字节码：

在 Java6 之前，Monitor 的实现完全是依靠操作系统内部的互斥锁，因为需要用户状态到内核状态的切换，所有同步操作是一个重量级操作。

Synchronized 底层原理，Synchronized 有2个队列 waitSet 和 entrtyList。

• 当多个线程进入同步代码块时，首先进入entryList
• 有一个线程获取到monitor锁后，就赋值给当前线程，并且计数器+1
• 如果线程调用wait方法，将释放锁，当前线程置为null，计数器-1，同时进入waitSet等待被唤醒，调用notify或者notifyAll之后又会进入entryList竞争锁
• 如果线程执行完毕，同样释放锁，计数器-1，当前线程置为null

如果有误，欢迎批评指正。友情提示，本文有点长。
SpringBoot 版本 2.0.5.RELEASE。

在学习 SpringBoot 时，会在启动项里面看到在类名上面有一个注解 @SpringBootApplication。前几天在一个公众号中看到关于一道面试题，题目类似于：知道 @SpringBootApplication 的原理吗？

突然发现自己对于 SpringBoot 还是处在‘知其然而不知所以然’的状态。于是就去官网和网上查看一些资料，于是有了这篇文章。

SpringBoot 启动项

1
2
3
4
5
6
7

@SpringBootApplication
public class ApplicationStartup {

    public static void main(String[] args) {
        SpringApplication.run(ApplicationStartup.class, args);
    }
}

@SpringBootApplication

看下 @SpringBootApplication 注解的详情

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
    //...
}

从注解的源码中可以看到它被 @SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan 等注解修饰。

@SpringBootConfiguration

如果有错，希望指出

动态代理在Java中有着广泛的应用，比如 Spring Aop、Hibernate 数据查询、RPC、Java 注解对象的获取。静态代理的代理关系在编译时确定，而动态代理的代理关系是在编译期确定的。主要了解：JDK Proxy 和 cglib 动态代理。

动态代理可以提供另一个对象的访问，同时可以隐藏实际对象的具体实例。

静态代理

再说动态代理之前，先了解下静态代理。

静态代理是代理模式实现方式之一，在程序运行前，由程序员创建或者特定工具自动生成源代码并对其编译生成 .class 文件。静态代理的实现需要三步：

• 定义业务接口
• 实现业务接口
• 定义代理类并实现业务接口

最后就可以直接通过客户顿进行调用静态代理了。

如果有问题，希望指出

Reflection（反射）是 Java 被视为动态语言的关键，反射机制允许程序在执行期借用 Reflection API 获取任何内部信息，并能操作任何对象的内部属性级方法。

Java 反射机制主要提供一下功能：

• 在运行时构造任意一个类的对象
• 在运行时获取任意一个类所具有的成员变量和方法
• 在运行时调用任意一个对象的方法
• 生成动态代理

Java 反射提供三种获取 Class 对象的方法：

1
2
3
4
5
6
7
8

Person person = new Person(1L, "反射");
//1、通过对象名
Class personClass = person.getClass();
//2、通过类名
Class baseClass = Person.class;
//3、通过全类名
Class baseClass2 = Class.forName("com.example.basejava.basics.reflect.Person");

Class 是一个类，一个描述类的类。它封装了描述方法的 Method，描述字段的 Filed，描述构造器的 Constructor 等属性。

代码

Person 类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

public class Person implements Serializable {

    private Long id;
    private String name;

    static {
        System.out.println("测试反射静态代码块");
    }

    Person(Person person) {
        System.out.println("(默认)反射测试类构造了" + person);
    }

    public Person() {
        System.out.println("调用了公有、无参构造方法执行了。。。");
    }

    Person(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    Person(String name) {
        this.name = name;
        System.out.println("name+" + name);
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

如果本文有错，希望在下面的留言区指正。

在之前的一篇文章中，写了一篇 Spring 事务管理。

本地事务管理主要考虑的是单台服务器上面的事务回滚。那么，如果在分布式服务之间如何管理事务呢？

如上图所示的分布式调用，客户端 client 调用服务A，而服务A 除了本身的对数据库的修改，还需要调用服务B和服务C。如果在调用服务B成功后在调用服务C，但是这时候服务C出错了，这时候如何解决事务的回滚？

CAP

CAP 理论是分布式系统的一个基础理论，描述任何一个分布式系统最多只能满足下面三种特性中的两个：

• 一致性（Consistency）：对某个指定的客户端来说，读操作保证能够返回最新的写操作结果。
• 可用性（Availability）：非故障的节点在合理的时间内返回合理的响应（不是错误和超时的响应）。
• 分区容忍性（Partition tolerance）：当出现网络分区后，系统能够继续“履行职责”。

CAP 的选择

虽然 CAP 理论定义是三个要素中只能取两个，但放到分布式环境下来思考，对于一个分布式系统而言，分区容错性可以说是一个最基本的要求。分布式系统的组件必然是需要部署到不同节点，否则也就无所谓分布式系统了，因此必然出现子网络。而对于分布式系统而言，网络问题有时一个必定会出现的异常情况，因此分区容错性也就成为一个分布式系统必然需要面对和解决的问题了。

• 深入理解虚拟机 —— Java内存区域
• 深入理解虚拟机 —— 垃圾收集器

类被加载到虚拟机的内存中开始，到卸载出内存为止，它的整个生命周期包括：加载、验证、准备、解析、初始化、使用和卸载。

类加载的过程

加载

在加载阶段，需要完成以下3件事情：

• 通过一个类的全限定名来获取定义此类的二进制字节流
• 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
• 在内存中生成一个代表这个类的 java.lang.Class 对象，作为方法区这个类的各种数据的访问入口。

加载阶段结束后，Java 虚拟机外部的二进制字节流就按照虚拟机所设定的格式存储在方法区之中，方法区中的数据存储格式完全由虚拟机实现自行定义。

验证

验证是连接阶段的第一步，这一阶段的目的是为了确保 Class 文件的字节流包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。

声明：本文使用JDK1.8，如果有错希望指出

在Java面试的时候，HashMap 和 Hashtable 经常被问，就想仔细分析下两者。

Java集合框架 —— HashMap

HashMap 和 Hashtable 的区别

HashMap 和 Hashtable 都是实现 Map 接口，两者主要的区别是线程安全性，同步，以及速度。

因此仅在需要线程安全的时候使用Hashtable，而如果Java5以上，还是使用 ConcurrentHashMap。

Java并发容器 ——— ConcurrentHashMap。

源码分析

声明：本文使用JDK1.8，如果有错希望指出

本文将简单介绍 JAVA 集合框架——TreeMap。TreeMap 集合是基于红黑树的 NavigableMap 实现。该集合最重要的特性就是可排序，该映射可以根据 Map 的键的自然顺序排序，或者根据创建时提供的 Comparator 进行排序，具体取决于使用的构造方法。

TreeMap 继承关系

源码分析

数据结构

TreeMap采用红黑树的数据结构来实现。树节点Entry实现了Map.Entry，采用内部类的方式实现:

1
2
3
4
5
6
7

static final class Entry<K,V> implements Map.Entry<K,V> {
    K key;
    V value;
    Entry<K,V> left;
    Entry<K,V> right;
    Entry<K,V> parent;
    boolean color = BLACK;

接下来看下 TreeMap 中支持红黑树的数据成员：

1
2
3
4
5
6
7
8
9
10
11

public class TreeMap<K,V>
    extends AbstractMap<K,V>
    implements NavigableMap<K,V>, Cloneable, java.io.Serializable{
    //用于接收自定义比较器，插入时用于比对元素的大小
    private final Comparator<? super K> comparator;
    //红黑树的根节点
    private transient Entry<K,V> root;
    //树中元素个数
    private transient int size = 0;
    //
    private transient int modCount = 0;

欢迎指正。

最近打算重温一下排序算法。

插入排序

原理

插入排序主要是通过构建有序序列，对未排列的数据，从后往前扫描，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。

代码

1
2
3
4
5
6
7
8
9
10
11
12

public static void InsertSort(int[] array) {

    for (int i = 1; i < array.length; i++) {
        int j = i;
        int target = array[i];
        while (j > 0 && target < array[j - 1]) {
            array[j] = array[j - 1];
            j--;
        }
        array[j] = target;
    }
}

选择排序

原理

第一次从下标为0的开始下标为0的这个数与后面的n-1个进行比较；找出最小或者最大的放在下标为0的这个位置。