工作中需要用到的Java知识(JUC锁学习篇)

JUC这部分在工作中我使用的不是很多，但是无可奈何面试经常会问到这些内容，所以今天就来学习一下JUC。

JUC全称为Java.util.concurrent包，是Java的一个工具包，那么为什么JUC是面试经常问的内容呢，因为JUC包括了多线程、原子性、锁等重量级内容，可以用来考察一个程序员对Java技术的了解程度。

1.回顾多线程

面试1：Java可以创建线程么？

答：不可以，Java创建线程是调用底层的本地native方法，调用C++去创建线程的。

查询电脑CPU核数

package com.test.rabbitmq.test;

/**
 * @author ME
 * @date 2022/2/5 0:41
 */
public class Test {
    public static void main(String[] args) {
        System.out.println("此电脑的CPU核数为" + Runtime.getRuntime().availableProcessors() + "核");
    }
}

线程的状态有几种

wait与sleep方法的区别

我在学习多线程的时候说了一下两者的不同，这里再说一遍

1.来自不同的类，wait方法来自Object类，sleep方法来自Thread类

工作中睡眠的时候使用如下代码，避免直接使用sleep方法

// 睡眠一天
TimeUnit.DAYS.sleep(1);

// 睡眠两秒
TimeUnit.SECONDS.sleep(2);

2.锁的释放，wait方法会释放锁，sleep方法不会释放锁

3.使用范围不同，wait方法必须在同步代码块中使用，不然会报IllegalMonitorStateException，sleep方法则可以在任何地方使用

Synchronized与Lock区别实战

我们先创建一个买票的业务逻辑类

package com.test.rabbitmq.test;

/**
 * @author ME
 * @date 2022/2/5 15:25
 * 卖票的类
 */
public class Ticket {
    // 设置一共有30张票
    private int ticketNum = 30;

    // 设置卖票的方法
    public void sell() {
        // 当我们的剩余的票数大于0时才能卖票
        if (ticketNum > 0) {
            // 先减去票数，后面再加，这样增加了多余的逻辑，容易出现错误
            ticketNum--;
            // 每卖出一张票后票数进行减一张操作，然后打印剩余票数
            System.out.println(Thread.currentThread().getName() + "卖出了第" + (ticketNum + 1) + "张票, 剩余：" + (ticketNum) + "张票");
        }
    }
}

然后我们创建多线程进行调用

package com.test.rabbitmq.test;

/**
 * @author ME
 * @date 2022/2/5 15:25
 */
public class MyLockTest {
    // 主方法进行执行
    public static void main(String[] args) {
        // 创建票的对象
        Ticket ticket = new Ticket();
        // 线程A一共有30个人前去买票
        new Thread(() -> { for (int i = 0; i < 30; i++) ticket.sell();}, "A").start();
        // 线程B一共有30个人前去买票
        new Thread(() -> { for (int i = 0; i < 30; i++) ticket.sell();}, "B").start();
        // 线程C一共有30个人前去买票
        new Thread(() -> { for (int i = 0; i < 30; i++) ticket.sell();}, "C").start();
    }
}

执行结果如下，由于线程之间的数据共享，所以造成了资源的不安全。

 那么我们在卖票类中添加Synchronized关键字后再次进行尝试

package com.test.rabbitmq.test;

/**
 * @author ME
 * @date 2022/2/5 15:25
 * 卖票的类
 */
public class Ticket {
    // 设置一共有30张票
    private int ticketNum = 30;

    // 设置卖票的方法，添加了synchronized关键字
    public synchronized void sell() {
        // 当我们的剩余的票数大于0时才能卖票
        if (ticketNum > 0) {
            // 先减去票数，后面再加，这样增加了多余的逻辑，容易出现错误
            ticketNum--;
            // 每卖出一张票后票数进行减一张操作，然后打印剩余票数
            System.out.println(Thread.currentThread().getName() + "卖出了第" + (ticketNum + 1) + "张票, 剩余：" + (ticketNum) + "张票");
        }
    }
}

执行结果如下，会发现正常有序依次执行，关键就是synchronized关键字添加了同步，一个资源在同一时刻只有一个线程可以使用。

 接下来我们使用lock锁的方式进行操作

这是一个新的概念，在JUC中有一个锁，为lock，在我们java.util.concurrent.locks包下。

已知的实现类有：

我们再来查看ReentrantLock的源码

那么什么是公平锁，什么是非公平锁呢？

lock锁代码如下

package com.test.rabbitmq.test;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author ME
 * @date 2022/2/5 15:25
 * 卖票的类
 */
