java中的线程
public static void main(String[] args) {
//开启线程
Thread t1 = new Thread(() -> {
//todo
});
t1.start();
如上一个简单的线程他从启动到调用run方法是怎么一个流程，往下看线程start方法的源码发现核心的方法应该就是调用 private native void start0(); 这个方法是native用c写的。这个方法底层在调用jvm，jvm直接调用操作系统pthread_create方法启动操作系统的一个线程，同时jvm维护一个线程对象跟操作系统的线程一一对应，同时和java的Thread 一一对应，调用java的线程对象相关api相当于操作操作系统的线程，在操作系统的pthread_create的方法中执行的时候再来回调java的run方法。
java线程调用过程如下
环境准备
1、idae环境 2.需要依赖jol（可以打印出对象对象头）
<dependency>
<groupId>org.openjdk.jol</groupId>
<artifactId>jol-core</artifactId>
<version>0.9</version>
</dependency>
synchronized 是什么
synchronized是java的关键字，是jvm底层实现的，1.6前只有重量级锁，1.6jvm对其进行优化，增加了偏向锁和轻量级锁
前提
要了解synchronized锁膨胀过程需要了解对象的对象头 //todo 差一个对象头图片
偏向锁
顾名思义，偏向，偏心，偏向线程，当只有一个线程访问同步代码的时候，即是偏向锁，每次要执行同步代码的时候，都会先判断线程id是否一致，如果一致就直接进入同步块
偏向锁延迟
1、主线程不睡眠的情况
public static void main(String[] args) throws InterruptedException {
User user = new User();
//jvm延迟偏向锁，所以这时候无锁锁标志 01
System.out.println("first print" + ClassLayout.parseInstance(user).toPrintable());
//此时偏向锁关闭，进入同步代码块，变为轻量级锁 00
synchronized (user) {
System.out.println("first into sync" + ClassLayout.parseInstance(user).toPrintable());
}
}
下面是根据jol打印出来的对象头 mark work
第一次打印：00000001 00000000 00000000 00000000 锁标志位是01 无锁
第二次打印： 00001000 11110111 10010011 00000010 锁标志位00 轻量级锁 
2、主线程睡眠的情况
public static void main(String[] args) throws InterruptedException {
//睡眠大概五秒之后，jvm偏向锁已经开启
Thread.sleep(5000L);
User user = new User();
//偏向锁，还没有记录线程信息，表示可偏向 101
System.out.println("first print" + ClassLayout.parseInstance(user).toPrintable());
//进入同步代码块，先检查是否可偏向
//如果可偏向，记录线程信息 101 同时记录线程id
synchronized (user) {
System.out.println("first into sync" + ClassLayout.parseInstance(user).toPrintable());
}
}
下面是根据jol打印出来的对象头 mark work
第一次打印：00000101 00000000 00000000 00000000 锁标志101 没有线程id，表示可偏向
第二次打印： 00000101 00101000 11110010 00000010 锁标志101 有线程id，表示已经偏向了
小总结一下
同样的代码有睡眠跟没有睡眠锁的标志位不一样，睡眠五秒之后jvm已经开启了偏向锁，所以有睡眠的进入同步代码块就是偏向锁，没有睡眠的，jvm延迟了偏向锁，所以进入同步代码块是轻量级锁。
轻量级锁
偏向锁是一直由同一个线程持有锁，但是当发生多个线程交替执行同步块的时候就会进行锁升级。
以下是轻量级锁升级膨胀的过程
示例
public static void main(String[] args) throws InterruptedException {
//睡眠五秒，五秒之后jvm开启轻量级锁
Thread.sleep(5000L);
User user = new User();
//偏向锁，还没有记录线程信息，表示可偏向 101 无线程id
System.out.println("first print" + ClassLayout.parseInstance(user).toPrintable());
//进入同步代码块，先检查是否可偏向
//如果可偏向，记录线程信息 101 有线程id
synchronized (user) {
System.out.println("first into sync" + ClassLayout.parseInstance(user).toPrintable());
}
//开启线程 此时不同的线程来了，不存在锁竞争，锁升级为轻量级锁
Thread t1 = new Thread(() -> {
synchronized (user) {
System.out.println("sencond into sync" + ClassLayout.parseInstance(user).toPrintable());
}
});
t1.start();
}
下面是根据jol打印出来的对象头 mark work
重量级锁
重量级锁是在多线程中，存在锁竞争的情况下会出现
示例
public static void main(String[] args) throws InterruptedException {
Thread.sleep(5000L);
User user = new User();
//偏向锁，但是没有偏向的线程 101
System.out.println("first pring"
+ ClassLayout.parseInstance(user).toPrintable());
//主线程拿到锁
synchronized (user) {
//偏向锁，此时有偏向的地址 101
System.out.println("first in"
+ ClassLayout.parseInstance(user).toPrintable());
}
//线程t2拿到锁
Thread t2 = new Thread(() -> {
synchronized (user) {
//虽然主线程已经执行完了，但是算是交替执行
//此时是轻量级锁 00
System.out.println("t2 "
+ ClassLayout.parseInstance(user).toPrintable());
try {
//进入锁，先不退出，等待t3来竞争锁
Thread.sleep(7000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t2.start();
//等待是为了确保t2已经拿到锁了
Thread.sleep(4000L);
//线程t3竞争锁
Thread t3 = new Thread(() -> {
synchronized (user) {
//t2还没执行完就去竞争锁
//存在锁的竞争，锁升级为重量级锁 10
System.out.println("t3 "
+ ClassLayout.parseInstance(user).toPrintable());
}
});
t3.start();
}
下面是根据jol打印出来的对象头 mark work
