22-08-27 西安 JUC（01）线程安全synchronized、Lock锁、线程通信

如果使用initialValue（）

protected T initialValue() {
        return null;
}

需要使用匿名内部类

2、ThreadLocal编码规范

ali编码规范中要求如下

那么我们做一个演示

使用完，不清理ThreadLocal的变量

class MyData {
    //一个ThreadLocal类型的成员变量
    ThreadLocal threadLocalField = ThreadLocal.withInitial(() -> 0);
 
    public void add() {
        //每调用一次该方法，给线程专属变量+1
        threadLocalField.set(1 + threadLocalField.get());
    }
}
 
public class ThreadLocalDemo {
    public static void main(String[] args) {
        MyData myData = new MyData();
        ExecutorService threadpool = Executors.newFixedThreadPool(3);
        //来10个任务，让该线程池去处理
        for (int i = 1; i <= 10; i++) {
            threadpool.submit(()->{
                Integer beforeINT = myData.threadLocalField.get();
                myData.add();
                Integer afterINT = myData.threadLocalField.get();
                System.out.println("当前处理任务的线程是"+Thread.currentThread().getName()+"\t"+"beforeINT: "+beforeINT+"\t afterINT: "+afterINT);
            });
        }
        threadpool.shutdown();
    }
}

看的出来，线程1的ThreadLocal变量值一直在增加，这回造成业务逻辑问题和内存泄漏

使用完，清理ThreadLocal的变量

public static void main(String[] args) {
    MyData myData = new MyData();
    ExecutorService threadpool = Executors.newFixedThreadPool(3);
    //来10个任务，让该线程池去处理
    for (int i = 1; i <= 10; i++) {
        threadpool.submit(() -> {
            try {
                Integer beforeINT = myData.threadLocalField.get();
                myData.add();
                Integer afterINT = myData.threadLocalField.get();
                System.out.println("当前处理任务的线程是" + Thread.currentThread().getName() + "\t" + "beforeINT: " + beforeINT + "\t afterINT: " + afterINT);
            } finally {
                //每个线程处理完任务之后，都要回收ThreadLocal变量，避免造成内存泄漏
                myData.threadLocalField.remove();
            }
        });
 
    }
    threadpool.shutdown();
}

ThreadLocal变量的值不再累加，符合效果 

====

建议ThreadLocal对象使用static修饰

ThreadLocali能实现了线程的数据隔离，不在于它自己本身，而在于Thread的ThreadLocalMap。所以，ThreadLocali可以只初始化一次，只分配一块存储空间就足以了，没必要作为成员变量多次被初始化。

阿里手册

3、ThreadLocalMap

为什么TheadLocal线程安全?

Thread类中有一个ThreadLocalMap类型的变量，每个线程人手一份，不和别人共用，该map

只被持有它的线程访问，故不存在线程安全以及锁的问题

ThreadLocalMap是ThreadLocal的静态内部类

ThreadLocalMap的Entry对ThreadLocal的引用为弱引用，避免了ThreadLocal对象无法被回收的问题

以当前ThreadLocal对象作为键，给定的数据作为值设置到当前线程对象的ThreadLocalMap中

4、set、get、remove方法

 set方法

public void set(T value) {
    Thread t = Thread.currentThread();//获取当前线程对象
    ThreadLocalMap map = getMap(t);//得到线程的Map，也就是这个属性threadLocals
    if (map != null)
        map.set(this, value);//将当前的threadLocal对象作为键  传入的参数作为值存入
    else
        createMap(t, value);
}
 
void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

=========  后续通过ThreadLocal获取属性值

get方法 

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

====================  移除数据

 remove方法

public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

5、ThreadLocalMap与WeakReference

内存泄漏：不再会被使用的对象或者变量占用的内存不能被回收，就是内存泄露

ThreadLocalMap的Entry对ThreadLocal的引用为弱引用，避免了ThreadLocal对象无法被回收的问题

只被弱引用关联的对象只能生存到下一次垃圾收集发生为止；在系统GC时，只要发现弱引用，
无论内存是否足够都会回收掉只被弱引用关联的对象。