public class Ticket {
    // 设置一共有30张票
    private int ticketNum = 30;
    // 创建锁对象 放在方法外
    ReentrantLock lock = new ReentrantLock();
    // 设置卖票的方法
    public void sell() {
        // 上锁 放在方法内，后面紧随tryCatch
        lock.lock();
        try {
            // 当我们的剩余的票数大于0时才能卖票
            if (ticketNum > 0) {
                // 先减去票数，后面再加，这样增加了多余的逻辑，容易出现错误
                ticketNum--;
                // 每卖出一张票后票数进行减一张操作，然后打印剩余票数
                System.out.println(Thread.currentThread().getName() + "卖出了第" + (ticketNum + 1) + "张票, 剩余：" + (ticketNum) + "张票");
            }
        }catch (Exception e) {
        }finally {
            // 必须解锁
            lock.unlock();
        }
    }
}

执行结果如下，与synchronized关键字的效果一样

 那么问题来了，两者有什么区别呢？

1.synchronized是Java中的关键字；Lock是一个Java类

2.synchronized由于是自动的，无法获取锁的状态；Lock可以判断是否获取到了锁

3.synchronized由于是自动的，会自动释放锁；Lock必须要手动释放锁，如果不释放则会造成死锁

4.synchronized一个线程获得锁，其他线程会一直等待；Lock可以通过tryLock()方法尝试获取锁，可以进行其他操作

5.synchronized锁是可重入锁，不可中断的，非公平锁；Lock是可重入锁，可以判断锁的状态，公平锁与非公平锁可以自己设置

6.synchronized锁不灵活；Lock锁比较灵活

生产者消费者问题

我们使用synchronized与wait()方法与notify()方法用来进行线程间的通信，代码如下

我们先了解一个notify()与notifyAll()方法的区别

notify()是随机唤醒一个线程；notifyAll()是唤醒全部等待线程来争夺锁

相比于notifyAll()来说，notify()的性能更好。

那么什么时候使用notifyAll()方法呢？

这不得不提到锁池与等待池的关系了，我们启动线程后，线程会进入锁池进行锁的争夺，当我们执行到wait()方法时，会进入等待池，进入等待池的线程不会参与锁的争夺，只有执行notify()或notifyAll()方法时，才会从等待池唤醒一个或多个线程加入锁池进行锁的争夺，一旦锁池中没有线程，notify()方法唤醒的线程也走到了wait()方法，此时所有线程都处于等待状态，会造成死锁。

我们先创建两个方法，您需要了解这两个方法的含义

package com.test.rabbitmq.lockTest;

/**
 * @author ME
 * @date 2022/2/5 20:26
 */
public class A {
    private int number = 0;
    // 方法1,当number不为0时进行等待，当number等于0时进行+1操作，然后释放锁，唤醒其他等待线程
    public synchronized void increment() throws InterruptedException {
        if (number != 0) {
            // 进行线程等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "执行完毕，当前number的值为：" + number);
        // 唤醒其他线程
        this.notifyAll();
    }
    // 方法2，当number为0时进行等待，当number不为0时进行-1操作，然后释放锁，唤醒其他等待线程
    public synchronized void decrement() throws InterruptedException {
        if (number == 0) {
            // 进行线程等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "执行完毕，当前number的值为：" + number);
        // 唤醒其他线程
        this.notifyAll();
    }
}

然后我们通过多线程来启动这两个方法

package com.test.rabbitmq.lockTest;

/**
 * @author ME
 * @date 2022/2/5 20:31
 */
public class Test {
    public static void main(String[] args) {
        A a = new A();
        // 线程A
        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) a.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "A").start();

        // 线程B
        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) a.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "B").start();
    }
}

执行结果如下，这样就实现了线程之间的通讯

但是我们再添加两个线程,代码如下

package com.test.rabbitmq.lockTest;

/**
 * @author ME
 * @date 2022/2/5 20:31
 */
public class Test {
    public static void main(String[] args) {
        A a = new A();
        // 线程A
        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) a.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "A").start();

        // 线程B
        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) a.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "B").start();

        // 线程C
        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) a.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "C").start();

        // 线程D
        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) a.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "D").start();
    }
}

执行后结果如下

原因是因为出现了虚假唤醒问题

if只会判断一次，while在等待状态下依然循环判断着

 代码if替换为while后运行成功

package com.test.rabbitmq.lockTest;

/**
 * @author ME
 * @date 2022/2/5 20:26
 */
