提交

.gitignore

@@ -7,4 +7,3 @@ public/
 .deploy*/
 _multiconfig.yml
 package-lock.json
-yarn.lock

README.md

@@ -0,0 +1,6 @@
+# 小达的个人博客源码项目
+
+使用`Hexo`框架+`Butterfly`主题构建
+
+## 
+

source/_posts/CSS.md

@@ -0,0 +1 @@
+​	

source/_posts/Java.md

@@ -33,3 +33,236 @@ spring:
 
 ### 替换Mybatis为Mybatis-Plus
 
+# Java SE
+
+## 注解
+
+### 注解语法
+
+同class和interface一样，注解也属于一种类型。
+
+### 注解定义
+
+注解通过@interface关键字进行定义。
+
+```java
+@TestAnnotation
+public class Test {
+    
+}
+```
+
+创建一个类Test，然后在类定义的地方加上@TestAnnotation就可以用TestAnnotation注解这个类了。
+
+可以简单理解为将 TestAnnotation这张标签贴到 Test这个类上面。
+
+要想注解能够正常工作，还有一个元注解
+
+### 元注解
+
+元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其他的注解上面。
+
+元注解也是一张标签，但是它是一张特殊的标签，它的作用和目的就是给其他普通的标签进行解释说明的。
+
+元标签有 @Retention、@Documented、@Target、@Inherited、@Repeatable 5种
+
+#### @Retention
+
+Retention的英文意为保留期的意思。当@Retention应用到一个注解上的时候，它解释说明了这个注解的存活时间。
+
+它的取值如下：
+
+- RetentionPolicy.SOURCE 注解只在源码阶段保留，在编译器进行编译时它将被丢弃忽视。
+- RetentionPolicy.CLASS 注解只被保留到编译进行的时候，它不会被加载到JVM中。
+- RetentionPolicy.RUNTIME 注解可以保留到程序运行的时候，它会被加载进入到JVM中，所以在程序运行时可以获取到它们。
+
+@Retention 去给一张标签解释的时候，它指定了这张标签张贴的时间。@Retention 相当于给一张标签上面盖了一张时间戳，时间戳指明了标签张贴的时间周期。
+
+```java
+@Retention(RetentionPolicy.RUNTIME)
+public @interface TestAnnotation {
+    
+}
+```
+
+指定 TestAnnotation 可以在程序运行周期被获取到，因此它的生命周期非常长。
+
+#### @Documented
+
+这个元注解和文档有关。它的作用是能够将注解中的元素包含到JavaDoc中去
+
+#### @Target
+
+Target 是目标的意思，@Target 制定了注解运用的地方。
+
+当一个注解被 @Target 注解时，这个注解就被限定了运用的场景。
+
+类比到标签，原本标签想张贴到哪个地方就到哪个地方，但是因为 @Target 的存在，它张贴的地方就非常具体了，比如只能张贴到方法上、类上、方法参数上等等。@Target 有下面的取值
+
+- ElementType.ANNOTATION_TYPE 可以给一个注解进行注解
+- ElementType.CONSTRUCTUR 可以给构造方法进行注解
+- ElementType.FIELD 可以给属性进行注解
+- ElementType.LOCAL_VARIABLE 可以给局部变量进行注解
+- ElementType.METHOD 可以给方法进行注解
+- ElementType.PACKAGE 可以给一个包进行注解
+- ElementType.TYPE 可以给一个类型进行注解，比如类、接口、枚举
+
+#### @Inherited
+
+Inherited 是继承的意思，但是它并不是说注解本身可以继承，而是说如果一个超类被 @Inherited 注解过的注解进行注解的话，那么如果它的子类没有被任何注解应用的话，那么这个子类就继承了超类的注释。
+
+```java
+@Inherited
+@Retention(RetentionPolicy.RUNTIME)
+@interface Test {}
+@Test
+public class A {}
+public class B extends A {}
+```
+
+注解 Test 被 @Inherited 修饰，之后类A 被 Test 注解，类 B 基础 A，类B 也拥有 Test 这个注解。
+
+可以这样理解：
+
+老子非常有钱，所以人们给他贴了一张标签叫做富豪。
+
+老子的儿子长大后，只要没有和老子断绝父子关系，虽然别人没有给他贴标签，但是他自然也是富豪。
+
+老子的孙子长大了，自然也是富豪。
+
+这就是人们口中戏称的富一代，富二代，富三代。虽然叫法不同，好像好多个标签，但其实事情的本质也就是他们有一张共同的标签，也就是老子身上的那张富豪的标签。
+
+#### @Repeatable
+
+Repeatable 自然是可重复的意思。@Repeatable 是Java 1.8 才加进来的，所以算是一个新的特性。
+
+什么样的注解或被多次运用呢？通常是注解的值可以同时取多个。
+
+举个例子，一个人他既是程序员又是产品经理，同时他还是个画家。
+
+```java
+@interface Persons {
+    Person[] value();
+}
+@Repeatable(Persons.class)
+@interface Person {
+    String role default "";
+}
+@Person(role="artist")
+@Person(role="coder")
+@Person(role="PM")
+public class SuperMan {
+}
+```
+
+@Repeatable 注解了Persion。而@Repeatable 后面括号中的类相当于一个容器注解。
+
+什么是容器注解呢？就是用来存放其他注解的地方。它本身是一个注解。
+
+相关容器注解
+
+```java
+@interface Persons {
+    Person[] value();
+}
+```
+
+按照规定，它里面必须要有一个 value 的属性，属性类型是一个被 @Repeatable 注解过的注解数组，注意它是数组。
+
+Persons 是一张总的标签，上面贴满了Person这种同类型但内容不一样的标签。把Persons 给一个 SuperMan 贴上，相当于同时给他贴了程序员、产品经理、画家的标签。
+
+我们可能对于 @Person(role="PM")括号里面的内容感兴趣，它其实就是给 Person 这个注解的 role 属性赋值为 PM
+
+### 注解的属性
+
+注解的属性也叫做成员变量。注解只要成员变量，没有方法。注解的成员变量在注解的定义中“无形参方法”形式来声明，其方法名定义了该成员变量的名字，其返回值定义了该成员变量的类型。
+
+```java
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface TestAnnotation {
+    int id();
+    String msg();
+}
+```
+
+上面代码定义了 TestAnnotation 这个注解拥有 id 和 msg 两个属性。在使用的时候，我们应该给它们进行赋值。
+
+赋值的方式是在注解的括号内以 value="" 形式，多个属性之前用 , 隔开。
+
+```java
+@TestAnnotation(id=3, msg="hello annotation")
+public class Test {
+}
+```
+
+## 多线程
+
+### 线程安全
+
+#### 概念
+
+线程安全是多线程编程的一个概念。在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且准确的执行，不会出现数据污染等意外情况。上述是百度百科给出的一个概念解释。换言之，线程安全就是某个函数在并发环境中调用时，能够处理好多个线程之间的共享变量，是程序能够正确执行完毕。也就是说我们想要确保在多线程访问的时候，我们的程序还能够按照我们预期的行为去执行，那么就是线程安全了。
+
+#### 导致线程不安全的原因
+
+首先，可以来看一段代码，来看看是不是线程安全的，代码如下：
+
+```java
+package com.company;
+
+public class TestThread {
+
+    private static class XRunnable implements Runnable{
+        private int count;
+        public void run(){
+            for(int i= 0; i<5; i++){
+                getCount();
+            }
+        }
+
+        public void getCount(){
+            count++;
+            System.out.println(" "+count);
+        }
+    }
+
+    public static void main(String[] args) {
+        XRunnable runnable = new XRunnable();
+        Thread t1 = new Thread(runnable);
+        Thread t2 = new Thread(runnable);
+        Thread t3 = new Thread(runnable);
+        t1.start();
+        t2.start();
+        t3.start();
+    }
+}
+```
+
+输出的结果为：
+
+```java
+2
+3
+2
+5
+4
+7
+6
+10
+11
+12
+9
+8
+13
+14
+15
+```
+
+从代码上进行分析，当启动了三个线程，每个线程应该都是循环5次得出1到15的结果，但是从输出的结果，就可以看到有两个2的输出，出现像这种情况表明这个方法根本就不是线程安全的。我们可以这样理解：在每个进程的内存空间中都会有一块特殊的公共区域，通常称为**堆(内存)**,之所以会输出两个2，是因为每个进程的所有线程都可以访问到该区域，当第一个线程已经获得2这个数了，还没来得及输出，下一个线程在这段时间的空隙获得了2这个值，故输出时会输出2的值。
+
+#### 线程安全问题
+
+要考虑线程安全问题，就需要先考虑Java并发的三大基本特征：**原子性**、**可见性**以及**有序性**
+
+- 原子性