1 线程安全(库存超卖)

1：多个线程对同一个变量做写的操作。

2: 集群部署，多个服务对同一个变量做写的操作（分布式锁）。等等

简单的小案例

public class ThreadRunnable implements Runnable{
    private  int  a=100;
    @Override
    public void run() {
       while (true){
           if(a>1){
             a--;
               System.out.println(Thread.currentThread().getName()+"=="+a);
           }
       }

    }
    public static void main(String[] args) {
        //同一个对象，同一变量 a
        ThreadRunnable thread = new ThreadRunnable();
        //两个线程分别减共享变量a
        new Thread(thread).start();
        new Thread(thread).start();
    }
}

多线程下变量的不可见性

在多线程并发执行下，多个线程修改共享的成员变量，会出现一个线程修改共享变量后，另一个线程，不能直接看到线程修改后的变量的最新值。

2 锁用法

2.1 同步方法

由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，

内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态

注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类

 public synchronized void add(){}

2.2.同步代码块

被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

注：同步是一种高开销的操作，因此应该尽量减少同步的内容。

通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可

   synchronized(this){

    }

2.3 synchronized 作用于静态方法

总结

当synchronized作用于静态方法时，其锁就是当前类的class对象锁。由于静态成员不专属于任何一个实例对象，是类成员，因此通过class对象锁可以控制静态成员的并发操作。
synchronized作用于非静态方法时，也可以直接锁类。也可以控制静态成员的并发操作。
synchronized作用于非静态方法时，必须是同一个对象才能控制静态成员的并发操作。

需要注意的是如果一个线程A调用一个实例对象的非static synchronized方法，而线程B需要调用这个实例对象所属类的静态 synchronized方法，是允许的，不会发生互斥现象，因为访问静态 synchronized 方法占用的锁是当前类的class对象，而访问非静态 synchronized 方法占用的锁是当前实例对象锁

案例静态成员变量 (synchronized锁非静态方法)

synchronized修饰非静态方法时，锁的是当前实例，不同实例就不是同一把锁了，就不是线程安全

public class ThreadRunnable5 implements Runnable {
    private static int a = 100;
    @SneakyThrows @Override
    public void run() {
            while (true) {
                if (a > 1) {
                    increase4Obj();
                    Thread.sleep(100);
                }
            }
    }
    public synchronized   void increase4Obj(){
            System.out.println(Thread.currentThread().getName() + "==" + a);
            a--;
    }
    public static void main(String[] args) {
        ThreadRunnable5 thread = new ThreadRunnable5();
        new Thread(thread).start();
        new Thread(thread).start();
    }
}

普通方法锁的就是对象的实例，不同的实例对象时，就是两个锁。无法保证线程安全

案例静态成员变量 (synchronized锁静态方法或直接锁类)

2.4ReentrantLock类是可重入、互斥、实现了Lock接口的锁

lock() : 获得锁

unlock() : 释放锁

注意及时释放锁，否则会出现死锁，通常在finally代码释放锁

3 死锁产生与排查

死锁产生

public class ThreadRunnable3 implements Runnable {
    private int count = 1;
    private String locak = "aa";
    @SneakyThrows @Override
    public void run() {
        while (true) {
            count++;
            if (count % 2 == 0) {
                synchronized (locak) {
                    a();
                }
            } else {
                synchronized (this) {
                    b();
                }
            }
        }

    }
    public synchronized void a() {
        System.out.println("我是a方法" + Thread.currentThread().getName());
    }
    public void b() {
        synchronized (locak) {
            System.out.println("我是b方法" + Thread.currentThread().getName());
        }
    }

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

死锁排查

jdk安装目录 jdk1.8.0_341\bin\jconsole.exe