# Nicksxs's Blog

What hurts more, the pain of hard work or the pain of regret?

0%

## 聊聊 Java 中绕不开的 Synchronized 关键字-二

发表于 2021-06-27 更新于 2022-06-11 分类于 Java 阅读次数： Disqus：

# Java并发

synchronized 的一些学习记录

jdk1.6 以后对 synchronized 进行了一些优化，包括偏向锁，轻量级锁，重量级锁等

这些锁的加锁方式大多跟对象头有关，我们可以查看 jdk 代码

首先对象头的位置注释

    // Bit-format of an object header (most significant first, big endian layout below):
    //
    //  32 bits:
    //  --------
    //             hash:25 ------------>| age:4    biased_lock:1 lock:2 (normal object)
    //             JavaThread*:23 epoch:2 age:4    biased_lock:1 lock:2 (biased object)
    //             size:32 ------------------------------------------>| (CMS free block)
    //             PromotedObject*:29 ---------->| promo_bits:3 ----->| (CMS promoted object)
    //
    //  64 bits:
    //  --------
    //  unused:25 hash:31 -->| unused:1   age:4    biased_lock:1 lock:2 (normal object)
    //  JavaThread*:54 epoch:2 unused:1   age:4    biased_lock:1 lock:2 (biased object)
    //  PromotedObject*:61 --------------------->| promo_bits:3 ----->| (CMS promoted object)
    //  size:64 ----------------------------------------------------->| (CMS free block)
    //
    //  unused:25 hash:31 -->| cms_free:1 age:4    biased_lock:1 lock:2 (COOPs && normal object)
    //  JavaThread*:54 epoch:2 cms_free:1 age:4    biased_lock:1 lock:2 (COOPs && biased object)
    //  narrowOop:32 unused:24 cms_free:1 unused:4 promo_bits:3 ----->| (COOPs && CMS promoted object)
    //  unused:21 size:35 -->| cms_free:1 unused:7 ------------------>| (COOPs && CMS free block)

    enum { locked_value             = 0,
             unlocked_value           = 1,
             monitor_value            = 2,
             marked_value             = 3,
             biased_lock_pattern      = 5
    };

我们可以用 java jol库来查看对象头，通过一段简单的代码来看下

    public class ObjectHeaderDemo {
        public static void main(String[] args) throws InterruptedException {
            L l = new L();
            System.out.println(ClassLayout.parseInstance(l).toPrintable());
    		}
    }

然后可以看到打印输出，当然这里因为对齐方式，我们看到的其实顺序是反过来的，按最后三位去看，我们这是 001，好像偏向锁都没开，这里使用的是 jdk1.8，默认开始偏向锁的，其实这里有涉及到了一个配置，jdk1.8 中偏向锁会延迟 4 秒开启，可以通过添加启动参数 -XX:+PrintFlagsFinal，看到

因为在初始化的时候防止线程竞争有大量的偏向锁撤销升级，所以会延迟 4s 开启

我们再来延迟 5s 看看

    public class ObjectHeaderDemo {
        public static void main(String[] args) throws InterruptedException {
    				TimeUnit.SECONDS.sleep(5);
            L l = new L();
            System.out.println(ClassLayout.parseInstance(l).toPrintable());
    		}
    }

可以看到偏向锁设置已经开启了，我们来是一下加个偏向锁

    public class ObjectHeaderDemo {
        public static void main(String[] args) throws InterruptedException {
            TimeUnit.SECONDS.sleep(5);
            L l = new L();
            System.out.println(ClassLayout.parseInstance(l).toPrintable());
            synchronized (l) {
                System.out.println("1\n" + ClassLayout.parseInstance(l).toPrintable());
            }
            synchronized (l) {
                System.out.println("2\n" + ClassLayout.parseInstance(l).toPrintable());
            }
    		}
    }

看下运行结果

可以看到是加上了 101 = 5 也就是偏向锁，后面是线程 id

