转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

线程池#

• 为什么要使用线程池

  • 池化技术：线程池、数据库连接池、Http连接池
  • 池化技术思想意义：为了减少每次获取资源的消耗，提高对资源的利用率

  • 线程池提供了限制和管理 资源(包括执行一个任务)的方式
  • 每个线程池还维护基本统计信息，例如已完成任务的数量
  • 好处：
    1. 降低资源消耗 重复利用已创建线程降低线程创建和销毁造成的消耗
    2. 提高响应速度 任务到达时，任务可以不需等到线程创建就能继续执行
    3. 提高线程的可管理性 线程是稀缺资源，如果无限制创建，不仅消耗系统资源，还会降低系统的稳定性，使用线程池统一管理分配、调优和监控。

• 实现Runnable接口和Callable接口的区别

  //Callable的用法 
  public class TestLy {
  
      //如果加上volatile,就能保证可见性，线程1 才能停止
        boolean stop = false;//对象属性
  
      public static void main(String[] args) throws InterruptedException, ExecutionException {
          FutureTask<String> futureTask=new FutureTask<>(new Callable<String>() {
              @Override
              public String call() throws Exception {
                  System.out.println("等3s再把结果给你");
                  TimeUnit.SECONDS.sleep(3);
                  return "hello world";
              }
          });
          new Thread(futureTask).start();
          String s = futureTask.get();
          System.out.println("3s后获取到了结果"+s);
  
          new Thread(new Runnable() {
              @Override
              public void run() {
                  System.out.println("abc");
              }
          }).start();
      }
  }
  /*
  等3s再把结果给你
  3s后获取到了结果hello world
  abc
  */

  • Runnable接口不会返回结果或抛出检查异常，Callable接口可以

以下内容均转自 https://www.cnblogs.com/wuqinglong/p/9945618.html，部分疑惑参考自另一作者 https://github.com/farmerjohngit/myblog/issues/12 ，感谢原作者。

【目前还是存有部分疑虑（轻量级锁那块），可能需要详细看源码才能释疑】

概述#

传统的synchronized为重量级锁（使用操作系统互斥量（mutex）来实现的传统锁），但是随着JavaSE1.6对synchronized优化后，部分情况下他就没有那么重了。本文介绍了JavaSE1.6为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁，以及锁结构、及锁升级过程

实现同步的基础#

Java中每个对象都可以作为锁，具体变现形式

1. 对于普通同步方法，锁是当前实例对象
2. 对于静态同步方法，锁是当前类的Class对象
3. 对于同步方法块，锁是synchronized括号里配置的对象

一个线程试图访问同步代码块时，必须获取锁；在退出或者抛出异常时，必须释放锁

实现方式#

JVM 基于进入和退出 Monitor 对象来实现方法同步和代码块同步，但是两者的实现细节不一样

1. 代码块同步：通过使用 monitorenter 和 monitorexit 指令实现的
2. 同步方法：ACC_SYNCHRONIZED 修饰

monitorenter 指令是在编译后插入到同步代码块的开始位置，而 monitorexit 指令是在编译后插入到同步代码块的结束处或异常处

对于同步方法，进入方法前添加一个 monitorenter 指令，退出方法后添加一个 monitorexit 指令。

demo：

public class Demo {

    public void f1() {
        synchronized (Demo.class) {
            System.out.println("Hello World.");
        }
    }

    public synchronized void f2() {
        System.out.println("Hello World.");
    }

}

编译之后的字节码（使用 javap )

public void f1();
  descriptor: ()V
  flags: ACC_PUBLIC
  Code:
    stack=2, locals=3, args_size=1
       0: ldc           #2                  // class me/snail/base/Demo
       2: dup
       3: astore_1
       4: monitorenter
       5: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       8: ldc           #4                  // String Hello World.
      10: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      13: aload_1
      14: monitorexit
      15: goto          23
      18: astore_2
      19: aload_1
      20: monitorexit
      21: aload_2
      22: athrow
      23: return
    Exception table:
       from    to  target type
           5    15    18   any
          18    21    18   any
    LineNumberTable:
      line 6: 0
      line 7: 5
      line 8: 13
      line 9: 23
    StackMapTable: number_of_entries = 2
      frame_type = 255 /* full_frame */
        offset_delta = 18
        locals = [ class me/snail/base/Demo, class java/lang/Object ]
        stack = [ class java/lang/Throwable ]
      frame_type = 250 /* chop */
        offset_delta = 4

public synchronized void f2();
  descriptor: ()V
  flags: ACC_PUBLIC, ACC_SYNCHRONIZED
  Code:
    stack=2, locals=1, args_size=1
       0: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #4                  // String Hello World.
       5: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return
    LineNumberTable:
      line 12: 0
      line 13: 8

