在Java多线程编程当中，提供了以下几种方式来实现线程安全：
Synchronized--阻塞
内部锁（Synchronized）和显式锁（Lock）：属于互斥同步方法，是重量级的多线程同步机制，可能会引起上下文切换和线程调度，它同时提供内存可见性、有序性和原子性。
Volatile--非阻塞
volatile：轻量级多线程同步机制，不会引起上下文切换和线程调度。仅提供内存可见性、有序性保证，不提供原子性。
CAS--非阻塞
CAS原子指令：属于非阻塞同步方法，轻量级多线程同步机制，不会引起上下文切换和线程调度。它同时提供内存可见性、有序性和原子化更新保证。单个变量的更新就可以用原子操作
1.Synchronized， 在方法上添加 Synchronized 修饰
还是小华，小明，小航，要到淘宝最全世界最酷炫的LV 小裤裤，但是现在存货只有两条了，自然就是手快有，手慢无啦
public static void main(String args[]){
Order order=new Order();
//启动3个线程，代表他们进行下单
Thread thread1=new Thread(order,"小华");
Thread thread2=new Thread(order,"小航");
Thread thread3=new Thread(order,"小明");
thread1.start();
thread2.start();
thread3.start();
}
public static class Order implements Runnable{
private int lvUnderWare=2; //裤子的库存只有两条了
@Override
public void run() {
if (lvUnderWare > 0) {
System.out.println(Thread.currentThread().getName() + "开始下单买LV的小裤裤," + "订单显示还剩下：" + lvUnderWare + "条");
lvUnderWare--;
System.out.println(Thread.currentThread().getName() + "下单成功了，买到lv的小裤裤了");
} else {
System.out.println(Thread.currentThread().getName()+"也要购买，但是订单不足了");
try {
Thread.sleep(1000 * 60 );
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
可以看到订单显示0条的时候，还能下单成功？出问题了呀，因为小航买的时候，小明也开始买了呀，但是小明下手慢呀，就木得了，所以这个订单出现线程安全得问题了，我们加个同步方法吧
@Override
public synchronized void run() {
if (lvUnderWare > 0) {
System.out.println(Thread.currentThread().getName() + "开始下单买LV的小裤裤," + "订单显示还剩下：" + lvUnderWare + "条");
lvUnderWare--;
System.out.println(Thread.currentThread().getName() + "下单成功了，买到lv的小裤裤了");
} else {
System.out.println(Thread.currentThread().getName()+"也要购买，但是订单不足了");
try {
Thread.sleep(1000 * 60 );
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
可以看到这回小明，买不到 了，因为已经卖完了呀
2.Synchronized 修饰代码块
@Override
public void run() {
if (lvUnderWare > 0) {
synchronized (this){
System.out.println(Thread.currentThread().getName() + "开始下单买LV的小裤裤," + "订单显示还剩下：" + lvUnderWare + "条");
lvUnderWare--;
System.out.println(Thread.currentThread().getName() + "下单成功了，买到lv的小裤裤了");
}
}
else {
System.out.println(Thread.currentThread().getName()+"也要购买，但是订单不足了");
try {
Thread.sleep(1000 * 60 );
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
代表获取当前对象的锁；也可以是类中的一个属性对象，代表获取该属性对象的锁。我得理解就是order 类这个对象得锁，得到得结果也是小明买不到了，也是线程安全得
3.修饰类
synchronized (Order.class)
@Override
public void run() {
synchronized (Order.class) {
if (lvUnderWare > 0) {
System.out.println(Thread.currentThread().getName() + "开始下单买LV的小裤裤," + "订单显示还剩下：" + lvUnderWare + "条");
lvUnderWare--;
System.out.println(Thread.currentThread().getName() + "下单成功了，买到lv的小裤裤了");
} else {
System.out.println(Thread.currentThread().getName() + "也要购买，但是订单不足了");
try {
Thread.sleep(1000 * 60);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
一样得到得是线程安全的
Volicate
线程在写入volatile变量得时候不会把值缓存在寄存器或者其他地方，而是会把值刷新回主内存中，当其他内存读取该变量得时候，会从主内存中重新获取该值，而不是从当前线程的工作内存中获取值,实际上就是，线程写入了volicate 变量的时候就相当于线程退出同步的代码块，将变量的值写入到主内存中，读取volicate变量的时候就详单与进入同步块，会清空本地内存的变量的值，然后从主内存中获取最新的值
private volatile static int count=1;
public static void main (String [] args) throws InterruptedException {
int finalI=1;
for(int i=1;i<=10;i++){
new Thread(()->{
count++;
System.out.println(count);
}).start();
}
Thread.sleep(1000);
System.out.println("final:"+count);
}
可以看到中间的count 的值是线程不安全的，但是最终得到的值永远都是 11
所以使用volicate 我觉得如果是要关注每个线程中间的变量值是不适合的，所以说当写入变量值要依赖当前变量值，这种操作不是原子性的，而volicate不保证原子性的
锁释放
异常自动释放锁
当一个线程执行的代码出现异常时，其所持有的锁会自动释放。