static class ThreadLocalMap {
    static class Entry extends WeakReference> {
        /** The value associated with this ThreadLocal. */
        Object value;
        Entry(ThreadLocal k, Object v) {
            super(k);
            value = v;
        }
    }
）

线程通信

线程间通信是通过 线程竞争关系+ 线程等待释放锁+唤醒等待 来完成线程的通信

synchornized和Lock加锁的方式 锁定资源都不同 所以不能通用

synchronized线程间通信

• synchronized 保证多个线程访问的资源有竞争关系
• wait/noityAll+ 业务中的判断 保证满足条件的线程才会执行

多线程模板

1.线程操作资源类

2.线程间的协作（通信）

         判断、干活、通知（唤醒）

1、线程通信简单案例

两个线程操作一个初始值为0的变量，实现一个线程对变量增加1，一个线程对变量减少1，交替10轮

这个案例之所以能成功，原因在于AA线程和BB线程都在争抢同一个对象shareDataOne ，存在竞争关系。

AA获取到后，就去给number+1，假设此时number=0，AA会把number+1,因为synchronized是非公平锁，所以AA可能又抢到了，此时number=1，AA就在this.wait那等着，并且释放锁，BB拿到锁之后对number-1，并且唤醒所有在对象shareDataOne等待的线程，AA就醒了，继续往下走。。。把number再+1.。。。

public class ShareDataOne {
    private Integer number = 0;
    /**
     *  增加1
     */
    public synchronized void increment() throws InterruptedException {
        //判断
        if(number!=0){
            //让该线程等着,唤醒后从wait下一行开始执行，所以wait下一行是没有return的
            this.wait();
        }
        //干活
        number++;
        System.out.println(Thread.currentThread().getName() + ": " + number);
 
        //通知：唤醒此对象上等待的其他线程
        this.notifyAll();
    }
    /**
     *  减少1
     */
    public synchronized void decrement() throws InterruptedException {
        //判断
        if(number!=1){
            //让该线程等着,唤醒后从wait下一行开始执行，所以wait下一行是没有return的
            this.wait();
        }
        //干活
        number--;
        System.out.println(Thread.currentThread().getName() + ": " + number);
 
        //通知：唤醒此对象上等待的其他线程
        this.notifyAll();
    }
}

测试类如下：

public class NotifyWaitDemo {
 
    public static void main(String[] args) {
        ShareDataOne shareDataOne = new ShareDataOne();
 
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareDataOne.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "AA").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareDataOne.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "BB").start();
 
    }
}

测试结果也是对的，交替打印

2、虚假唤醒问题案例

资源类不改动，我们改变测试类代码、

再加CC和DD线程

public class NotifyWaitDemo {
 
    public static void main(String[] args) {
        ShareDataOne shareDataOne = new ShareDataOne();
 
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareDataOne.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "AA").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareDataOne.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "BB").start();
        
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareDataOne.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "CC").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareDataOne.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "DD").start();
    }
}

打印结果，依然会有概率是，10101010...。

但是，多执行几次，也会出现错乱的现象，也就是虚假唤醒问题

分析为什么会出现虚假唤醒问题

消费者被唤醒后是从wait()方法（被阻塞的地方）后面执行，而不是重新从同步块开头。

解决线程唤醒问题很简单

判断时，不能用if，改用while

if只判断一次，while是只要唤醒就要拉回来再判断一次。

//判断
while(number!=0){
    //让该线程等着,唤醒后从wait下一行开始执行，所以wait下一行是没有return的
    this.wait();
}
 
 //判断
 while(number!=1){
     //让该线程等着,唤醒后从wait下一行开始执行，所以wait下一行是没有return的
     this.wait();
 }

测试，控制台打印结果，就会交替打印1和0了

ReentrantLock线程通信

ReentrantLock: 它是通过同一个锁对象的state属性值 判断锁是否被使用，

多个线程如果希望通过Lock来加锁保证竞争关系，他们需要使用同一个lock对象，哪一个能够将lock对象的state属性值从0改为1 哪一个就可以获取锁成功

注：只能有一个线程修改state成功，会把等待的线程放在队列（AQS）

