diff --git a/second/week_01/74/HashMap.txt b/second/week_01/74/HashMap.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/second/week_01/74/LinkedList.txt b/second/week_01/74/LinkedList.txt
index 34779205104d49e81c8e34ac3a08f2f441f0a049..201dd8ba8b81f4e08aabe6218fd4e7b1f1e2f438 100644
--- a/second/week_01/74/LinkedList.txt
+++ b/second/week_01/74/LinkedList.txt
@@ -5,6 +5,8 @@ JAVA源码学习 - java.util.LinkedList
    取：效率低，需遍历（大部分情况）
    增删：效率高，删除元素=null，改变前后元素链表标记。
 
+  Node<E> first：队列第一个元素
+  Node<E> last：队列 最后一个元素
 
   内部类Node：private static class Node<E> {
       E item;
@@ -18,13 +20,19 @@ JAVA源码学习 - java.util.LinkedList
       }
   }
 
+  继承接口Deque(双向链表)：
+    表的头尾进行操作，*First,*Last *=add(添加)，*=remove(删除，链表为空抛异常)，*=poll(链表为空返回null)，*=get(取，链表为空时抛出异常)，*=peek(取，链表为空返回null)
+    boolean remove(Object o)：移除指定的元素  boolean contains(Object o)：是否包含指定的元素  Iterator<E> iterator()：获得迭代器
+
+  extends Queue(单项链表)：
+
 
 
 2.算法
   E unlink(Node<E> x)：从链表中删除x
   void linkLast(E e)：在e元素后边添加
   void linkBefore(E e)：在e元素前边添加
-
+  *Node<E> node(int index)：二分查找
 
   重要方法：
 
diff --git a/second/week_02/74/AtomicInteger.txt b/second/week_02/74/AtomicInteger.txt
new file mode 100644
index 0000000000000000000000000000000000000000..eaacf0aaac3c17bfea8be968ee6d8f45a4259f77
--- /dev/null
+++ b/second/week_02/74/AtomicInteger.txt
@@ -0,0 +1,20 @@
+AtomicInteger、AtomicStampedReference、LongAdder
+
+AtomicInteger：
+
+volatile关键字：保证变量再线程间可见，对volatile变量所有得写操作都能立即反应到其他线程中。
+        保证工作内存（线程）中对主内存变量操作assign,store,write这三个操作时原子的
+        volatile修饰的是修改后及时写回主存，对其他线程可见可理解为其他线程能知道自己缓存中的变量是过期的
+
+阻塞同步：多线程访问共享数据时i，保证共享数据在同一时刻只被一个或一些进程使用
+非阻塞同步：利用CAS，保证操作原子性，atoicInteger的方法主要用到cas
+
+有序性：JVM主内存和工作内存的交互，lock,unlock,read,load(主内存read值放到工作内存变量副本),use,assign,store,write
+    由于cpu的乱序执行方式能保持当前线程计算结果正确性，但无法保证线程间的可见性。如果保证线程对主内存变量的交互为上面
+    顺序严格执行，则可实现线程间的可见。
+
+原子性：原子性性质为不可拆分，i++的动作亦包含上述交互的所有步骤，所有不是原子的，即有可能发生脏读等现象
+
+主要方法：
+   AtomicInteger.incrementAndGet()：非阻塞，无限循环 next = current + 1，通过CAS判断是否被其他线程修改，直到成功
+    更多方法原理基于Unsafe
diff --git a/second/week_02/74/Unsafe.puml b/second/week_02/74/Unsafe.puml
new file mode 100644
index 0000000000000000000000000000000000000000..5117b8704b724cd5d29cc49a7341103ee7e6cb75
--- /dev/null
+++ b/second/week_02/74/Unsafe.puml
@@ -0,0 +1,6 @@
+@startuml
+
+
+title unsafe 学习
+
+@enduml
\ No newline at end of file
diff --git a/second/week_02/74/Unsafe.txt b/second/week_02/74/Unsafe.txt
new file mode 100644
index 0000000000000000000000000000000000000000..acd1fe99cd2aff3b606ffead5608ff141d6c354a
--- /dev/null
+++ b/second/week_02/74/Unsafe.txt
@@ -0,0 +1,41 @@
+Unsafe：提供操作内存的方法
+
+扩展：
+反射：
+类加载器（网友总结合并）：根据类的二进制名（binary name）读取java编译器编译好的字节码文件,并将class文件加载到jvm中。
+        注意的是，jvm是动态加载需要的类。
+        Bootstrap ClassLoader：顶层加载器，加载核心类库
+        Extention ClassLoader：扩展类加载器， JAVA_HOME\lib\ext下jar包和class
+        Appclass Loader：SystemAppClass加载当前应用下所有classs
+
+
+
+根据getUnsage创建对象会判断当前加载器类型是否为Bootstrap ClassLoader,一般测试创建用反射：
+
+1.读写一个对象的属性，即便是私有的
+public native Object getObject(Object var1, long var2);
+public native void putObject(Object var1, long var2, Object var4);
+
+2.内存地址上读写
+public native int getInt(Object var1, long var2);  该对象指定的内存位置开始读取一个byte
+public native void putInt(Object var1, long var2, int var4);
+
+3.volatile读写，保证线程间可见性，有序性  Volatile
+
+4.有序写入，不保证可见性  Ordered
+
+5.内存操作
+ public native long allocateMemory(long var1); 分配内存
+ public native long reallocateMemory(long var1, long var3); 重新分配内存
+ public native void setMemory(Object var1, long var2, long var4, byte var6); 设置内存
+ public native void copyMemory(Object var1, long var2, Object var4, long var5, long var7); 复制内存
+ public native void freeMemory(long var1); 清除内存
+
+6.CAS
+ public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
+ public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
+ public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
+
+7.线程调度
+
+8.类加载
\ No newline at end of file