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() + "核");}
}

线程的状态有几种

名称	含义
NEW	新生
RUNNABLE	运行
BLOCKED	阻塞
WAITING	等待
TIMED_WAITING	超时等待
TERMINATED	终止

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	可重入锁
ReentrantReadWriteLock.ReadLock	读锁
ReentrantReadWriteLock.WriteLock	写锁

我们再来查看ReentrantLock的源码

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

公平锁	先来先得，必须要排队，谁先来的谁先执行
非公平锁	可以进行插队，性能大大高于公平锁，synchronized锁与JUC中的lock锁默认都使用的非公平锁

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() {// 上锁 放在方法内，后面紧随tryCatchlock.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();// 线程Anew Thread(() -> {try {for (int i = 0; i < 10; i++) a.increment();} catch (InterruptedException e) {e.printStackTrace();}}, "A").start();// 线程Bnew 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();// 线程Anew Thread(() -> {try {for (int i = 0; i < 10; i++) a.increment();} catch (InterruptedException e) {e.printStackTrace();}}, "A").start();// 线程Bnew Thread(() -> {try {for (int i = 0; i < 10; i++) a.decrement();} catch (InterruptedException e) {e.printStackTrace();}}, "B").start();// 线程Cnew Thread(() -> {try {for (int i = 0; i < 10; i++) a.decrement();} catch (InterruptedException e) {e.printStackTrace();}}, "C").start();// 线程Dnew 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-signalAllcondition.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锁住了类时，与他的实例对象互不干扰，实例对象正常上锁正常使用。