此时线程间的通信需要使用的方法：跟上面那一套（synchronized）不一样

线程间通信需要使用Lock的newCondition创建的Condition对象的：

await()、signal()/signalAll() 控制线程间的通信

Condition对象：每个线程拥有自己单独的一个，才可以精确控制当前线程释放锁等待 或者被唤醒

public class ShareDataOne {
    private Integer number = 0;
 
    Lock lock = new ReentrantLock(); // 初始化lock锁
 
    //必须使用正在加锁的锁对象创建Condition对象
    Condition c_add = lock.newCondition();
    Condition c_sub = lock.newCondition();
 
    /**
     * 打印0
     */
    public void print0() {
        lock.lock(); // 加锁
        try {
            // 1. 判断
            while (number != 0) {
                // c_add让当前线程等待
                c_add.await();
            }
 
            // 2. 干活
            System.out.print(number++ + "\t");
 
            // 3. 通知 唤醒的是使用c_sub等待的线程
            //condition对象 每个线程需要自己单独的一个，才可以精确控制当前线程释放锁等待  或者被唤醒
            c_sub.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
 
    /**
     * 打印1
     */
    public void print1() {
        lock.lock();
        try {
            // 1. 判断
            while (number != 1) {
                c_sub.await();
            }
 
            // 2. 干活
            System.out.print(number-- + "\t");
 
            // 3. 通知
            //condition对象 每个线程需要自己单独的一个，才可以精确控制当前线程释放锁等待  或者被唤醒
            c_add.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

测试类:

public class NotifyWaitDemo {
 
    public static void main(String[] args) {
        ShareDataOne shareDataOne = new ShareDataOne();
 
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                shareDataOne.print0();
            }
        },"AA").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                shareDataOne.print1();
            }
        },"BB").start();
    }
}

控制台打印效果 

LockSupport

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。

1、LockSupport工具类

LockSupport是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有对应的唤醒方法。归根结底，LockSupport调用的Unsafe中的native代码。

8个方法

2、park（）和unpark（）

LockSupport提供park()和unpark()方法实现阻塞线程和解除线程阻塞的过程

LockSupport和每个使用它的线程都有一个许可(permit)关联。每个线程都有一个相关的permit且permit最多只有一个，重复调用unpark也不会积累凭证。

==========

park（）

permit许可证默认设有，所以一开始调park()方法当前线程就会阻塞，直到别的线程给当前线程的发放permit,park方法才会被唤醒。

调用了UnSafe类

public static void park() {
    UNSAFE.park(false, 0L);
}

==========

unpark（）

调用unpark(thread)方法后，就会将thread线程的许可证permit发放，会自动唤醒park线程，即之前阻塞中的LockSupport.park()方法会立即返回。

调用了UnSafe类

public static void unpark(Thread thread) {
    if (thread != null)
        UNSAFE.unpark(thread);
}

=======

为什么可以突破wait/notify的原有调用顺序？

因为unpark获得了一个凭证，之后再调用park方法，就可以名正言顺的凭证消费，故不会阻塞。

为什么唤醒两次后阻塞两次，但最终结果还会阻塞线程？

因为凭证的数量最多为1，连续调用两次unpark和调用一次unpark效果一样，只会增加一个凭证；而调用两次park却需要消费两个凭证，证不够，不能放行。

3、LockSupport实现线程间通信

实现线程间等待唤醒的3种方式

方式1：使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程

方式2：使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程

方式3：LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程

不管是方式1还是方式2都有如下2个限制

• 线程先要获得并持有锁，等待唤醒方法必须在锁块(synchronized或Iock)中
• 必须要先等待后唤醒，线程才能够被唤醒

public class LockSupportDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t----come in");
            LockSupport.park();
            System.out.println(Thread.currentThread().getName()+"\t----被唤醒");
        },"t1");
        t1.start();
        //休眠1s
       TimeUnit.SECONDS.sleep(1);
 
        new Thread(()->{
            LockSupport.unpark(t1);
            System.out.println(Thread.currentThread().getName()+"\t----发出通知");
        },"t2").start();
    }
}

