java 线程安全--Synchronized

在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();
                    }
                }
        }
    }

image.png

可以看到订单显示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();
                    }
                }
        }

image.png

可以看到这回小明，买不到 了，因为已经卖完了呀

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 类这个对象得锁，得到得结果也是小明买不到了，也是线程安全得

image.png

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);
    }

image.png

可以看到中间的count 的值是线程不安全的，但是最终得到的值永远都是 11
所以使用volicate 我觉得如果是要关注每个线程中间的变量值是不适合的，所以说当写入变量值要依赖当前变量值，这种操作不是原子性的，而volicate不保证原子性的

锁释放

异常自动释放锁
当一个线程执行的代码出现异常时，其所持有的锁会自动释放。