当我再使用一个线程来竞争这个锁的时候

    public class ObjectHeaderDemo {
        public static void main(String[] args) throws InterruptedException {
            TimeUnit.SECONDS.sleep(5);
            L l = new L();
            System.out.println(ClassLayout.parseInstance(l).toPrintable());
            synchronized (l) {
                System.out.println("1\n" + ClassLayout.parseInstance(l).toPrintable());
            }
    				Thread thread1 = new Thread() {
                @Override
                public void run() {
                    try {
                        TimeUnit.SECONDS.sleep(5L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (l) {
                        System.out.println("thread1 获取锁成功");
                        System.out.println(ClassLayout.parseInstance(l).toPrintable());
                        try {
                            TimeUnit.SECONDS.sleep(5L);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
    				thread1.start();
    		}
    }

可以看到变成了轻量级锁，在线程没有争抢，只是进行了切换，就会使用轻量级锁，当两个线程在竞争了，就又会升级成重量级锁

    public class ObjectHeaderDemo {
        public static void main(String[] args) throws InterruptedException {
            TimeUnit.SECONDS.sleep(5);
            L l = new L();
            System.out.println(ClassLayout.parseInstance(l).toPrintable());
            synchronized (l) {
                System.out.println("1\n" + ClassLayout.parseInstance(l).toPrintable());
            }
            Thread thread1 = new Thread() {
                @Override
                public void run() {
                    try {
                        TimeUnit.SECONDS.sleep(5L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (l) {
                        System.out.println("thread1 获取锁成功");
                        System.out.println(ClassLayout.parseInstance(l).toPrintable());
                        try {
                            TimeUnit.SECONDS.sleep(5L);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            Thread thread2 = new Thread() {
                @Override
                public void run() {
                    try {
                        TimeUnit.SECONDS.sleep(5L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (l) {
                        System.out.println("thread2 获取锁成功");
                        System.out.println(ClassLayout.parseInstance(l).toPrintable());
                    }
                }
            };
            thread1.start();
            thread2.start();
        }
    }

    class L {
        private boolean myboolean = true;
    }

可以看到变成了重量级锁。

## 聊聊 Java 中绕不开的 Synchronized 关键字

发表于 2021-06-20 分类于 Java 阅读次数： Disqus：

Synchronized 关键字在 Java 的并发体系里也是非常重要的一个内容，首先比较常规的是知道它使用的方式，可以锁对象，可以锁代码块，也可以锁方法，看一个简单的 demo

    public class SynchronizedDemo {

        public static void main(String[] args) {
            SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
            synchronizedDemo.lockMethod();
        }

        public synchronized void lockMethod() {
            System.out.println("here i'm locked");
        }

        public void lockSynchronizedDemo() {
            synchronized (this) {
                System.out.println("here lock class");
            }
        }
    }

然后来查看反编译结果，其实代码（日光）之下并无新事，即使是完全不懂的也可以通过一些词义看出一些意义

      Last modified 2021年6月20日; size 729 bytes
      MD5 checksum dd9c529863bd7ff839a95481db578ad9
      Compiled from "SynchronizedDemo.java"
    public class SynchronizedDemo
      minor version: 0
      major version: 53
      flags: (0x0021) ACC_PUBLIC, ACC_SUPER
      this_class: #2                          // SynchronizedDemo
      super_class: #9                         // java/lang/Object
      interfaces: 0, fields: 0, methods: 4, attributes: 1
    Constant pool:
       #1 = Methodref          #9.#22         // java/lang/Object."<init>":()V
       #2 = Class              #23            // SynchronizedDemo
       #3 = Methodref          #2.#22         // SynchronizedDemo."<init>":()V
       #4 = Methodref          #2.#24         // SynchronizedDemo.lockMethod:()V
       #5 = Fieldref           #25.#26        // java/lang/System.out:Ljava/io/PrintStream;
       #6 = String             #27            // here i\'m locked
       #7 = Methodref          #28.#29        // java/io/PrintStream.println:(Ljava/lang/String;)V
       #8 = String             #30            // here lock class
       #9 = Class              #31            // java/lang/Object
      #10 = Utf8               <init>
      #11 = Utf8               ()V
      #12 = Utf8               Code
      #13 = Utf8               LineNumberTable
      #14 = Utf8               main
      #15 = Utf8               ([Ljava/lang/String;)V
      #16 = Utf8               lockMethod
      #17 = Utf8               lockSynchronizedDemo
      #18 = Utf8               StackMapTable
      #19 = Class              #32            // java/lang/Throwable
      #20 = Utf8               SourceFile
      #21 = Utf8               SynchronizedDemo.java
      #22 = NameAndType        #10:#11        // "<init>":()V
      #23 = Utf8               SynchronizedDemo
      #24 = NameAndType        #16:#11        // lockMethod:()V
      #25 = Class              #33            // java/lang/System
      #26 = NameAndType        #34:#35        // out:Ljava/io/PrintStream;
      #27 = Utf8               here i\'m locked
      #28 = Class              #36            // java/io/PrintStream
      #29 = NameAndType        #37:#38        // println:(Ljava/lang/String;)V
      #30 = Utf8               here lock class
      #31 = Utf8               java/lang/Object
      #32 = Utf8               java/lang/Throwable
      #33 = Utf8               java/lang/System
      #34 = Utf8               out
      #35 = Utf8               Ljava/io/PrintStream;
      #36 = Utf8               java/io/PrintStream
      #37 = Utf8               println
      #38 = Utf8               (Ljava/lang/String;)V
    {
      public SynchronizedDemo();
        descriptor: ()V
        flags: (0x0001) ACC_PUBLIC
        Code:
          stack=1, locals=1, args_size=1
             0: aload_0
             1: invokespecial #1                  // Method java/lang/Object."<init>":()V
             4: return
          LineNumberTable:
            line 5: 0

      public static void main(java.lang.String[]);
        descriptor: ([Ljava/lang/String;)V
        flags: (0x0009) ACC_PUBLIC, ACC_STATIC
        Code:
          stack=2, locals=2, args_size=1
             0: new           #2                  // class SynchronizedDemo
             3: dup
             4: invokespecial #3                  // Method "<init>":()V
             7: astore_1
             8: aload_1
             9: invokevirtual #4                  // Method lockMethod:()V
            12: return
          LineNumberTable:
            line 8: 0
            line 9: 8
            line 10: 12

      public synchronized void lockMethod();
        descriptor: ()V
        flags: (0x0021) ACC_PUBLIC, ACC_SYNCHRONIZED
        Code:
          stack=2, locals=1, args_size=1
             0: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
             3: ldc           #6                  // String here i\'m locked
             5: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
             8: return
          LineNumberTable:
            line 13: 0
            line 14: 8

      public void lockSynchronizedDemo();
        descriptor: ()V
        flags: (0x0001) ACC_PUBLIC
        Code:
          stack=2, locals=3, args_size=1
             0: aload_0
             1: dup
             2: astore_1
             3: monitorenter
             4: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
             7: ldc           #8                  // String here lock class
             9: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
            12: aload_1
            13: monitorexit
            14: goto          22
            17: astore_2
            18: aload_1
            19: monitorexit
            20: aload_2
            21: athrow
            22: return
          Exception table:
             from    to  target type
                 4    14    17   any
                17    20    17   any
          LineNumberTable:
            line 17: 0
            line 18: 4
            line 19: 12
            line 20: 22
          StackMapTable: number_of_entries = 2
            frame_type = 255 /* full_frame */
              offset_delta = 17
              locals = [ class SynchronizedDemo, class java/lang/Object ]
              stack = [ class java/lang/Throwable ]
            frame_type = 250 /* chop */
              offset_delta = 4
    }
    SourceFile: "SynchronizedDemo.java"

其中`lockMethod`中可以看到是通过 `ACC_SYNCHRONIZED` flag 来标记是被 synchronized 修饰，前面的 ACC 应该是 access 的意思，并且通过 `ACC_PUBLIC` 也可以看出来他们是同一类访问权限关键字来控制的，而修饰类则是通过`3: monitorenter`和`13: monitorexit`来控制并发，这个是原来就知道，后来看了下才知道修饰方法是不一样的，但是在前期都比较诟病是 synchronized 的性能，像 monitor 也是通过操作系统的`mutex lock`互斥锁来实现的，相对是比较重的锁，于是在 JDK 1.6 之后对 synchronized 做了一系列优化，包括偏向锁，轻量级锁，并且包括像 ConcurrentHashMap 这类并发集合都有在使用 synchronized 关键字配合 cas 来做并发保护，

jdk 对于 synchronized 的优化主要在于多重状态锁的升级，最初会使用偏向锁，当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID，以后该线程在进入和退出同步块时不需要进行CAS操作来加锁和解锁，只需简单地测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁。引入偏向锁是为了在无多线程竞争的情况下尽量减少不必要的轻量级锁执行路径，因为轻量级锁的获取及释放依赖多次CAS原子指令，而偏向锁只需要在置换ThreadID的时候依赖一次CAS原子指令（由于一旦出现多线程竞争的情况就必须撤销偏向锁，所以偏向锁的撤销操作的性能损耗必须小于节省下来的CAS原子指令的性能消耗）。
而当出现线程尝试进入同步块时发现已有偏向锁，并且是其他线程时，会将锁升级成轻量级锁，并且自旋尝试获取锁，如果自旋成功则表示获取轻量级锁成功，否则将会升级成重量级锁进行阻塞，当然这里具体的还很复杂，说的比较浅薄主体还是想将原先的阻塞互斥锁进行轻量化，区分特殊情况进行加锁。

## 聊聊 Java 的类加载机制二

发表于 2021-06-13 更新于 2022-06-11 分类于 Java 阅读次数： Disqus：

## 类加载器

类加载机制中说来说去其实也逃不开类加载器这个话题，我们就来说下类加载器这个话题，Java 在 jdk1.2 以后开始有了
Java 虚拟机设计团队有意把加载阶段中的“通过一个类的全限定名来获取描述该类的二进制字节流”这个动作放到 Java 虚拟机外部去实现，以便让应用程序自己去决定如何去获取所需的类。实现这个动作的代码被称为“类加载器”(Class Loader).
其实在 Java 中类加载器有一个很常用的作用，比如一个类的唯一性，其实是由加载它的类加载器和这个类一起来确定这个类在虚拟机的唯一性，这里也参考下周志明书里的例子

    public class ClassLoaderTest {

        public static void main(String[] args) throws Exception {
            ClassLoader myLoader = new ClassLoader() {
                @Override
                public Class<?> loadClass(String name) throws ClassNotFoundException {
                    try {
                        String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";
                        InputStream is = getClass().getResourceAsStream(fileName);
                        if (is == null) {
                            return super.loadClass(name);
                        }
                        byte[] b = new byte[is.available()];
                        is.read(b);
                        return defineClass(name, b, 0, b.length);
                    } catch (IOException e) {
                        throw new ClassNotFoundException(name);
                    }
                }
            };
            Object object = myLoader.loadClass("com.nicksxs.demo.ClassLoaderTest").newInstance();
            System.out.println(object.getClass());
            System.out.println(object instanceof ClassLoaderTest);
        }
    }

可以看下结果
这里说明了当一个是由虚拟机的应用程序类加载器所加载的和另一个由自己写的自定义类加载器加载的，虽然是同一个类，但是 instanceof 的结果就是 false 的

## 双亲委派

自 JDK1.2 以来，Java 一直有些三层类加载器、双亲委派的类加载架构

### 启动类加载器

首先是启动类加载器，`Bootstrap Class Loader`，这个类加载器负责加载放在\lib目录，或者被-Xbootclasspath参数所指定的路径中存放的，而且是Java 虚拟机能够识别的（按照文件名识别，如 rt.jar、tools.jar，名字不符合的类库即使放在 lib 目录中，也不会被加载）类库加载到虚拟机的内存中，启动类加载器无法被 Java 程序直接引用，用户在编写自定义类加载器时，如果需要把家在请求为派给引导类加载器去处理，那直接使用 null 代替即可，可以看下 java.lang.ClassLoader.getClassLoader()方法的代码片段

    /**
         * Returns the class loader for the class.  Some implementations may use
         * null to represent the bootstrap class loader. This method will return
         * null in such implementations if this class was loaded by the bootstrap
         * class loader.
         *
         * <p> If a security manager is present, and the caller's class loader is
         * not null and the caller's class loader is not the same as or an ancestor of
         * the class loader for the class whose class loader is requested, then
         * this method calls the security manager's {@code checkPermission}
         * method with a {@code RuntimePermission("getClassLoader")}
         * permission to ensure it's ok to access the class loader for the class.
         *
         * <p>If this object
         * represents a primitive type or void, null is returned.
         *
         * @return  the class loader that loaded the class or interface
         *          represented by this object.
         * @throws SecurityException
         *    if a security manager exists and its
         *    {@code checkPermission} method denies
         *    access to the class loader for the class.
         * @see java.lang.ClassLoader
         * @see SecurityManager#checkPermission
         * @see java.lang.RuntimePermission
         */
        @CallerSensitive
        public ClassLoader getClassLoader() {
            ClassLoader cl = getClassLoader0();
            if (cl == null)
                return null;
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                ClassLoader.checkClassLoaderPermission(cl, Reflection.getCallerClass());
            }
            return cl;
        }

### 扩展类加载器

这个类加载器是在类sun.misc.Launcher.ExtClassLoader中以 Java 代码的形式实现的，它负责在家\lib\ext 目录中，或者被 java.ext.dirs系统变量中所指定的路径中的所有类库，它其实目的是为了实现 Java 系统类库的扩展机制

### 应用程序类加载器

这个类加载器是由sun.misc.Launcher.AppClassLoader实现，通过 java 代码，并且是 ClassLoader 类中的 getSystemClassLoader()方法的返回值，可以看一下代码

    /**
         * Returns the system class loader for delegation.  This is the default
         * delegation parent for new <tt>ClassLoader</tt> instances, and is
         * typically the class loader used to start the application.
         *
         * <p> This method is first invoked early in the runtime's startup
         * sequence, at which point it creates the system class loader and sets it
         * as the context class loader of the invoking <tt>Thread</tt>.
         *
         * <p> The default system class loader is an implementation-dependent
         * instance of this class.
         *
         * <p> If the system property "<tt>java.system.class.loader</tt>" is defined
         * when this method is first invoked then the value of that property is
         * taken to be the name of a class that will be returned as the system
         * class loader.  The class is loaded using the default system class loader
         * and must define a public constructor that takes a single parameter of
         * type <tt>ClassLoader</tt> which is used as the delegation parent.  An
         * instance is then created using this constructor with the default system
         * class loader as the parameter.  The resulting class loader is defined
         * to be the system class loader.
         *
         * <p> If a security manager is present, and the invoker's class loader is
         * not <tt>null</tt> and the invoker's class loader is not the same as or
         * an ancestor of the system class loader, then this method invokes the
         * security manager's {@link
         * SecurityManager#checkPermission(java.security.Permission)
         * <tt>checkPermission</tt>} method with a {@link
         * RuntimePermission#RuntimePermission(String)
         * <tt>RuntimePermission("getClassLoader")</tt>} permission to verify
         * access to the system class loader.  If not, a
         * <tt>SecurityException</tt> will be thrown.  </p>
         *
         * @return  The system <tt>ClassLoader</tt> for delegation, or
         *          <tt>null</tt> if none
         *
         * @throws  SecurityException
         *          If a security manager exists and its <tt>checkPermission</tt>
         *          method doesn't allow access to the system class loader.
         *
         * @throws  IllegalStateException
         *          If invoked recursively during the construction of the class
         *          loader specified by the "<tt>java.system.class.loader</tt>"
         *          property.
         *
         * @throws  Error
         *          If the system property "<tt>java.system.class.loader</tt>"
         *          is defined but the named class could not be loaded, the
         *          provider class does not define the required constructor, or an
         *          exception is thrown by that constructor when it is invoked. The
         *          underlying cause of the error can be retrieved via the
         *          {@link Throwable#getCause()} method.
         *
         * @revised  1.4
         */
        @CallerSensitive
        public static ClassLoader getSystemClassLoader() {
            initSystemClassLoader();
            if (scl == null) {
                return null;
            }
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                checkClassLoaderPermission(scl, Reflection.getCallerClass());
            }
            return scl;
        }
        private static synchronized void initSystemClassLoader() {
            if (!sclSet) {
                if (scl != null)
                    throw new IllegalStateException("recursive invocation");
                // 主要的第一步是这
                sun.misc.Launcher l = sun.misc.Launcher.getLauncher();
                if (l != null) {
                    Throwable oops = null;
                    // 然后是这
                    scl = l.getClassLoader();
                    try {
                        scl = AccessController.doPrivileged(
                            new SystemClassLoaderAction(scl));
                    } catch (PrivilegedActionException pae) {
                        oops = pae.getCause();
                        if (oops instanceof InvocationTargetException) {
                            oops = oops.getCause();
                        }
                    }
                    if (oops != null) {
                        if (oops instanceof Error) {
                            throw (Error) oops;
                        } else {
                            // wrap the exception
                            throw new Error(oops);
                        }
                    }
                }
                sclSet = true;
            }
        }
    // 接着跟到sun.misc.Launcher#getClassLoader
    public ClassLoader getClassLoader() {
            return this.loader;
        }
    // 然后看到这 sun.misc.Launcher#Launcher
    public Launcher() {
            Launcher.ExtClassLoader var1;
            try {
                var1 = Launcher.ExtClassLoader.getExtClassLoader();
            } catch (IOException var10) {
                throw new InternalError("Could not create extension class loader", var10);
            }

            try {
                // 可以看到 就是 AppClassLoader
                this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
            } catch (IOException var9) {
                throw new InternalError("Could not create application class loader", var9);
            }

            Thread.currentThread().setContextClassLoader(this.loader);
            String var2 = System.getProperty("java.security.manager");
            if (var2 != null) {
                SecurityManager var3 = null;
                if (!"".equals(var2) && !"default".equals(var2)) {
                    try {
                        var3 = (SecurityManager)this.loader.loadClass(var2).newInstance();
                    } catch (IllegalAccessException var5) {
                    } catch (InstantiationException var6) {
                    } catch (ClassNotFoundException var7) {
                    } catch (ClassCastException var8) {
                    }
                } else {
                    var3 = new SecurityManager();
                }

                if (var3 == null) {
                    throw new InternalError("Could not create SecurityManager: " + var2);
                }

                System.setSecurityManager(var3);
            }

        }

它负责加载用户类路径(ClassPath)上所有的类库，我们可以直接在代码中使用这个类加载器，如果我们的代码中没有自定义的类在加载器，一般情况下这个就是程序中默认的类加载器

### 双亲委派模型

双亲委派模型的工作过程是：如果一个类加载器收到了类加载的请求，它首先不会自己去尝试家在这个类，而是把这个请求为派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的家在请求最终都应该传送到最顶层的启动类加载器中，只有当父类加载器反馈自己无法完成加载请求（它的搜索范围中没有找到所需要的类）时，子加载器才会尝试自己去完成加载。
使用双亲委派模型来组织类加载器之间的关系，一个显而易见的好处就是 Java 中的类随着它的类加载器一起举杯了一种带有优先级的层次关系。例如类 java.lang.Object，它存放在 rt.jar 之中，无论哪一个类加载器要家在这个类，最终都是委派给处于模型最顶层的启动类加载器进行加载，因此 Object 类在程序的各种类加载器环境中都能够保证是同一个类。反之，如果没有使用双薪委派模型，都由各个类加载器自行去加载的话，如果用户自己也编写了一个名为 java.lang.Object 的类，并放在程序的 ClassPath 中，那系统中就会出现多个不同的 Object 类，Java 类型体系中最基础的行为也就无从保证，应用程序将会变得一片混乱。
可以来看下双亲委派模型的代码实现

    /**
         * Loads the class with the specified <a href="#name">binary name</a>.  The
         * default implementation of this method searches for classes in the
         * following order:
         *
         * <ol>
         *
         *   <li><p> Invoke {@link #findLoadedClass(String)} to check if the class
         *   has already been loaded.  </p></li>
         *
         *   <li><p> Invoke the {@link #loadClass(String) <tt>loadClass</tt>} method
         *   on the parent class loader.  If the parent is <tt>null</tt> the class
         *   loader built-in to the virtual machine is used, instead.  </p></li>
         *
         *   <li><p> Invoke the {@link #findClass(String)} method to find the
         *   class.  </p></li>
         *
         * </ol>
         *
         * <p> If the class was found using the above steps, and the
         * <tt>resolve</tt> flag is true, this method will then invoke the {@link
         * #resolveClass(Class)} method on the resulting <tt>Class</tt> object.
         *
         * <p> Subclasses of <tt>ClassLoader</tt> are encouraged to override {@link
         * #findClass(String)}, rather than this method.  </p>
         *
         * <p> Unless overridden, this method synchronizes on the result of
         * {@link #getClassLoadingLock <tt>getClassLoadingLock</tt>} method
         * during the entire class loading process.
         *
         * @param  name
         *         The <a href="#name">binary name</a> of the class
         *
         * @param  resolve
         *         If <tt>true</tt> then resolve the class
         *
         * @return  The resulting <tt>Class</tt> object
         *
         * @throws  ClassNotFoundException
         *          If the class could not be found
         */
        protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException
        {
            synchronized (getClassLoadingLock(name)) {
                // First, check if the class has already been loaded
                Class<?> c = findLoadedClass(name);
                if (c == null) {
                    long t0 = System.nanoTime();
                    try {
                        if (parent != null) {
                            // 委托父类加载
                            c = parent.loadClass(name, false);
                        } else {
                            // 使用启动类加载器
                            c = findBootstrapClassOrNull(name);
                        }
                    } catch (ClassNotFoundException e) {
                        // ClassNotFoundException thrown if class not found
                        // from the non-null parent class loader
                    }

                    if (c == null) {
                        // If still not found, then invoke findClass in order
                        // to find the class.
                        long t1 = System.nanoTime();
                        // 调用自己的 findClass() 方法尝试进行加载
                        c = findClass(name);

                        // this is the defining class loader; record the stats
                        sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                        sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                        sun.misc.PerfCounter.getFindClasses().increment();
                    }
                }
                if (resolve) {
                    resolveClass(c);
                }
                return c;
            }
        }

### 破坏双亲委派

关于破坏双亲委派模型，第一次是在 JDK1.2 之后引入了双亲委派模型之前，那么在那之前已经有了类加载器，所以java.lang.ClassLoader 中添加了一个 protected 方法 findClass()，并引导用户编写的类加载逻辑时尽可能去重写这个方法，而不是在 loadClass()中编写代码。这个跟上面的逻辑其实类似，当父类加载失败，会调用 findClass()来完成加载；第二次是因为这个模型本身还有一些不足之处，比如 SPI 这种，所以有设计了线程下上下文类加载器(Thread Context ClassLoader)。这个类加载器可以通过 java.lang.Thread 类的 java.lang.Thread#setContextClassLoader() 进行设置，然后第三种是为了追求程序动态性，这里有涉及到了 osgi 等概念，就不展开了

## 聊聊如何识别和意识到日常生活中的各类危险

发表于 2021-06-06 分类于 生活 阅读次数： Disqus：

这篇博客的灵感又是来自于我从绍兴来杭州的路上，在我们进站以后上电梯快到的时候，突然前面不动了，右边我能看到的是有个人的行李箱一时拎不起来，另一边后面看到其实是个小孩子在那哭闹，一位妈妈就在那停着安抚或者可能有点手足无措，其实这一点应该是在几年前慢慢意识到是个非常危险的场景，特别是像绍兴北站这样上去站台是非常长的电梯，因为最近扩建改造，车次减少了很多，所以每一班都有很多人，检票上站台的电梯都是满员运转，试想这种情况，如果刚才那位妈妈再多停留一点时间，很可能就会出现后面的人上不来被挤下去，再严重点就是踩踏事件，但是这类情况很少人真的意识到，非常明显的例子就是很多人拿着比较大比较重的行李箱，不走垂梯，并且在快到的时候没有提前准备好，有可能在玩手机啥的，如果提不动，后面又是挤满人了，就很可能出现前面说的这种情况，并且其实这种是非紧急情况，大多数人都没有心理准备，一旦发生后果可能就会很严重，例如火灾地震疏散大部分人或者说负责引导的都是指示要有序撤离，防止踩踏，但是普通坐个扶梯，一般都不会有这个意识，但是如果这个时间比较长，出现了人员站不住往后倒了，真的会很严重。所以如果自己是带娃的或者带了很重的行李箱的，请提前做好准备，看到前面有人带的，最好也保持一定距离。
还有比如日常走路，旁边有车子停着的情况，比较基本的看车灯有没有亮着，亮着的是否是倒车灯，这种应该特别注意远离，至少保持距离，不能挨着走，很多人特别是一些老年人，在一些人比较多的路上，往往完全无视旁边这些车的状态，我走我的路，谁敢阻拦我，管他车在那动不动，其实真的非常危险，车子本身有视线死角，再加上司机的驾驶习惯和状态，想去送死跟碰瓷的除外，还有就是有一些车会比较特殊，车子发动着，但是没灯，可能是车子灯坏了或者司机通过什么方式关了灯，这种比较难避开，不过如果车子打着了，一般会有比较大的热量散发，车子刚灭了也会有，反正能远离点尽量远离，从轿车的车前面走过挨着走要比从屁股后面挨着走稍微安全一些，但也最好不要挨着车走。
最后一点其实是我觉得是我自己比较怕死，一般对来向的车或者从侧面出来的车会做更长的预判距离，特别是电瓶车，一般是不让人的，像送外卖的小哥，的确他们不太容易，但是真的很危险啊，基本就生死看刹车，能刹住就赚了，刹不住就看身子骨扛不扛撞了，只是这里要多说点又要谈到资本的趋利性了，总是想法设法的压榨以获取更多的利益，也不扯远了，能远离就远离吧。

## 聊聊传说中的 ThreadLocal

发表于 2021-05-30 更新于 2022-06-11 分类于 Java 阅读次数： Disqus：

说来也惭愧，这个 ThreadLocal 其实一直都是一知半解，而且看了一下之后还发现记错了，所以还是记录下
原先记忆里的都是反过来，一个 ThreadLocal 是里面按照 thread 作为 key，存储线程内容的，真的是半解都米有，完全是错的，这样就得用 concurrentHashMap 这种去存储并且要锁定线程了，然后内容也只能存一个了，想想简直智障

### 究竟是啥结构

比如我们在代码中 new 一个 ThreadLocal，

    public static void main(String[] args) {
            ThreadLocal<Man> tl = new ThreadLocal<>();

            new Thread(() -> {
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(tl.get());
            }).start();
            new Thread(() -> {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                tl.set(new Man());
            }).start();
        }

        static class Man {
            String name = "nick";
        }

这里构造了两个线程，一个先往里设值，一个后从里取，运行看下结果，
知道这个用法的话肯定知道是取不到值的，只是具体的原理原来搞错了，我们来看下设值 set 方法

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

写博客这会我才明白我原来咋会错得这么离谱，看到第一行代码 t 就是当前线程，然后第二行就是用这个线程去`getMap`，然后我是把这个当成从 map 里取值了，其实这里是

    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

获取 t 的 threadLocals 成员变量，那这个 threadLocals 又是啥呢
它其实是线程 Thread 中的一个类型是java.lang.ThreadLocal.ThreadLocalMap的成员变量
这是 ThreadLocal 的一个静态成员变量

    static class ThreadLocalMap {

            /**
             * The entries in this hash map extend WeakReference, using
             * its main ref field as the key (which is always a
             * ThreadLocal object).  Note that null keys (i.e. entry.get()
             * == null) mean that the key is no longer referenced, so the
             * entry can be expunged from table.  Such entries are referred to
             * as "stale entries" in the code that follows.
             */
            static class Entry extends WeakReference<ThreadLocal<?>> {
                /** The value associated with this ThreadLocal. */
                Object value;

                Entry(ThreadLocal<?> k, Object v) {
                    super(k);
                    value = v;
                }
            }
        }

全部代码有点长，只截取了一小部分，然后我们再回头来分析前面说的 set 过程，再 copy 下代码

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

获取到 map 以后呢，如果 map 不为空，就往 map 里 set，这里注意 key 是啥，其实是当前这个 ThreadLocal，这里就比较明白了究竟是啥结构，每个线程都会维护自身的 ThreadLocalMap，它是线程的一个成员变量，当创建 ThreadLocal 的时候，进行设值的时候其实是往这个 map 里以 ThreadLocal 作为 key，往里设 value。

### 内存泄漏是什么鬼

这里又要看下前面的 ThreadLocalMap 结构了，类似 HashMap，它有个 Entry 结构，在设置的时候会先包装成一个 Entry

    private void set(ThreadLocal<?> key, Object value) {

            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.

            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);

            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();

                if (k == key) {
                    e.value = value;
                    return;
                }

                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
    }

这里其实比较重要的就是前面的 Entry 的构造方法，Entry 是个 WeakReference 的子类，然后在构造方法里可以看到 key 会被包装成一个弱引用，这里为什么使用弱引用，其实是方便这个 key 被回收，如果前面的 ThreadLocal tl实例被设置成 null 了，如果这里是直接的强引用的话，就只能等到线程整个回收了，但是其实是弱引用也会有问题，主要是因为这个 value，如果在 ThreadLocal tl 被设置成 null 了，那么其实这个 value 就会没法被访问到，所以最好的操作还是在使用完了就 remove 掉