public class A {
    private int number = 0;
    // 方法1,当number不为0时进行等待，当number等于0时进行+1操作，然后释放锁，唤醒其他等待线程
    public synchronized void increment() throws InterruptedException {
        while (number != 0) {
            // 进行线程等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "执行完毕，当前number的值为：" + number);
        // 唤醒其他线程
        this.notifyAll();
    }
    // 方法2，当number为0时进行等待，当number不为0时进行-1操作，然后释放锁，唤醒其他等待线程
    public synchronized void decrement() throws InterruptedException {
        while (number == 0) {
            // 进行线程等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "执行完毕，当前number的值为：" + number);
        // 唤醒其他线程
        this.notifyAll();
    }
}

运行结果如下

 上述的代码我们使用了synchronized与wait()方法与notify()方法用来进行线程间的通信，那么在JUC中有没有同等替代的方法呢？答案是肯定有的，在JUC中用Lock来替代synchronized，那么其他方法也同样可以使用await()与signal()方法进行替代。

下面为两种代码的对比

package com.test.rabbitmq.lockTest;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author ME
 * @date 2022/2/5 20:26
 */
public class A {
    private int number = 0;

    // 使用synchronized + wait + notify方式
    // 方法1,当number不为0时进行等待，当number等于0时进行+1操作，然后释放锁，唤醒其他等待线程
    public synchronized void increment() throws InterruptedException {
        while (number != 0) {
            // 进行线程等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "执行完毕，当前number的值为：" + number);
        // 唤醒其他线程
        this.notifyAll();
    }
    // 使用lock锁 + await + signal 方式
    // 方法2，当number为0时进行等待，当number不为0时进行-1操作，然后释放锁，唤醒其他等待线程
    // 创建锁对象
    ReentrantLock lock = new ReentrantLock();
    // 创建对象监视器对象，相比于notify()来说signal()可以唤醒指定线程
    Condition condition = lock.newCondition();
    
    public void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (number == 0) {
                // 进行线程等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "执行完毕，当前number的值为：" + number);
            // 唤醒其他线程 与notify-notifyAll相同，JUC有signal-signalAll
            condition.signalAll();
        }catch (Exception e) {
        }finally {
            lock.unlock();
        }
    }
}

 condition类如何进行指定线程唤醒

我们上面了解到了notify()只能进行随机唤醒，condition可以进行指定唤醒，那么他如何使用呢？代码如下，通过创建多个Condition类进行区分后进行指定唤醒

package com.test.rabbitmq.lockTest;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author ME
 * @date 2022/2/5 20:26
 */
public class A {
    private int number = 0;
    // 创建锁对象
    ReentrantLock lock = new ReentrantLock();
    // 创建increment对象监视器对象
    Condition incrementCondition = lock.newCondition();
    // 创建decrement对象监视器对象
    Condition decrementCondition = lock.newCondition();

    // 使用lock锁 + await + signal 方式
    // 方法1,当number不为0时进行等待，当number等于0时进行+1操作，然后释放锁，唤醒其他等待线程
    public void increment() throws InterruptedException {
        lock.lock();
        try {
            while (number != 0) {
                // 本方法的对象监视器进行线程等待
                incrementCondition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "执行完毕，当前number的值为：" + number);
            // 唤醒其他线程 与notify-notifyAll相同，JUC有signal-signalAll
            // 指定唤醒decrement方法
            decrementCondition.signal();
        }catch (Exception e) {
        }finally {
            lock.unlock();
        }
    }

    // 使用lock锁 + await + signal 方式
    // 方法2，当number为0时进行等待，当number不为0时进行-1操作，然后释放锁，唤醒其他等待线程
    public void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (number == 0) {
                // 本方法的对象监视器进行线程等待
                decrementCondition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "执行完毕，当前number的值为：" + number);
            // 唤醒其他线程 与notify-notifyAll相同，JUC有signal-signalAll
            // 指定唤醒increment方法
            incrementCondition.signal();
        }catch (Exception e) {
        }finally {
            lock.unlock();
        }
    }
}

锁的常见问题解决

1.同一个对象的synchronized方法在多个线程中调用，先启动的先执行

原因：synchronized锁的对象是方法的调用对象，谁调用此方法就锁谁，如果创建两个对象则互不影响，又或者执行普通方法也不需要等待，但如果是同一个对象，哪怕使用sleep()方法睡眠了，其他线程也必须等待此线程睡眠时间到了执行完毕后再进行执行。

当synchronized锁的是静态方法，此时锁的即为class对象，锁了这个类。他跟锁普通方法的区别为当synchronized锁住了方法但是就算创建了两个对象，也会互相影响，因为他们共用一个class类。

同一个类中，synchronized锁住了类时，与他的实例对象互不干扰，实例对象正常上锁正常使用。