1、什么是线程

Java monitor机制，写的很详细，本文不介绍了https://www.cnblogs.com/qingshan-tang/p/12698705.html

com.lang.Thread类，感兴趣同学自行阅读该源码

1.1 进程

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。进程参考资料

1.1.1 进程切换

进程从硬盘读取我们的程序代码，这个时候是比较费时的，CPU不会阻塞在这里等着，而是切换到其他进程，当数据加载完成是，CPU会收到个中断，继续执行这个请求。

对于单核CPU而言，短时间内会执行多少进程，造成并行的错觉，实际可以理解为是并发的操作。

1.1.2 内核态与用户态

进程分为用户进程和内核进程两种。为了安全，用户进程是受限的，它不能随意访问资源、获取资源。所以，由内核进程负责管理和分配资源，它具有最高权限，而用户进程使用被分配的资源。且，操作系统必须能够在有需要的时候能立即切换回内核进程(通过中断)，只有这样，操作系统才能有安全感。

1.1.3 用户态向内核态切换

1、发生系统调用时

2、产生异常时

3、外设产生中断时

这里不做过多解释了，感兴趣同学自行学习linux原理。

1.3 线程

线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。百度百科

1.3.1 进程与线程的关系

1、一个进程中可以同时存在多个线程；

2、各个线程之间可以并发执行；

3、各个线程之间可以共享当前线程中的地址空间和文件等资源；

4、线程是调度的基本单位，而进程则是资源拥有的基本单位；

5、当进程只有一个线程时，可以认为进程就等于线程；

1.3.2 线程内存模型

（1）在看线程内存模型之前，我们首先看下计算机的硬件内存模型。

硬件内存模型

寄存器：寄存器部件，包括通用寄存器、专用寄存器和控制寄存器。通用寄存器又可分定点数和浮点数两类，它们用来保存指令执行过程中临时存放的寄存器操作数和中间（或最终）的操作结果。通用寄存器是中央处理器的重要部件之一。

高速多级缓存：用于解决CPU核心与内存的速度差异问题，CPU核心速度快，内存相比要慢很多，而缓存要比内存速度快。

缓存协议：多级缓存的引入在多核CPU时代导致了缓存不一致的问题，这里需要引入MESI协议缓存解决这一问题，保证缓存中的信息与内存中的信息一致。MESI协议缓存这里不做讲解。

（2）下一步我们看下java内存模型与线程模型的关系
java程序的一次编写到处运行如何体现的？jvm内存模型屏蔽了不同硬件的内存模型。jvm内存模型规定，所有的变量都存储在jvm主内存中，即堆内存，这里指可共享的变量（new出来的实例化对象，数组等）。这里提出主内存与工作内存的概念，每个线程有自己的工作内存，保存自己私有的变量，线程从主内存获取变量的副本作为自己的私有变量，不允许直接操作主内存的变量。线程的工作内存也是独立的，无法操作其他线程的变量。

jvm线程内存关系图

（3）硬件内存模型与jvm内存模型的关系
如下图所示，jvm内存模型和硬件内存模型相似，但并不完全相同。但是jvm的数据大部分会存储到硬件主内存中，部分会存储到寄存器或缓存中，这里只做简单说明。

硬件内存模型与jvm内存模型关系

2、线程实现

2.1 继承Thread类

static class ExtendThread extends Thread {
    @Override
    public void run() {
        System.out.println("继承Thread类方式");
    }
}

public static void main(String[] args) {
    //实例化一个对象
    ExtendThread extendThread = new ExtendThread();
    //start()执行
    extendThread.start();
}

结果：

继承Thread类方式

2.2 实现runnable接口

static class ImplRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("实现Runnable接口方式");
    }
}

public static void main(String[] args) {
    new Thread(new ImplRunnable()).start();
}

结果：

实现Runnable接口方式

2.3 实现callable接口

static class ImplCallable implements Callable {

    private String str;