先说 f1() 方法，发现其中一个 monitorenter 对应了两个 monitorexit，这是不对的。但是仔细看 #15: goto 语句，直接跳转到了 #23: return 处，再看 #22: athrow 语句发现，原来第二个 monitorexit 是保证同步代码块抛出异常时锁能得到正确的释放而存在的，这就理解了。

本文主要讲解synchronized原理和偏向锁、轻量级锁、重量级锁的升级过程，基本都转自

https://blog.csdn.net/MariaOzawa/article/details/107665689 原作者: MariaOzawa

简介#

• 为什么需要锁
  并发编程中，多个线程访问同一共享资源时，必须考虑如何维护数据的原子性
• 历史
  • JDK1.5之前，Java依靠Synchronized关键字实现锁功能，Synchronized是Jvm实现的内置锁，锁的获取与释放由JVM隐式实现
  • JDK1.5，并发包新增Lock接口实现锁功能，提供同步功能，使用时显式获取和释放锁
• 区别
  • Lock同步锁基于Java实现，Synchronized基于底层操作系统的MutexLock实现 /ˈmjuːtɛks/ ，每次获取和释放锁都会带来用户态和内核态的切换，从而增加系统性能开销，性能糟糕，又称重量级锁
  • JDK1.6之后，对Synchronized同步锁做了充分优化

Synchronized同步锁实现原理#

• Synchronized实现同步锁的两种方式：修饰方法；修饰方法块

    // 关键字在实例方法上，锁为当前实例
    public synchronized void method1() {
        // code
    }
  
    // 关键字在代码块上，锁为括号里面的对象
    public void method2() {
        Object o = new Object();
        synchronized (o) {
            // code
        }
    }

  这里使用编译–及javap 打印字节文件

  javac -encoding UTF-8 SyncTest.java  //先运行编译class文件命令
  
  javap -v SyncTest.class //再通过javap打印出字节文件

  结果如下，Synchronized修饰代码块时，由monitorenter和monitorexist指令实现同步。进入monitorenter指令后线程持有Monitor对象；退出monitorenter指令后，线程释放该Monitor对象

    public void method2();
      descriptor: ()V
      flags: ACC_PUBLIC
      Code:
        stack=2, locals=4, args_size=1
           0: new           #2                  
           3: dup
           4: invokespecial #1                  
           7: astore_1
           8: aload_1
           9: dup
          10: astore_2
          11: monitorenter //monitorenter 指令
          12: aload_2
          13: monitorexit  //monitorexit  指令
          14: goto          22
          17: astore_3
          18: aload_2
          19: monitorexit
          20: aload_3
          21: athrow
          22: return
        Exception table:
           from    to  target type
              12    14    17   any
              17    20    17   any
        LineNumberTable:
          line 18: 0
          line 19: 8
          line 21: 12
          line 22: 22
        StackMapTable: number_of_entries = 2
          frame_type = 255 /* full_frame */
            offset_delta = 17
            locals = [ class com/demo/io/SyncTest, class java/lang/Object, class java/lang/Object ]
            stack = [ class java/lang/Throwable ]
          frame_type = 250 /* chop */
            offset_delta = 4

  如果Synchronized修饰同步方法，代替monitorenter和monitorexit的是 ACC_SYNCHRONIZED标志，即：JVM使用该访问标志区分方法是否为同步方法。方法调用时，调用指令检查是否设置ACC_SYNCHRONIZED标志，如有，则执行线程先持有该Monitor对象，再执行该方法；运行期间，其他线程无法获取到该Monitor对象；方法执行完成后，释放该Monitor对象 javap -v xx.class 字节文件查看

简介#

无锁 => 偏向锁 => 轻量锁 => 重量锁

复习Class类锁和实例对象锁，说明Class类锁和实例对象锁不是同一把锁，互相不影响

public static void main(String[] args) throws InterruptedException { 
        Object object=new Object();
        new Thread(()->{
           synchronized (Customer.class){
               System.out.println(Thread.currentThread().getName()+"Object.class类锁");
               try {
                   TimeUnit.SECONDS.sleep(5);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
            System.out.println(Thread.currentThread().getName()+"结束并释放锁");
        },"线程1").start();
        //保证线程1已经获得类锁
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            synchronized (object){
                System.out.println(Thread.currentThread().getName()+"获得object实例对象锁");
            }
            System.out.println(Thread.currentThread().getName()+"结束并释放锁");
        },"线程2").start();

    }

/* 输出
线程1Object.class类锁
线程2获得object实例对象锁
线程2结束并释放锁
线程1结束并释放锁
*/

总结图 , 00 , 01 , 10 ，没有11

对象布局#

• heap （where）: new (eden ,s0 ,s1) ,old, metaspace

