目录
创建线程的方式
继承Thread类
实现Runnable接口
实现Callable接口
线程的状态转换
volatile关键字
synchronized关键字
synchronized关键字的特性
synchronized原理
在java中，创建线程就是new一个Thread，有三种方式，第一种是继承Thread类、第二种是实现Runnable接口、第三种是实现Callable接口
继承Thread类，重写run方法(run方法即定义要执行的任务代码)
public class TestDemo5 {
class MyThread extends Thread {
@Override
public void run() {
System.out.println("继承Thread类方式创建线程");
}
}
public static void main(String[] args) {
TestDemo5.MyThread thread = new TestDemo5().new MyThread();
thread.start();
}
}首先实现Runnable接口，再重写run方法，之后创建线程时传入创建的runnable对象
public class TestDemo5 {
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("实现Runnable接口方式创建线程");
}
}
public static void main(String[] args) {
TestDemo5.MyRunnable myRunnable = new TestDemo5().new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
}
}public class TestDemo6 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
Callable<Integer> callable = new Callable<Integer>() {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i <= 1000; i++) {
sum += i;
}
return sum;
}
};
FutureTask<Integer> futureTask = new FutureTask<>(callable);
Thread t = new Thread(futureTask);
t.start();
int ret = futureTask.get();
System.out.println(ret);
}
}
线程的状态有六种：NEW(初始状态)、RUNNABLE(可运行态)、WAITING(等待状态)、TIMED_WAITING(超时等待状态)、BLOCKED(阻塞状态)、TERMINATED(终止状态)
创建一个线程，线程就进入了NEW状态，当调用start方法时，进入RUNNABLE状态，如果调用了wait、join等方法时就进入WAITING、TIMED_WAITING状态，当多个线程竞争同一把锁时，竞争失败的线程进入BLOCKING状态，线程执行完成后，进入TERMINATED状态。
使用volatile关键字是为了保证线程安全的，当某个线程对共享变量只是读操作而没有写操作时，使用volatile就可以保证线程安全。volatile的作用是保证可见性和有序性，因为读操作本来就具有原子性，因此仅使用volatile就可以保证线程安全。
· volatile能保证内存的可见性
使多个线程对同一个共享变量操作具有可见性
代码在写入volatile修饰的变量时，先改变工作内存中volatile变量的副本值，再将改变后的副本的值从工作内存刷新到主内存。
代码在读取volatile修饰的变量时，先从主内存中读取volatile变量的最新值到线程的工作内存中，再从工作内存中读取volatile变量的副本。
· volatile可以禁止代码指令重排序，建立内存屏障
例如：小李对自己的安排是：
1、打篮球；
2、吃饭；
3、取快递
如果不加volatile，小李的执行顺序可能是2、1、3或3、2、1等等，但是加上volatile就是1、2、3，这就是禁止指令重排序的作用。
· 但是volatile不能保证原子性
多个线程使用同一个对象进行加锁（基于对象头加锁），可以实现线程间的同步互斥。简单地说，它的原理就是基于对象头加锁，满足原子性、可见性、有序性
①互斥：
synchronized会起到互斥效果，某个线程执行到某个对象的synchronized中时，如果其他线程也执行到同一个的对象的synchronized就会阻塞等待，进入synchronized代码块相当于加锁，退出synchronized修饰的代码块相当于释放锁。synchronized的锁是存在Java对象头中的。
互斥可以满足原子性，某个线程执行同一个对象加锁的同步代码，排斥另一个线程加锁，满足最小执行单位。
②刷新内存：
synchronized结束释放锁，会把工作内存中的数据刷新到主存，其他线程申请锁，获取的始终是最新数据（满足可见性）。synchronized的工作过程：获得互斥锁->从主内存中拷贝变量的最新副本到工作内存->执行代码->将更改后的共享变量的值刷新到主内存->释放互斥锁
③有序性：
某个线程执行一段同步代码，不管如何重排序，期间都不可能有其他线程指令的执行，这样多个线程执行同步代码，就是满足一定的顺序的
④可重入：
同一个线程可以多次申请同一个对象锁
结合锁策略，谈synchronized锁的基本特点：
①开始时是乐观锁，如果锁冲突频繁，就转换为悲观锁
②开始时是轻量级锁实现，如果锁被持有的时间较长，就会转为重量级锁
③实现轻量级锁时大概率用到自旋锁策略
④是一种不公平锁
⑤是一种可重入锁
⑥不是读写锁
加锁工作过程：
JVM将synchronized锁分为无锁、偏向锁、轻量级锁、重量级锁状态，会根据情况依次进行升级。
①偏向锁：第一个加锁的线程，优先进入偏向锁状态，偏向锁并不是真的“加锁”，只是给对象头做了一个“偏向锁的标记”，记录这个锁属于哪个线程。如果后续没有其他线程来竞争该锁，就不用进行其他同步操作了，如果后续有其他线程竞争该锁，就取消原来的偏向锁状态，进入一般的轻量级锁。
②轻量级锁：随着其他线程进入竞争，偏向锁的状态被消除，进入轻量级锁状态(自适应的自旋锁)。这里的轻量级锁是通过CAS实现的，通过CAS检查并更新一块内存，如果更新成功表示加锁成功，如果更新失败，则认为锁被占用，继续自旋式的等待(并不放弃CPU).自旋操作是一直让CPU进行空转，比较浪费CPU资源。
③重量级锁：当线程冲突进一步激烈，自旋锁不能快速获取到锁状态，就会升级为重量级锁，重量级锁基于系统级别的mutex lock实现，代价非常大，是系统加锁