1.Java的List如何实现线程安全？
2.Linux 内核 rcu(顺序) 锁实现原理与源码解析
3.HashMap和Hashtable的区别
4.用好这个IDEA插件，的的源写代码效率至少提升5倍！源码
5.Linux内核RCU实现简析
6.Lock的await/singal 和 Object的wait/notify 的区别

Java的List如何实现线程安全？

       Java的List如何实现线程安全？

       Collections.synchronizedList(names);效率最高，线程安全

       Java的List是我们平时很常用的集合，线程安全对于高并发的场景也十分的重要，那么List如何才能实现线程安全呢 ？

       åŠ é”

       é¦–先大家会想到用Vector，这里我们就不讨论了，首先讨论的是加锁，例如下面的代码

       public class Synchronized{

       private List<String>  names = new LinkedList<>();

       public synchronized void addName(String name ){

       names.add("abc");

       }

       public String getName(Integer index){

       Lock lock =new ReentrantLock();

       lock.lock();

       try {

       return names.get(index);

       }catch (Exception e){

       e.printStackTrace();

       }

       finally {

       lock.unlock();

       }

       return null;

       }

       }

       synchronized一加，或者使用lock 可以实现线程安全，但是这样的List要是很多个，代码量会大大增加。

       java自带类

       åœ¨java中我找到自带有两种方法

       CopyOnWriteArrayList

       CopyOnWrite 写入时复制，它使一个List同步的替代品，通常情况下提供了更好的并发性，并且避免了再迭代时候对容器的加锁和复制。通常更适合用于迭代，在多插入的情况下由于多次的复制性能会一定的下降。

       ä¸‹é¢æ˜¯add方法的源代码

          public boolean add(E e) {

       final ReentrantLock lock = this.lock; // 加锁 只允许获得锁的线程访问

       lock.lock();

       try {

       Object[] elements = getArray();

       int len = elements.length;

       // 创建个长度加1的数组并复制过去

       Object[] newElements = Arrays.copyOf(elements, len + 1);

       newElements[len] = e; // 赋值

       setArray(newElements); // 设置内部的数组

       return true;

       } finally {

       lock.unlock();

       }

       }

       Collections.synchronizedList

       Collections中有许多这个系列的方法例如

       ä¸»è¦æ˜¯åˆ©ç”¨äº†è£…饰者模式对传入的集合进行调用 Collotions中有内部类SynchronizedList

         static class SynchronizedList<E>

       extends SynchronizedCollection<E>

       implements List<E> {

       private static final long serialVersionUID = -L;

       final List<E> list;

       SynchronizedList(List<E> list) {

       super(list);

       this.list = list;

       }

       public E get(int index) {

       synchronized (mutex) { return list.get(index);}

       }

       public E set(int index, E element) {

       synchronized (mutex) { return list.set(index, element);}

       }

       public void add(int index, E element) {

       synchronized (mutex) { list.add(index, element);}

       }

       public E remove(int index) {

       synchronized (mutex) { return list.remove(index);}

       }

       static class SynchronizedCollection<E> implements Collection<E>, Serializable {

       private static final long serialVersionUID = L;

       final Collection<E> c;  // Backing Collection

       final Object mutex;     // Object on which to synchronize

       è¿™é‡Œä¸Šé¢çš„mutex就是锁的对象 在构建时候可以指定锁的对象 主要使用synchronize关键字实现线程安全

          /

**

       * @serial include

       */

       static class SynchronizedList<E>

       extends SynchronizedCollection<E>

       implements List<E> {

       private static final long serialVersionUID = -L;

       final List<E> list;

       SynchronizedList(List<E> list) {

       super(list);

       this.list = list;

       }

       SynchronizedList(List<E> list, Object mutex) {

       super(list, mutex);

       this.list = list;

       }

       è¿™é‡Œåªæ˜¯åˆ—举SynchronizedList ，其他类类似，可以看下源码了解下。

       æµ‹è¯•

       public class Main {

       public static void main(String[] args) {

       List<String> names = new LinkedList<>();

       names.add("sub");

       names.add("jobs");

       // 同步方法1 内部使用lock

       long a = System.currentTimeMillis();

       List<String> strings = new CopyOnWriteArrayList<>(names);

       for (int i = 0; i < ; i++) {

       strings.add("param1");

       }

       long b = System.currentTimeMillis();

       // 同步方法2 装饰器模式使用 synchronized

       List<String> synchronizedList = Collections.synchronizedList(names);

       for (int i = 0; i < ; i++) {

       synchronizedList.add("param2");

       }

       long c = System.currentTimeMillis();

       System.out.println("CopyOnWriteArrayList time == "+(b-a));

       System.out.println("Collections.synchronizedList time == "+(c-b));

       }

       }

       ä¸¤è€…内部使用的方法都不一样，CopyOnWriteArrayList内部是使用lock进行加锁解锁完成单线程访问，synchronizedList使用的是synchronize

       è¿›è¡Œäº†æ¬¡æ·»åŠ åŽæ—¶é—´å¯¹æ¯”如下：

       å¯ä»¥çœ‹å‡ºæ¥è¿˜æ˜¯ä½¿ç”¨äº†synchronize的集合工具类在添加方面更加快一些，其他方法这里篇幅关系就不测试了，大家有兴趣去试一下。

Linux 内核 rcu(顺序) 锁实现原理与源码解析

       RCU 的全称是 Read-Copy-Update，代表读取-复制-更新，源码作为 Linux 内核提供的的的源一种免锁机制，它在锁实现方案中独树一帜。源码小程序 查看 源码在面对自旋锁、的的源互斥锁、源码信号量、的的源读写锁、源码req 顺序锁等常规锁结构时，的的源RCU 提供了另一种思路，源码追求在无需阻塞操作的的的源前提下实现高效并发。

       RCU 通过链表操作实现了读写分离。源码在读任务执行时，的的源可以安全地读取链表中的节点。然而，若写任务在此期间修改或删除节点，则可能导致数据不一致问题。因此，RCU 采用先读取后复制、再更新的策略，实现无锁状态下的高效读取。这与 Copy-On-Write 技术相似，先复制一份数据，对副本进行修改，完成后将修改内容覆盖原数据，打赏视频源码ds从而达到高效、无阻塞的操作。

       图中展示了链表操作的细节，每个节点包含数据字段和 next 指针字段。在读任务读取节点 B 时，写任务 N 执行删除操作，导致 next 指针指向错误的节点，从而引发业务异常。此时，若采用互斥锁，则能够保证数据一致性，但系统性能会受到一定程度的影响。读写锁和 seq 锁虽然在一定程度上改善了性能，但仍存在一定的问题，如写者饥饿状态或读者阻塞。

       RCU 的实现旨在避免以上问题，让读任务直接获取锁，无需像 seq 锁那样进行重试，也不像读写锁和互斥锁那样完全阻塞读操作。RCU 通过在读任务完成后再删除节点，实现先修改指针，保留副本，注册回调，等待读任务释放副本，最后删除副本的过程。这种机制使得读任务无需阻塞等待写任务，扎金花源码分析辅助有效提高了系统性能。

       内核源码中，RCU 通过 `rcu_assign_pointer` 修改指针，`synchronize_kernel` 等待所有读任务完成，而读任务则通过 `rcu_read_lock`、`rcu_read_unlock` 和 `rcu_dereference` 来上锁、解锁和获取引用值。这种设计在一定程度上借鉴了垃圾回收机制，通过写者修改引用并保留副本，待所有读任务完成后删除副本，从而实现高效、并发的操作。在 `rcu_read_lock` 中，禁止抢占确保了所有读任务完成后才释放锁，开启抢占，这为读任务提供了宽限期，等待所有任务完成。

       总之，RCU 作为一种创新的锁实现机制，通过链表操作和读写分离策略，为 Linux 内核提供了一种高效、无阻塞的并发控制方式。其源码解析展示了如何通过内核函数实现读取-复制-更新的机制，以及如何通过宽限期确保数据一致性，从而在保证性能的同时，提供了一种优雅的手游平台源码交易并发控制解决方案。

HashMap和Hashtable的区别

       HashMap和Hashtable的比较是Java面试中的常见问题，用来考验程序员是否能够正确使用集合类以及是否可以随机应变使用多种思路解决问题。HashMap的工作原理、ArrayList与Vector的比较以及这个问题是有关Java 集合框架的最经典的问题。Hashtable是个过时的集合类，存在于Java API中很久了。在Java 4中被重写了，实现了Map接口，所以自此以后也成了Java集合框架中的一部分。Hashtable和HashMap在Java面试中相当容易被问到，甚至成为了集合框架面试题中最常被考的问题，所以在参加任何Java面试之前，都不要忘了准备这一题。

        这篇文章中，我们不仅将会看到HashMap和Hashtable的区别，还将看到它们之间的相似之处。

        HashMap和Hashtable都实现了Map接口，但决定用哪一个之前先要弄清楚它们之间的分别。主要的区别有：线程安全性，同步(synchronization)，以及速度。

        由于Hashtable是线程安全的也是synchronized，所以在单线程环境下它比HashMap要慢。如果你不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。

        HashMap不能保证随着时间的推移Map中的元素次序是不变的。

        fail-fast机制在遍历一个集合时，当集合结构被修改，会抛出Concurrent Modification Exception。

        fail-fast会在以下两种情况下抛出ConcurrentModificationException

        集合被创建后，在遍历它的过程中修改了结构。

        注意 remove()方法会让expectModcount和modcount 相等，所以是不会抛出这个异常。

        当一个线程在遍历这个集合，而另一个线程对这个集合的结构进行了修改。

        迭代器在遍历过程中是直接访问内部数据的，因此内部的数据在遍历的过程中无法被修改。为了保证不被修改，迭代器内部维护了一个标记 “mode” ，当集合结构改变（添加删除或者修改），标记"mode"会被修改，而迭代器每次的hasNext()和next()方法都会检查该"mode"是否被改变，当检测到被修改时，抛出Concurrent Modification Exception。

        下面看看ArrayList迭代器部分的源码。

        可以看到它的标记“mode”为 expectedModeCount。

        fail-safe任何对集合结构的修改都会在一个复制的集合上进行修改，因此不会抛出ConcurrentModificationException。

        fail-safe机制有两个问题

        HashMap可以通过下面的语句进行同步：

        Map m = Collections.synchronizeMap(hashMap);

        Hashtable和HashMap有几个主要的不同：线程安全以及速度。仅在你需要完全的线程安全的时候使用Hashtable，而如果你使用Java 5或以上的话，请使用ConcurrentHashMap吧。

用好这个IDEA插件，写代码效率至少提升5倍！

       还在编写无聊枯燥又难以维护的POJO吗？洁癖者的春天在哪里？请看Lombok！

       在过往的Java项目中，充斥着太多不友好的代码：POJO的getter/setter/toString；异常处理；I/O流的关闭操作等等，这些样板代码既没有技术含量，又影响着代码的美观，Lombok应运而生。

       首先说明一下：任何技术的出现都是为了解决某一类问题的，如果在此基础上再建立奇技*巧，不如回归Java本身。应该保持合理使用而不滥用。

       Lombok的使用非常简单，下面我们一起来看下：

       1）引入相应的maven包：

<dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1..</version><scope>provided</scope></dependency>

       Lombok的scope=provided，说明它只在编译阶段生效，不需要打入包中。事实正是如此，Lombok在编译期将带Lombok注解的Java文件正确编译为完整的Class文件。

       2）添加IDE工具对Lombok的支持：

       IDEA中引入Lombok支持如下：

       点击File--Settings设置界面，安装Lombok插件：

       点击File--Settings设置界面，开启AnnocationProcessors：

       开启该项是为了让Lombok注解在编译阶段起到作用。

       Eclipse的Lombok插件安装可以自行百度，也比较简单，值得一提的是，由于Eclipse内置的编译器不是Oraclejavac，而是vscode源码开发环境配置eclipse自己实现的EclipseCompilerforJava(ECJ).要让ECJ支持Lombok，需要在eclipse.ini配置文件中添加如下两项内容：

       -Xbootclasspath/a:[lombok.jar所在路径]

       -javaagent:[lombok.jar所在路径]

       3）Lombok实现原理：

       自从Java6起，javac就支持“JSRPluggableAnnotationProcessingAPI”规范，只要程序实现了该API，就能在javac运行的时候得到调用。

       Lombok就是一个实现了"JSRAPI"的程序。在使用javac的过程中，它产生作用的具体流程如下：

       javac对源代码进行分析，生成一棵抽象语法树(AST)

       javac编译过程中调用实现了JSR的Lombok程序

       此时Lombok就对第一步骤得到的AST进行处理，找到Lombok注解所在类对应的语法树(AST)，然后修改该语法树(AST)，增加Lombok注解定义的相应树节点

       javac使用修改后的抽象语法树(AST)生成字节码文件

       4)Lombok注解的使用：

       POJO类常用注解：

       @Getter/@Setter:作用类上，生成所有成员变量的getter/setter方法；作用于成员变量上，生成该成员变量的getter/setter方法。可以设定访问权限及是否懒加载等。

packagecom.trace;importlombok.AccessLevel;importlombok.Getter;importlombok.Setter;/***CreatedbyTraceon/5/.<br/>*DESC:测试类*/@SuppressWarnings("unused")publicclassTestClass{ publicstaticvoidmain(String[]args){ }@Getter(value=AccessLevel.PUBLIC)@Setter(value=AccessLevel.PUBLIC)publicstaticclassPerson{ privateStringname;privateintage;privatebooleanfriendly;}publicstaticclassAnimal{ privateStringname;privateintage;@Getter@Setterprivatebooleanfunny;}}

       在Structure视图中，可以看到已经生成了getter/setter等方法：

       编译后的代码如下：[这也是传统Java编程需要编写的样板代码]

////Sourcecoderecreatedfroma.classfilebyIntelliJIDEA//(poweredbyFernflowerdecompiler)//packagecom.trace;publicclassTestClass{ publicTestClass(){ }publicstaticvoidmain(String[]args){ }publicstaticclassAnimal{ privateStringname;privateintage;privatebooleanfunny;publicAnimal(){ }publicbooleanisFunny(){ returnthis.funny;}publicvoidsetFunny(booleanfunny){ this.funny=funny;}}publicstaticclassPerson{ privateStringname;privateintage;privatebooleanfriendly;publicPerson(){ }publicStringgetName(){ returnthis.name;}publicintgetAge(){ returnthis.age;}publicbooleanisFriendly(){ returnthis.friendly;}publicvoidsetName(Stringname){ this.name=name;}publicvoidsetAge(intage){ this.age=age;}publicvoidsetFriendly(booleanfriendly){ this.friendly=friendly;}}}

       @ToString：作用于类，覆盖默认的toString()方法，可以通过of属性限定显示某些字段，通过exclude属性排除某些字段。

       @EqualsAndHashCode：作用于类，覆盖默认的equals和hashCode

       @NonNull：主要作用于成员变量和参数中，标识不能为空，否则抛出空指针异常。

       @NoArgsConstructor,@RequiredArgsConstructor,@AllArgsConstructor：作用于类上，用于生成构造函数。有staticName、access等属性。

       staticName属性一旦设定，将采用静态方法的方式生成实例，access属性可以限定访问权限。

       @NoArgsConstructor：生成无参构造器；

       @RequiredArgsConstructor：生成包含final和@NonNull注解的成员变量的构造器；

       @AllArgsConstructor：生成全参构造器。

       编译后结果：

publicstaticclassPerson{ @NonNullprivateStringname;privateintage;privatebooleanfriendly;publicStringtoString(){ return"TestClass.Person(name="+this.getName()+",age="+this.getAge()+")";}@NonNullpublicStringgetName(){ returnthis.name;}publicintgetAge(){ returnthis.age;}publicbooleanisFriendly(){ returnthis.friendly;}publicvoidsetName(@NonNullStringname){ if(name==null){ thrownewNullPointerException("name");}else{ this.name=name;}}publicvoidsetAge(intage){ this.age=age;}publicvoidsetFriendly(booleanfriendly){ this.friendly=friendly;}privatePerson(){ }privatestaticTestClass.Personof(){ returnnewTestClass.Person();}@ConstructorProperties({ "name"})Person(@NonNullStringname){ if(name==null){ thrownewNullPointerException("name");}else{ this.name=name;}}@ConstructorProperties({ "name","age","friendly"})publicPerson(@NonNullStringname,intage,booleanfriendly){ if(name==null){ thrownewNullPointerException("name");}else{ this.name=name;this.age=age;this.friendly=friendly;}}}

       @Data：作用于类上，是以下注解的集合：@ToString@EqualsAndHashCode@Getter@Setter@RequiredArgsConstructor

       @Builder：作用于类上，将类转变为建造者模式

       @Log：作用于类上，生成日志变量。针对不同的日志实现产品，有不同的注解：

       其他重要注解：

       @Cleanup：自动关闭资源，针对实现了java.io.Closeable接口的对象有效，如：典型的IO流对象

       编译后结果如下：

       是不是简洁了太多。

       @SneakyThrows：可以对受检异常进行捕捉并抛出，可以改写上述的main方法如下：

       @Synchronized：作用于方法级别，可以替换synchronize关键字或lock锁，用处不大。

       作者：LiWenD正在掘金

Linux内核RCU实现简析

       RCU，即Read-Copy-Update，是一种并发控制技术，旨在解决并发读写时的读阻塞问题。其核心思想是当写线程进行操作时，不直接修改原数据，而是先复制数据，进行修改后，等待读线程的访问结束，再替换原数据，从而避免阻塞读线程。

       引入了Quiescent State和Quiescent Period的概念。Quiescent State表示线程没有访问数据的静止状态，Quiescent Period是等待时间窗口，确保在此窗口内没有线程访问旧数据，以便释放资源。

       在Linux内核中，RCU接口丰富多样，适用于不同场景和子系统，包括rcu_read_lock/unlock、call_rcu、synchronize_rcu等。其中，call_rcu用于写线程注册回调函数，等待Quiescent Period结束后执行，而synchronize_rcu则封装了call_rcu，同步等待Quiescent Period完成。

       Linux内核的RCU实现是作者Paul Mckenney完成和维护的，位于内核源代码的kernel/rcu目录下，详细文档在Documentation/RCU中。内核使用的是树形结构的RCU（tree-RCU），支持多核扩展。

       树形结构中，每个节点为rcu_node，每个CPU对应一个rcu_data，共同维护一个全局的rcu_state变量，记录整个系统RCU状态。RCU的生命周期包括注册Grace Period回调、开始Grace Period、CPU进入Quiescent State、Grace Period完成等阶段。

       在注册Grace Period回调时，回调函数被放入本CPU的rcu_data中。Grace Period开始时，内核线程rcu_gp_kthread被唤醒，执行一系列初始化操作，包括设置系统中所有CPU的Quiescent State。CPU进入Quiescent State后，内核线程rcu_cpu_kthread检查并上报Quiescent State，直到所有CPU都完成上报，表明系统整体进入Quiescent State，Grace Period完成。

       当Grace Period完成时，注册的回调函数执行。这发生在每个CPU的rcu_cpu_kthread中，其中内核线程rcu_gp_kthread仅更新了rcu_node的gp_seq，未直接触发回调执行。rcu_cpu_kthread在检查函数rcu_check_quiescent_state中确认Grace Period已完成，通过内部检查判断当前gp序列是否已完成，若已完成，则将所有callback移动到RCU_DONE_TAIL列表上，后续在rcu_do_batch函数中执行每个callback。

Lock的await/singal 和 Object的wait/notify 的区别

       Lock的await/singal 和 Object的wait/notify 的区别

       åœ¨ä½¿ç”¨Lock之前，我们都使用Object 的wait和notify实现同步的。举例来说，一个producer和consumer，consumer发现没有东西了，等待，produer生成东西了，唤醒。

       çº¿ç¨‹consumer 线程producer

        synchronize(obj){

        obj.wait();//没东西了，等待

       } synchronize(obj){

        obj.notify();//有东西了，唤醒

       }

       æœ‰äº†lock后，世道变了，现在是：

       lock.lock();

       condition.await();

       lock.unlock(); lock.lock();

       condition.signal();

       lock.unlock();

       ä¸ºäº†çªå‡ºåŒºåˆ«ï¼Œçœç•¥äº†è‹¥å¹²ç»†èŠ‚。区别有三点：

       1. lock不再用synchronize把同步代码包装起来；

       2. 阻塞需要另外一个对象condition；

       3. 同步和唤醒的对象是condition而不是lock，对应的方法是await和signal，而不是wait和notify。

       ä¸º

       ä»€ä¹ˆéœ€è¦ä½¿ç”¨condition呢？简单一句话，lock更灵活。以前的方式只能有一个等待队列，在实际应用时可能需要多个，比如读和写。为了这个灵活

       æ€§ï¼Œlock将同步互斥控制和等待队列分离开来，互斥保证在某个时刻只有一个线程访问临界区（lock自己完成），等待队列负责保存被阻塞的线程

       ï¼ˆcondition完成）。

       é€šè¿‡æŸ¥çœ‹ReentrantLock的源代码发现，condition其实是等待队列的一个管理者，condition确保阻塞的对象按顺序被唤醒。

       åœ¨Lock的实现中，LockSupport被用来实现线程状态的改变，后续将更进一步研究LockSupport的实现机制。

synchronize底层原理

       synchronize底层原理是什么?我们先通过反编译下面的代码来看看Synchronized是如何实现对代码块进行同步的：

       1 package com.paddx.test.concurrent;

       2

       3 public class SynchronizedDemo {

       4 public void method() {

       5 synchronized (this) {

       6 System.out.println(Method 1 start);

       7 }

       8 }

       9 }

       反编译结果：

       关于这两条指令的作用，我们直接参考JVM规范中描述：

       monitorenter ：

       Each object is associated with a monitor. A monitor is locked if and only if it has an owner. The thread that executes monitorenter attempts to gain ownership of the monitor associated with objectref, as follows:

        If the entry count of the monitor associated with objectref is zero, the thread enters the monitor and sets its entry count to one. The thread is then the owner of the monitor.

        If the thread already owns the monitor associated with objectref, it reenters the monitor, incrementing its entry count.

        If another thread already owns the monitor associated with objectref, the thread blocks until the monitors entry count is zero, then tries again to gain ownership.

       这段话的大概意思为：

       每个对象有一个监视器锁(monitor)。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程：

       1、如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。

       2、如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1.

       3.如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权。

       monitorexit：

       The thread that executes monitorexit must be the owner of the monitor associated with the instance referenced by objectref.

       The thread decrements the entry count of the monitor associated with objectref. If as a result the value of the entry count is zero, the thread exits the monitor and is no longer its owner. Other threads that are blocking to enter the monitor are allowed to attempt to do so.

       这段话的大概意思为：

       执行monitorexit的线程必须是objectref所对应的monitor的所有者。

       指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个 monitor 的所有权。

       通过这两段描述，我们应该能很清楚的看出Synchronized的实现原理，Synchronized的语义底层是通过一个monitor的对象来完成，其实wait/notify等方法也依赖于monitor对象，这就是为什么只有在同步的块或者方法中才能调用wait/notify等方法，否则会抛出java.lang.IllegalMonitorStateException的异常的原因。

       我们再来看一下同步方法的反编译结果：

       源代码：

       1 package com.paddx.test.concurrent;

       2

       3 public class SynchronizedMethod {

       4 public synchronized void method() {

       5 System.out.println(Hello World!);

       6 }

       7 }

       反编译结果：

       从反编译的结果来看，方法的同步并没有通过指令monitorenter和monitorexit来完成(理论上其实也可以通过这两条指令来实现)，不过相对于普通方法，其常量池中多了ACC_SYNCHRONIZED标示符。JVM就是根据该标示符来实现方法的同步的：当方法调用时，调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先获取monitor，获取成功之后才能执行方法体，方法执行完后再释放monitor。在方法执行期间，其他任何线程都无法再获得同一个monitor对象。 其实本质上没有区别，只是方法的同步是一种隐式的方式来实现，无需通过字节码来完成。