死锁问题排查

1、死锁产生的原因

死锁：两个或者两个以上线程在执行过程中，因为争夺资源而造成一种互相等待的观象，如果没有外力干涉，他们无法再执行下去

 A持有A锁，B持有B锁，都试图获取对方的锁

造成死锁必须要达到的4个条件，如果要避免死锁，只需要不满足其中某一个条件即可。

1.一个资源每次只能被一个线程使用
2.一个线程在阻塞等待某个资源时，不释放已占有资源
3.一个线程已经获得的资源，在未使用完之前，不能被强行剥夺
4.若干线程形成头尾相接的循环等待资源关系

而其中前3个条件是作为锁要符合的条件，所以要避免死锁就需要打破第4个条件，不出现循环等待锁的关系。

2、死锁的几种情况

1、使用synchronized时

两个线程在持有锁的情况下去获取对方的锁(业务中没有合理的使用锁、释放锁)

/*
死锁：
    A线程和B线程 互相持有锁
    各自在加锁的代码中有需要获取对方的锁导致死锁
 */
public class JucDemo04DeadLock {
    Object obj1 = new Object();
    Object obj2 = new Object();
 
    public static void main(String[] args) {
        JucDemo04DeadLock deadLock = new JucDemo04DeadLock();
        new Thread(()->{
            deadLock.a();
        },"AA").start();
        new Thread(()->{
            deadLock.b();
        },"BB").start();
    }
    public void a(){
        synchronized (obj1){
            System.out.println(Thread.currentThread().getName()+"获取到obj1的锁 正在执行");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (obj2){
                System.out.println(Thread.currentThread().getName()+"获取到obj2的锁 正在执行");
            }
 
        }
    }
    public void b(){
        synchronized (obj2){
            System.out.println(Thread.currentThread().getName()+"获取到obj2的锁 正在执行");
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (obj1){
                System.out.println(Thread.currentThread().getName()+"获取到obj1的锁 正在执行");
            }
 
        }
    }
}

控制台打印效果如下：停不下来了。。。直是红色方块 

2、使用reentrantLock时：

为了防止虚假唤醒使用了while死循环判断某个flag变量的状态值

    - 如果一个线程执行完任务后没有修改flag变量的值 会导致死循环
    - 如果忘了通过signal或者使用错了condition对象signal都会导致死锁
    - 如果lock忘记unlock也会导致死锁

3、如何查看死锁

1. 可以通过jstack命令来进行查看，jstack/jvisualvm命令中会显示发生了死锁的线程
2. 或者两个线程去操作数据库时，数据库发生了死锁，这是可以查询数据库的死锁情况

判断是否出现死锁

如果你打不开terminal窗口，就试着改一下这个。。深受其害

jps : 查看所有的java进程   

jps -l   //定位进程号

 注意是：小L

jstack:查看某个java进程的线程堆栈信息+线程的状态

jstack 进程号  //找到死锁的问题

可是可是在实际开发报错是这样的。。。程序就是卡住在那一块了，用jstack也是照样卡住。。。

线程的状态

• NEW 未启动的。

• RUNNABLE 运行中。

• BLOCKED 受阻塞并等待监视器锁。

• WATING 等待另一个线程执行特定操作。

• TIMED_WATING 有时限的等待另一个线程的特定操作。

• TERMINATED 已退出的。

4、死锁的解决方案

如果是synchronized

jps+jstack 可以查看到死锁的线程 排查代码问题

如果是reentrantLock

需要我们自己判断长时间等待的线程，到代码中找业务问题

5、开发中如何避免死锁

1.要注意加锁顺序，保证每个线程按同样的顺序进行加锁
2.要注意加锁时限，可以针对锁设置一个超时时间
3.要注意死锁检查，这是一种预防机制，确保在第一时间发现死锁并进行解决

===============

使用synchronized时：

因为它不可响应中断，一定不要写复杂的嵌套锁的获取

使用ReentrantLock时

每次加锁必须伴随一次释放锁，释放锁建议写在finally中，还可以使用tryLock尝试获取锁，可以响应中断，获取失败超时