    public ImplCallable(String str) {
        this.str = str;
    }

    @Override
    public Object call() throws Exception {
        System.out.println("实现callable接口方式");
        return str;
    }
}

public static void main(String[] args) throws ExecutionException, InterruptedException {
    //创建目标对象
    ImplCallable mc = new ImplCallable("实现callable接口方式");
    //创建执行服务
    ExecutorService ser = Executors.newFixedThreadPool(2);
    //提交执行
    Future<String> result = ser.submit(mc);
    //获取结果
    String msg = result.get();
    //关闭服务
    ser.shutdownNow();
    System.out.println("线程执行结果：" + msg);
}

结果：

实现callable接口方式
线程执行结果：实现callable接口方式

2.4 lambda表达式简化实现

提供一个jdk8的方式， lambda表达式。

public static void main(String[] args) {
    new Thread(() -> {
        System.out.println("lambda表达式简化实现");
    }).start();
}

结果：

lambda表达式简化实现

3、常用方法

3.1 start()

用于启动线程，具体请看以下源码内容

public synchronized void start() {
    //判断线程状态是否为0，默认初始化为0
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    //通知组此线程即将启动，以便可以将其添加到组的线程列表中，修改未启动和已启动数量
    group.add(this);
    //启动状态默认为false
    boolean started = false;
    try {
        //调用native方法，底层jvm开启异步线程，并调用run方法
        start0();
        //线程已启动
        started = true;
    } finally {
        try {
            if (!started) {
                //移除线程组中的该线程，并修改未启动线程数
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
           //将start0方法抛出的异常加入堆栈
        }
    }
}

3.2 run()

通常需要重写该方法，线程需要执行的具体内容。

public void run() {
    if (target != null) {
        //这里执行我们自己重写的run方法
        target.run();
    }
}

3.3 currentThread()

返回当前执行线程的Thread对象

public static native Thread currentThread();

3.4 getName()

获取当前线程名称

public final String getName() {
    return name;
}

3.5 setName()

给线程设置自定义名称，一定要在start方法前执行。

public final synchronized void setName(String name) {
    //健康检查，这不做过多研究
    checkAccess();
    //非空验证
    if (name == null) {
        throw new NullPointerException("name cannot be null");
    }
    this.name = name;
    //当状态不为0，表示线程已启动，不能设置名字
    if (threadStatus != 0) {
        //调用底层方法，不做研究
        setNativeName(name);
    }
}

3.6 yield()

放弃当前处理器的占用

public static native void yield()

3.7 join()

在当前执行线程a中，另一个线程b调用该方法，则线程a进入阻塞状态，直到线程b执行完毕，线程a继续执行。参照下面示例：

public class Join extends Thread {

public static void main(String[] args) throws InterruptedException {
    Join join = new Join();
    join.setName("我是join线程");
    join.start();
    //调用join方法
    join.join();

    System.out.println("我是main线程");
}

@Override
public void run() {
    for (int i=0; i<3; i++) {
        System.out.println(Thread.currentThread().getName() + "i=" + i) ;
    }
}

}
执行结果：

我是join线程i=0
我是join线程i=1
我是join线程i=2
我是main线程

3.8 sleep()

阻塞当前线程指定的毫秒数

public static native void sleep(long millis) throws InterruptedException;

3.9 isAlive()

判断当前线程是否存活

public final native boolean isAlive();

4、线程状态

Thread类中定义了state枚举，可以通过getState()获取

public enum State {
    /**
     * 初始
     */
    NEW,
    /**
     * 可运行
     */
    RUNNABLE,
    /**
     * 阻塞
     */
    BLOCKED,
    /**
     * 等待
     */
    WAITING,
    /**
     * 超时等待
     */
    TIMED_WAITING,
    /**
     * 终止
     */
    TERMINATED;
}

下图是通过idea集成plantuml插件画的，无法控制布局，请各位忍受，后面的图使用visio。

线程状态流转图

5、线程同步

多个线程同时调用同一个对象，或者修改同一个变量，为了保证安全性与准确性，引入了同步的概念。关于线程同步大概归纳整理以下几种方式。

举个例子：
有一个库存类，原本100个库存，现在启动多线程增加100个库存，在没有线程同步的情况下。

/**
 * 库存
 */
static class Inventory {

    //库存数量
    private int num = 100;

    //增加库存
    public void add(int n) {
        num += n;
        System.out.println("增加库存后的数量=" + num);
    }
}

public static void main(String[] args) {
    //初始化库存
    Inventory inventory = new Inventory();
    for (int i = 0; i < 100; i++) {
        new Thread(() -> {
            inventory.add(1);
        }).start();
    }
}

取最后几条结果，发现库存最终并没有达到预想的200个：

增加库存后的数量=179
增加库存后的数量=177
增加库存后的数量=177
增加库存后的数量=175
增加库存后的数量=174
增加库存后的数量=174
增加库存后的数量=171
增加库存后的数量=169
增加库存后的数量=167

Process finished with exit code 0

5.1 synchronized同步方法

使用同步方法的方式看看能否解决这个问题，在add方法增加synchronized，锁住该方法。

/**
 * 库存
 */
static class Inventory {

    //库存数量
    private int num = 100;

    //增加库存
    public synchronized void add(int n) {
        num += n;
        System.out.println("增加库存后的数量=" + num);
    }
}

public static void main(String[] args) {
    //初始化库存
    Inventory inventory = new Inventory();
    for (int i = 0; i < 100; i++) {
        new Thread(() -> {
            inventory.add(1);
        }).start();
    }
}

查看结果，发现此时结果按照顺序展示，达到预期。

...
增加库存后的数量=192
增加库存后的数量=193
增加库存后的数量=194
增加库存后的数量=195
增加库存后的数量=196
增加库存后的数量=197
增加库存后的数量=198
增加库存后的数量=199
增加库存后的数量=200

Process finished with exit code 0

5.2 synchronized同步代码块

使用同步代码块的方式解决该问题，在add方法内部加入同步代码块，如下代码所以

/**
 * 库存
 */
static class Inventory {

    //库存数量
    private int num = 100;

    //增加库存
    public void add(int n) {

        synchronized (this) {
            num += n;
            System.out.println("增加库存后的数量=" + num);
        }
    }
}

public static void main(String[] args) {
    //初始化库存
    Inventory inventory = new Inventory();
    for (int i = 0; i < 100; i++) {
        new Thread(() -> {
            inventory.add(1);
        }).start();
    }
}

取部分结果，能够得到预期结果

...
增加库存后的数量=196
增加库存后的数量=197
增加库存后的数量=198
增加库存后的数量=199
增加库存后的数量=200

5.3 volatile关键字

网上很多说通过volatile关键字解决线程同步的问题，但是我想说，这个关键字虽说能够阻止指令重排序，让变量线程间可见，但并不能完全实现线程同步，代码来看下。

/**
 * 库存
 */
static class Inventory {

    //库存数量
    private volatile int num = 100;

    //增加库存
    public void add(int n) {
            num += n;
            System.out.println("增加库存后的数量=" + num);
    }

    //减少库存
    public void sub(int n) {
            num -= n;
            System.out.println("减少库存后的数量=" + num);
        }
}

public static void main(String[] args) {
    Inventory inventory = new Inventory();
    for(int i = 0;i<100;i++) {
        new Thread(() -> {
            inventory.add(1);
        }).start();
    }
    for(int i = 0;i<100;i++) {
        new Thread(() -> {
            inventory.sub(1);
        }).start();
    }
}

结果，后面会专门针对volatile进行讲解：

...
减少库存后的数量=110
减少库存后的数量=111
减少库存后的数量=105
减少库存后的数量=103
减少库存后的数量=101
减少库存后的数量=100
减少库存后的数量=102

5.4 重入锁

/**
 * 库存
 */
static class Inventory {

    //初始化ReentrantLock实例
    Lock lock = new ReentrantLock();

    //库存数量
    private int num = 100;

    //增加库存
    public void add(int n) {
        //加锁
        lock.lock();
        try {
            num += n;
            System.out.println("增加库存后的数量=" + num);
        } finally {
            //释放锁
            lock.unlock();
        }
    }

    //减少库存
    public void sub(int n) {
        //加锁
        lock.lock();
        try {
            num -= n;
            System.out.println("减少库存后的数量=" + num);
        } finally {
            //释放锁
            lock.unlock();
        }
    }
}

public static void main(String[] args) {
    Inventory inventory = new Inventory();
    for (int i = 0; i < 100; i++) {
        new Thread(() -> {
            inventory.add(1);
        }).start();
    }
    for (int i = 0; i < 100; i++) {
        new Thread(() -> {
            inventory.sub(1);
        }).start();
    }
}

5.5 阻塞队列

定义LinkedBlockingQueue阻塞队列，简单实现增加一个，消费一个的线程同步功能

/**
 * 定义一个元素的队列,通过阻塞达到新增一个消费一个的效果
 * 数组元素定义多个时，因消费线程是100个独立线程，执行时间顺序存在差异，不能保证完全顺序执行
 */
final static LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<>(1);

/**
 * 库存
 */
static class Inventory {

    //增加库存
    public void add(int n) {
        try {
            System.out.println("开始增加第" + n + "库存。。。。。");
            //压入队列
            queue.put("第" + n + "库存。。。。。");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //减少库存
    public void sub() {
        try {
            //取出数据
            System.out.println("[取出]====" + queue.take());
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

public static void main(String[] args) {
    Inventory inventory = new Inventory();

    new Thread(() -> {
        for (int i = 1; i <= 100; i++) {
            inventory.add(i);
        }
    }).start();

    for (int i = 0; i < 100; i++) {
        new Thread(() -> {
            inventory.sub();
        }).start();
    }
}

结果：

...
增加库存后的数量=101
取出队列中的数量=101
减少库存后的数量=100
增加库存后的数量=101
取出队列中的数量=101
减少库存后的数量=100
增加库存后的数量=101

5.6 原子类

使用原子类的形式实现线程同步，内部实现使用了CAS（compareAndSwapInt自旋锁）机制。

/**
 * 库存
 */
static class Inventory {

    private AtomicInteger num = new AtomicInteger(100);
    //增加库存
    public void add(int n) {
        //增加库存
        num.incrementAndGet();
        System.out.println("增加库存后的数量=" + num);
    }
}

public static void main(String[] args) {
    Inventory inventory = new Inventory();
    for (int i = 0; i < 100; i++) {
        new Thread(() -> {
            inventory.add(1);
        }).start();
    }
}

结果：

...
增加库存后的数量=196
增加库存后的数量=197
增加库存后的数量=198
增加库存后的数量=199
增加库存后的数量=200

Process finished with exit code 0

5.7 局部变量

使用局部限量形式，模拟两个线程分别处理，相互之间不进行影响。

/**
 * 库存
 */
static class Inventory {

    private ThreadLocal<Integer> num = ThreadLocal.withInitial(() -> 100);

    //增加库存
    public void add(int n, String threadName) {
        //增加库存
        num.set(num.get() + n);
        System.out.println("线程:" + threadName + ",增加库存后的数量=" + num.get());
    }
}

public static void main(String[] args) {
    for (int i = 0; i < 2; i++) {
        new Thread(() -> {
            Inventory inventory = new Inventory();
            for (int j = 0; j < 10; j++) {
                inventory.add(1,Thread.currentThread().getName());
            }
        }).start();
    }
}

结果：

线程:Thread-0,增加库存后的数量=101
线程:Thread-0,增加库存后的数量=102
线程:Thread-0,增加库存后的数量=103
线程:Thread-0,增加库存后的数量=104
线程:Thread-0,增加库存后的数量=105
线程:Thread-0,增加库存后的数量=106
线程:Thread-0,增加库存后的数量=107
线程:Thread-0,增加库存后的数量=108
线程:Thread-0,增加库存后的数量=109
线程:Thread-0,增加库存后的数量=110
线程:Thread-1,增加库存后的数量=101
线程:Thread-1,增加库存后的数量=102
线程:Thread-1,增加库存后的数量=103
线程:Thread-1,增加库存后的数量=104
线程:Thread-1,增加库存后的数量=105
线程:Thread-1,增加库存后的数量=106
线程:Thread-1,增加库存后的数量=107
线程:Thread-1,增加库存后的数量=108
线程:Thread-1,增加库存后的数量=109
线程:Thread-1,增加库存后的数量=110

6、synchronized锁升级

在jdk1.6之前，synchronized的锁只有一种方式，即重量级锁；在之后引入了偏向锁，轻量级锁来缓解锁竞争问题。从此以后锁的状态就有了四种（无锁、偏向锁、轻量级锁、重量级锁），并且四种状态会随着竞争的情况逐渐升级，而且是不可逆的过程，即不可降级。

6.1 java对象

在讲锁之前，先简单介绍下java对的概念。如下图，java对象分为对象头，对象体，对齐字段。

java对象

6.1.1 对象头

当对象为普通对象时，对象头只包含Mark Word 和Klass Word，当时数组对象时，会包含数组长度。
Mark Word：先看下面一张图，图片来源：https://www.cnblogs.com/ZoHy/p/11313155.html

Mark Word 不同锁下的信息

从上图看到，在Mark Word中，包含以下主要信息：
1.locked：两位二进制的锁状态标志位，配合biased_lock表示java对象各阶段不同锁状态。
2.biased_lock：只占一位的二进制偏向锁标记，1表示启用偏向锁，0表示未启用。
3.identity_hashcode：31位的对象标识hashCode，采用延迟加载技术。调用方法System.identityHashCode()计算，并会将结果写到该对象头中。当对象加锁后（偏向、轻量级、重量级），MarkWord的字节没有足够的空间保存hashCode，因此该值会移动到管程Monitor（也可称为监视器）中。
4.thread：54位的持有偏向锁的线程id
5.epoch：偏向锁的时间戳。
6.ptr_to_lock_record：轻量级锁状态下，指向栈中锁记录的指针。
7.ptr_to_heavyweight_monitor：重量级锁状态下，指向对象监视器Monitor的指针。
8:age：4位的Java对象年龄。

Klass Word：存储一个地址，长度取决于系统位数，32位和64位，该地址指向方法区中类的元数据信息。
这里放个jdk1.8的jvm模型图，看一下堆与方法区的关系。
可参考后面的链接学习jvm模型知识：https://www.cnblogs.com/paddix/p/5309550.html

jvm内存模型

数组长度：32位的JVM上，长度为32位；64位JVM则为64位。64位JVM如果开启+UseCompressedOops选项，该区域长度也将由64位压缩至32位。

6.1.2对象体

主要存放对象的属性值。

6.1.3对齐字节

也可称为补齐区域，如果对象总大小不是4字节的整数倍，会填充上一段内存地址使之成为整数倍。

6.3 锁升级

大概了解什么是对象头以及Mark Word后，我们来讨论下锁升级的过程。在jdk1.6之前，只有重量级锁，通过阻塞和唤醒的形式，需要cpu不停地切换状态，这个过程有可能比用户代码执行的时间还长，这即是1.6之前效率低下的原因。1.6之后引入偏向锁和轻量级锁解决效率低下这一问题。

锁升级过程及状态流转

6.3.1 四种锁Mark Word

无锁时Mark Word的内容

偏向锁时Mark Word的内容

轻量级锁时Mark Word的内容

重量级锁时Mark Word的内容

6.3.2 四种锁的优缺点对比

优缺点对比

6.3.3 锁升级过程分析

图片来源https://tech.souyunku.com/?p=37386
偏向锁

偏向锁升级

1.当线程访问同步块，首先检查当前对象头是否包含线程1的id，如果没有，则通过CAS替换Mark Word，替换成功则升级为偏向锁。
2.升级为偏向锁时，会将Mark Word中的内容设置为当前线程id，继续执行同步代码块。这是线程2也来访问同步块，首先检查对象头是否包含线程2的id，如果没有，则会将Mark Word的内容替换为线程2的id，失败的话则意味着存在锁竞争。
3.存在竞争意味着需要升级偏向锁为轻量级锁，在此之前需要先撤销对象的偏向锁（在安全点，没有线程操作字节码），变为无锁的状态，然后升级为轻量级锁。

轻量级锁

轻量级锁膨胀

1、在偏向锁撤销后，需要升级为轻量级锁，线程1和线程2同时访问同步代码块，通过CAS修改对象的Mark Word，将其修改成每个线程自己的LockRecord，成功则得到锁。失败则表示已经被其他线程占用，继续通过自旋获取锁。
2、当自旋满足以下两个条件之一时，发生锁膨胀，升级为重量级锁。
1）在jdk1.6前，默认10次，可通过-XX:PreBlockSpin来修改，或者自旋线程数超过CPU核数的一半。
2）jdk1.6之后，引入了自适应自旋锁，次数并非一成不变。根据获取锁的成功率来决定是否能有更长的等待时间。
升级重量级锁后，会修改对象Mark Word，同时阻塞，并等待占有锁线程释放锁并唤醒其他线程，阻塞线程被唤醒后，继续开始争夺锁访问同步块。

7、synchronized静态同步方法与非静态同步方法

1.同步锁和对象锁是否互斥
同步静态方法，是类锁
同步非静态方法，是对象所
这两种锁是不同的，所以相互之前不会产生互斥。
通过一段代码进行验证：

public class SynchronizedStaticAndNonStatic {

public static int count = 0;

public static synchronized void inc() throws InterruptedException {
    count++;
    //这里将静态方法阻塞，验证是否能访问到inc2()
    Thread.sleep(10000);
    System.out.println("结果1： " + count);
}

public synchronized void inc2() {
    count++;
    System.out.println("结果2： " + count);
}

public static void main(String[] args) throws InterruptedException {
    //调用静态同步方法
    for (int i = 0; i < 5; i++) {
        new Thread(() -> {
            //同步静态方法
            try {
                SynchronizedStaticAndNonStatic.inc();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
    //调用非静态同步方法前先进行阻塞一秒，确保静态同步方法在执行阻塞过程中
    Thread.sleep(1000);
    for (int i = 0; i < 5; i++) {
        new Thread(() -> {
            //同步动态方法
            SynchronizedStaticAndNonStatic t = new SynchronizedStaticAndNonStatic();
            t.inc2();
        }).start();
    }
  }
}

结果分析：

结果2： 3
结果2： 4
结果2： 3
结果2： 5
结果2： 6
结果1： 6
结果1： 7
结果1： 8
结果1： 9
结果1： 10

当结果一进入sleep后，并没有对非静态方法inc2进行阻塞，inc2率先执行完毕。得出在静态方法加同步锁，并不会影响其他对象的非静态同步方法。类锁和对象锁并不互斥。
2.对象锁的同步方法是否互斥

public synchronized void inc3(String tName) throws InterruptedException {
    System.out.println("结果3： " + tName);
    Thread.sleep(10000);
}

public synchronized void inc4(String tName) {
    System.out.println("结果4： " + tName);
}

public static void main(String[] args) {
    SynchronizedStaticAndNonStatic t = new SynchronizedStaticAndNonStatic();
    for (int i = 0; i < 3; i++) {
        new Thread(() -> {
            try {
                t.inc3(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
    for (int i = 0; i < 3; i++) {
        new Thread(() -> {
            t.inc4(Thread.currentThread().getName());
        }).start();
    }
}

结果分析：在第一条结果3出来之前，休眠了10秒，结果4才进行打印，同一个对象在两个线程中分别访问该对象的两个同步方法是互斥的。

结果3： Thread-0
sleep 10s...
结果4： Thread-3
结果4： Thread-5
结果4： Thread-4
结果3： Thread-2
结果3： Thread-1

3.非静态锁方法，不同对象在两个线程中调用同一个同步方法

public synchronized void inc5(String tName) throws InterruptedException {
    System.out.println("结果5： " + tName);
    Thread.sleep(10000);
    System.out.println("结果5操作完成： " + tName);
}

public static void main(String[] args) {
    for (int i = 0; i < 5; i++) {
        new Thread(() -> {
            //同步动态方法
            SynchronizedStaticAndNonStatic t = new SynchronizedStaticAndNonStatic();
            try {
                t.inc5(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

结果分析：“结果5”的提示几乎同时输出，然后sleep了10秒后，才出现操作完成，证明一个对象阻塞后，并不会与其他对象的同步方法互斥。

结果5： Thread-0
结果5： Thread-4
结果5： Thread-3
结果5： Thread-2
结果5： Thread-1
结果5操作完成： Thread-3
结果5操作完成： Thread-4
结果5操作完成： Thread-0
结果5操作完成： Thread-1
结果5操作完成： Thread-2

4.用类直接在两个线程中调用两个不同的同步方法

 public static synchronized void inc() throws InterruptedException {
    count++;
    Thread.sleep(10000);
    System.out.println("结果1： " + count);
}

public static synchronized void inc6() throws InterruptedException {
    count++;
    Thread.sleep(10000);
    System.out.println("结果6： " + count);
}

public static void main(String[] args) {
    for (int i = 0; i < 5; i++) {
        new Thread(() -> {
            try {
                SynchronizedStaticAndNonStatic.inc();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

    for (int i = 0; i < 5; i++) {
        new Thread(() -> {
            try {
                SynchronizedStaticAndNonStatic.inc6();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

结果分析：无论结果1还是结果6，每条结果间隔都是10秒，用类直接在两个线程中调用两个不同的同步方法是互斥的。

结果1： 1
结果6： 2
结果6： 3
结果6： 4
结果6： 5
结果6： 6
结果1： 7
结果1： 8
结果1： 9
结果1： 10

8、synchronized锁重入

问题提出：当一个线程获取了一个对象的锁，在方法内部是否能够获取其他方法的锁？答案是肯定的，Synchronized是可重入锁。
实现原理：通过monitor机制，monitor通过维护一个计数器来记录锁的获取，重入，释放情况。
看个例子：

static class Inventory {

    //库存数量
    private int num = 100;

    //增加库存
    public synchronized void add(int n) {
        num += n;
        System.out.println("增加库存后的数量=" + num);
        sub(n);
    }

    //增加库存
    public synchronized void sub(int n) {
        num -= n;
        System.out.println("减少库存后的数量=" + num);
    }
}

public static void main(String[] args) {
    //初始化库存
    Inventory inventory = new Inventory();
    new Thread(() -> {
        inventory.add(1);
    }).start();
}

结果：线程调用同步方法add，其内部又调用了同步方法sub，看到结果正常返回，仍然能够获取到锁。

增加库存后的数量=101
减少库存后的数量=100

还有另外一种情况，当子类继承父类时，子类也是可以通过可重入锁调用父类的同步方法。

static class Inventory extends InventoryParent{

    //增加库存
    public synchronized void add(int n) {
        super.num += n;
        System.out.println("增加库存后的数量=" + super.num);
        super.sub(n);
    }
}

static class InventoryParent {

    //库存数量
    private int num = 100;

    //增加库存
    public synchronized void sub(int n) {
        num -= n;
        System.out.println("减少库存后的数量=" + num);
    }
}

public static void main(String[] args) {
    //初始化库存
    Inventory inventory = new Inventory();
    new Thread(() -> {
        inventory.add(1);
    }).start();
}

结果：

增加库存后的数量=101
减少库存后的数量=100

9、volatile

参考https://baijiahao.baidu.com/s?id=1663045221235771554&wfr=spider&for=pc
很详细

volatile 的特性

1、保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。（实现可见性）
2、禁止进行指令重排序。（实现有序性）
3、volatile 只能保证对单次读/写的原子性。i++ 这种操作不能保证原子性。

10、wait notify （面试高频）

是java.lang.Object下提供的方法，其中有五个相关方法

//随机唤醒等待队列中等待同一共享资源的一个线程，并使该线程退出等待队列，进入可运行状态，也就是notify()方法仅通知一个线程。
public final native void notify();
//使所有正在等待队列中等待同一共享资源的全部线程退出等待队列，进入可运行状态。此时，优先级最高的那个线程最先执行，但也有可能是随机执行，这取决于JVM虚拟机的实现。
public final native void notifyAll();
//超时等待一段时间，这里的参数时间是毫秒，也就是等待长达n毫秒，如果没有通知就超时返回
public final native void wait(long timeout) throws InterruptedException;
//对于超时时间更细力度的控制，单位为纳秒
public final void wait(long timeout, int nanos) throws InterruptedException {
    if (timeout < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }
    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
                            "nanosecond timeout value out of range");
    }
    if (nanos > 0) {
        timeout++;
    }
    wait(timeout);
}
//使调用该方法的线程释放共享资源锁，然后从运行状态退出，进入等待队列，直到被再次唤醒
public final void wait() throws InterruptedException {
    wait(0);
}

使用wait和notify实现数字和英文字母的交替打印

static class Print {
    /**
     * 当值为1时打印数字，当值为2时打印字母
     */
    private int flag = 1;
    private int count = 1;

    public synchronized void printNum() {
        if (flag != 1) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.print(count);
        flag = 2;
        notify();
    }

    public synchronized void printChar() {
        if (flag != 2) {
            //打印字母
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.print((char) (count - 1 + 'A'));
        count++;
        flag = 1;
        notify();
    }
}

public static void main(String[] args) {
    Print print = new Print();
    new Thread(() -> {
        for (int i = 0; i < 26; i++) {
            print.printNum();
        }
    }).start();
    new Thread(() -> {
        for (int i = 0; i < 26; i++) {
            print.printChar();
        }
    }).start();
}

结果：

1A2B3C4D5E6F7G8H9I10J11K12L13M14N15O16P17Q18R19S20T21U22V23W24X25Y26Z

多线程与高并发（一）-- 基础概念

1、什么是线程

1.1 进程

1.1.1 进程切换

1.1.2 内核态与用户态

1.1.3 用户态向内核态切换

1.3 线程

1.3.1 进程与线程的关系

1.3.2 线程内存模型

2、线程实现

2.1 继承Thread类

2.2 实现runnable接口

2.3 实现callable接口

2.4 lambda表达式简化实现

3、常用方法

3.1 start()

3.2 run()

3.3 currentThread()

3.4 getName()

3.5 setName()

3.6 yield()

3.7 join()

3.8 sleep()

3.9 isAlive()

4、线程状态

5、线程同步

5.1 synchronized同步方法

5.2 synchronized同步代码块

5.3 volatile关键字

5.4 重入锁

5.5 阻塞队列

5.6 原子类

5.7 局部变量

6、synchronized锁升级

6.1 java对象

6.1.1 对象头

6.1.2对象体

6.1.3对齐字节

6.3 锁升级

6.3.1 四种锁Mark Word

6.3.2 四种锁的优缺点对比

6.3.3 锁升级过程分析

7、synchronized静态同步方法与非静态同步方法

8、synchronized锁重入

9、volatile

10、wait notify （面试高频）