• 对象的构成元素（what） HotSpot虚拟机里，对象在堆内存中的存储布局分为三个部分

  • 对象头（Header）
    • 对象标记 MarkWord
    • 类元信息（类型指针 Class Pointer，指向方法区的地址）
    • 对象头多大 length（数组才有）
  • 实例数据（Instance Data）
  • 对其填充（Padding，保证整个对象大小，是8个字节的倍数）

对象头#

• 对象标记

  1. Object o= new Object(); //new一个对象，占内存多少
  2. o.hashCode() //hashCode存在对象哪个地方
  3. synchronized(o){ } //对象被锁了多少次（可重入锁）
  4. System.gc(); //躲过了几次gc（次数）

  上面这些，哈希码、gc标记、gc次数、同步锁标记、偏向锁持有者，都保存在对象标记里面

  1. 如果在64位系统中，对象头中，**mark word（对象标记）**占用8个字节（64位）；**class pointer（类元信息）**占用8个字节，总共16字节（忽略压缩指针）
  2. 无锁的时候，

• 类型指针 注意下图，指向方法区中（模板）的地址

实例数据和对齐填充#

• 实例数据

• 用来存放类的属性（Filed）数据信息，包括父类的属性信息

• 对齐填充

• 填充到长度为8字节，因为虚拟机要求对象起始地址必须是8字节的整数倍（对齐填充不一定存在）

• 示例

  class Customer{
      int id;//4字节
      boolean flag=false; //1字节
  }
  //Customer customer=new Customer();
  //该对象大小：对象头（对象标记8+类型指针8）+实例数据（4+1）=21字节 ===> 为了对齐填充，则为24字节

源码查看#

具体的（64位虚拟机为主）#

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

JMM（JavaMemoryModel)#

详见-知识点

volatile关键字#

• 保证变量可见性

  • 使用volatile关键字保证变量可见性，如果将变量声明为volatile则指示JVM该变量是共享且不稳定的，每次使用它都到主存中读取
    

    volatile关键字并非Java语言特有，在C语言里也有，它最原始的意义就是禁用CPU缓存。

  • volatile关键字只能保证数据可见性，不能保证数据原子性。synchronized关键字两者都能保证

  • 不可见的例子

    package com.concurrent; 
    import java.util.concurrent.TimeUnit;
    
    public class TestLy {
    
        //如果加上volatile,就能保证可见性，线程1 才能停止
          boolean stop = false;//对象属性
    
        public static void main(String[] args) throws InterruptedException {
           TestLy atomicTest = new TestLy();
            new Thread(() -> {
                while (!atomicTest.stop) {
                    //这里不能加System.out.println ,因为这个方法内部用了synchronized修饰,会导致获取主内存的值，
                    //就没法展示效果了
                    /*System.out.println("1还没有停止");*/
                }
                System.out.println(Thread.currentThread().getName()+"停止了");
            },"线程1").start();
    
            new Thread(() -> {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                atomicTest.stop= true;
                System.out.println(Thread.currentThread().getName()+"让线程1停止");
            },"线程2").start();
            while (true){}
        }
    
    
    }

• 如何禁止指令重排 使用volatile关键字，除了可以保证变量的可见性，还能防止JVM指令重排。当我们对这个变量进行读写操作的时候，-会通过插入特定的内存屏障来禁止指令重排

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

• 什么是进程和线程

  • 进程：是程序的一次执行过程，是系统运行程序的基本单位 系统运行一个程序，即一个进程从创建、运行到消亡的过程

    • 启动main函数则启动了一个JVM进程，main函数所在线程为进程中的一个线程，也称主线程

    • 以下为一个个的进程
      

      • 查看java进程

        jps -l
        32 org.jetbrains.jps.cmdline.Launcher
        10084
        16244 com.Test
        17400 sun.tools.jps.Jps

      • 杀死进程

         taskkill /f /pid 16244

  • 何为线程

    • 线程，比进程更小的执行单位

    • 同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈、本地方法栈，又被称为轻量级进程

    • Java天生就是多线程程序，如：

      public class MultiThread {
      	public static void main(String[] args) {
      		// 获取 Java 线程管理 MXBean
      	ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
      		// 不需要获取同步的 monitor 和 synchronizer 信息，仅获取线程和线程堆栈信息
      		ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
      		// 遍历线程信息，仅打印线程 ID 和线程名称信息
      		for (ThreadInfo threadInfo : threadInfos) {
      			System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName());
      		}
      	}
      }
      //输出
      [5] Attach Listener //添加事件
      [4] Signal Dispatcher // 分发处理给 JVM 信号的线程
      [3] Finalizer //调用对象 finalize 方法的线程
      [2] Reference Handler //清除 reference 线程
      [1] main //main 线程,程序入口

      也就是说，一个Java程序的运行，是main线程和多个其他线程同时运行