JUC并发编程——JUC并发编程概述及Lock锁（重点）（基于狂神说的学习笔记）
基于bilibili狂神说JUC并发编程视频所做笔记
概述
什么是JUC
JUC时java.util工具包中的三个包的简称
java.util.concurrent
java.util.concurrent.atomic
java.util.concurrent.locks
业务：普通的线程代码中，我们常使用Runnable接口
但Runnable没有返回值，且效率相比较于Callable来说相对较低，功能也没有Callable强大
线程和进程
进程：相当于一个程序
一个进程当中往往可以包含多个线程，且至少包含一个线程
Java默认有2个线程：mian（主线程），GC（垃圾回收）
Java真的可以开启线程吗？
java是无法开启线程的，Java运行在JVM（虚拟机）之上，无法直接操作硬件，因此其实际上是无法开启线程的，在我们无论使用Runnable接口还是继承Thread，用start()方法开启线程，其本质上都是调用==private native void start0()==方法，而该方法是本地方法，是运行底层的C++
并发编程：
并发与并行：
并发：（多个线程同时操作一个核）
- CPU一核，快速交替轮换，模拟多核
并行：（多个线程操作多个核）
- CPU多核，可以多个线程同时执行；引入线程池的概念
查看自己CPU核数：
public class Test1 {
public static void main(String[] args) {
// 获取CPU的核数
// COU 密集型，IO密集型
System.out.println(Runtime.getRuntime().availableProcessors());
}
}
并发编程的本质：充分利用CPU的资源
线程有几个状态
答： 6个，分别为：NEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED
public enum State{
/**
* Thread state for a thread which has not yet started.
*/
NEW,
/**
* Thread state for a runnable thread. A thread in the runnable
* state is executing in the Java virtual machine but it may
* be waiting for other resources from the operating system
* such as processor.
*/
RUNNABLE,
/**
* Thread state for a thread blocked waiting for a monitor lock.
* A thread in the blocked state is waiting for a monitor lock
* to enter a synchronized block/method or
* reenter a synchronized block/method after calling
* {@link Object#wait() Object.wait}.
*/
BLOCKED,
/**
* Thread state for a waiting thread.
* A thread is in the waiting state due to calling one of the
* following methods:
*
* - {@link Object#wait() Object.wait} with no timeout
* - {@link #join() Thread.join} with no timeout
* - {@link LockSupport#park() LockSupport.park}
*
*
* A thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called {@code Object.wait()}
* on an object is waiting for another thread to call
* {@code Object.notify()} or {@code Object.notifyAll()} on
* that object. A thread that has called {@code Thread.join()}
* is waiting for a specified thread to terminate.
*/
WAITING,
/**
* Thread state for a waiting thread with a specified waiting time.
* A thread is in the timed waiting state due to calling one of
* the following methods with a specified positive waiting time:
*
* - {@link #sleep Thread.sleep}
* - {@link Object#wait(long) Object.wait} with timeout
* - {@link #join(long) Thread.join} with timeout
* - {@link LockSupport#parkNanos LockSupport.parkNanos}
* - {@link LockSupport#parkUntil LockSupport.parkUntil}
*
*/
TIMED_WAITING,
/**
* Thread state for a terminated thread.
* The thread has completed execution.
*/
TERMINATED;
}
WAITING 与 TIMED_WAITING的区别为：
WAITING会一直等待唤醒，或其他线程，资源的响应
TIMED_WAITING为超时等待，一旦时间到，则不再等待
wait/sleep的区别
- 来自不同的类
wait 来自Object类
sleep来自Thread类
- 关于锁的释放
wait会释放锁
sleep不会释放锁，抱着锁睡觉
- 使用的范围是不同的
wait 必须在同步代码块中使用
sleep 可以在任何地方睡
- 是否需要捕获异常
wait不需要捕获异常
sleep必须要捕获异常
（但是，只要与线程有关的操作，都要捕获中断异常）
Lock锁（重点）
回顾synchronized
传统Synchronized
package syn;
// OOP并发编程
public class SaleTicketDemo01 {
public static void main(String[] args) {
// 声明一个票对象，使3个线程可以调用买票方法
Ticket ticket = new Ticket();
// 使用lambda表达式，回顾：lambda表达式是一种极简的表达艺术，但仅用于函数式接口
new Thread(()->{
for (int i = 0; i < 40; i++) {
ticket.sale();
}
},"A").start();
new Thread(()->{
for (int i = 0; i < 40; i++) {
ticket.sale();
}
},"B").start();
new Thread(()->{
for (int i = 0; i < 40; i++) {
ticket.sale();
}
},"C").start();
}
}
// 高耦合，对象及为对象，不要附加多余功能，不要将其变成线程类
class Ticket{
// 属性、方法
private int ticketNums = 30;
// synchronized 本质就是锁，队列
public synchronized void sale(){
if (ticketNums > 0) {
System.out.println(Thread.currentThread().getName()+" sales "+ticketNums--+",and remains"+ticketNums);
}
}
}
Lock锁实现线程安全示例
java.util.concurrent.locks下有三个接口
- Condition
- Lock
- ReadWriteLock
Lock接口
实现类：
- ReentranLock（可重入锁）
- ReentrantReadWriteLock.ReadLock（读锁）
- ReentrantReadWriteLock.WriteLock（写锁）
在ReentrantLock中，其构造函数：
公平锁：先到先得
非公平锁（默认）：可以插队，看CPU调度
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockDemo02 {
public static void main(String[] args) {
// 声明一个票对象，使3个线程可以调用买票方法
Ticket ticket = new Ticket();
// 使用lambda表达式，回顾：lambda表达式是一种极简的表达艺术，但仅用于函数式接口
new Thread(()->{for (int i = 0; i < 40; i++) ticket.sale();},"A").start();
new Thread(()->{for (int i = 0; i < 40; i++) ticket.sale();},"B").start();
new Thread(()->{for (int i = 0; i < 40; i++) ticket.sale();},"C").start();
}
}
// 高耦合，对象及为对象，不要附加多余功能，不要将其变成线程类
// 使用lock锁
/*
Lock三部曲
1、 new ReentrantLock()
2、 lock.lock()
3、 finally => lock.unlock()
*/
class Ticket{
// 属性、方法
private int ticketNums = 30;
Lock lock = new ReentrantLock();
// synchronized 本质就是锁，队列
public void sale(){
lock.lock();// 加锁
try {
//业务代码
if (ticketNums > 0) {
System.out.println(Thread.currentThread().getName()+" sales "+ticketNums--+",and remains"+ticketNums);
}
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
lock.unlock();// 解锁
}
}
}
Lock与synchronized的区别
1、synchronized内置的Java关键字；而Lock是一个Java类
2、synchronized无法判断获取锁的状态；Lock可以判断是否获取到了锁
3、synchronized会自动释放锁；Lock必须手动释放锁，如果不释放锁，则会造成死锁
4、synchronized线程1（获得锁），线程2（一直等待）； Lock锁时，线程2就不一定会等待下去
5、synchronized可重入锁，不可中断的，非公平锁（不可更改）；Lock，可重入锁，可以判断锁，默认非公平（可以修改）
6、synchronized适合锁少量的代码同步问题；Lock锁适合锁大量的同步代码
锁是什么，如何判断锁的是谁
看8锁现象！！！
生产者和消费者问题
生产者消费者问题 synchronized版
package PC;
/**
* 线程之间的通信问题：生产者和消费者问题 等待唤醒 通知唤醒
* 线程交替执行 A B 操作同一个变量 num = 0
* A num+1
* B num-1
*/
public class A {
public static void main(String[] args) {
Data data = new Data();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.increment();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"A").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"B").start();
}
}
// 口诀：等待，业务，通知
// 资源类
class Data{
private int number = 0;
// +1操作
public synchronized void increment() throws InterruptedException {
// 等待
if (number != 0){
this.wait();
}
// 业务
number++;
System.out.println(Thread.currentThread().getName()+"=>"+number);
// 通知其他线程，我加一完毕
this.notifyAll();
}
// -1操作
public synchronized void decrement() throws InterruptedException {
// 等待
if (number == 0){
this.wait();
}
// 业务
number--;
System.out.println(Thread.currentThread().getName()+"=>"+number);
// 通知其他线程，我减一完毕
this.notifyAll();
}
}
这真的线程安全吗？如果有四个线程同时跑呢？
答：不安全，当四个线程在跑时，则会出现意料之外的情况
为什么会产生这种情况？
答：造成这种现象的原因是虚假唤醒
什么是虚假唤醒？
多线程环境下，有多个线程执行了wait()方法，需要其他线程执行notify()或者notifyAll()方法去唤醒它们，假如多个线程都被唤醒了，但是只有其中一部分是有用的唤醒操作，其余的唤醒都是无用功；对于不应该被唤醒的线程而言，便是虚假唤醒。
比如：仓库有货了才能出库，突然仓库入库了一个货品；这时所有的线程（货车）都被唤醒，来执行出库操作；实际上只有一个线程（货车）能执行出库操作，其他线程都是虚假唤醒。
参考博客：Java线程虚假唤醒是什么、如何避免？_java 虚假唤醒_秃秃爱健身的博客-CSDN博客
很重要：以下是个人感悟！
其实当初笔者在此处还是很困惑的，为什么虚假唤醒会造成线程同时运行而不顾if条件语句，后来笔者意识到一个很重要的问题：“wait()方法会使线程放弃锁”。也就是说，当A线程拿到了同步锁之后，进入if条件语句判断，如果此时条件为true，它会进入waiting状态并放弃同步锁，因此，C线程在这段时间有可能会乘虚而入，抢在B线程或D线程将A线程唤醒前进入同步代码块，同样进入if语句的waiting状态，之后，B线程或D线程完成其业务逻辑后，执行notifyAll()方法，就会将A线程与C线程同时唤醒，然后两者都会执行业务逻辑，导致一次减，两次加，与我们的预期（我们的逻辑是加一次，减一次）不符。因此线程不安全。
以上解释只是个人猜想，还未曾验证过，比如将wait换成sleep，抱着线程休眠是否会出现同样的问题
如何避免虚假唤醒？
将if条件语句改为while循环语句
当使用if条件语句时，如果线程在if条件语句中被wait中断退出，当其重新进入回到它原本所在的位置后就会发现，它已经进行过判断了，接下来，就算已经有线程抢先一步操作，它也会义无反顾地往下走，因为没有条件能够拦住它啦！
而当我们使用while循环语句会发现：（以下是官方文档所给的推荐代码）
synchronized (obj) {
while (<condition does not hold> and <timeout not exceeded>) {
long timeoutMillis = ... ;
// recompute timeout values int nanos = ... ;
obj.wait(timeoutMillis, nanos);
}
... // Perform action appropriate to condition or timeout
}
如果线程在while循环中被wait中断退出，当其重新进入回到它原本所在的位置后就会发现，本次循环已经结束，**接下来并不是执行后面的业务代码，而是返回到while循环开头，重新判断一次是否满足条件。**这样的操作就保证了即使在退出重进，也会进行再一次的判断确保线程安全。
以下为示例中被修改的代码片段：
public synchronized void increment() throws InterruptedException {
// 等待
// ***************** 此处的if被改为while **********************
while (number != 0){
this.wait();
}
// 业务
number++;
System.out.println(Thread.currentThread().getName()+"=>"+number);
// 通知其他线程，我加一完毕
this.notifyAll();
}
// -1操作
public synchronized void decrement() throws InterruptedException {
// 等待
// ***************** 此处的if被改为while **********************
while (number == 0){
this.wait();
}
// 业务
number--;
System.out.println(Thread.currentThread().getName()+"=>"+number);
// 通知其他线程，我减一完毕
this.notifyAll();
}
生产者消费者问题 JUC版
对应于synchronized，JUC版本下，Lock锁也有对应的唤醒与停止方法，分别是condition接口下的signal()与await()
以下是官方文档的描述：
示例代码如下：
package PC;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class B {
public static void main(String[] args) {
Data2 data = new Data2();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.increment();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"A").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"B").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.increment();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"C").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"D").start();
}
}
// 口诀：等待，业务，通知
// 资源类
class Data2{
private int number = 0;
Lock lock = new ReentrantLock();
// +1操作
public void increment() throws InterruptedException {
Condition condition = lock.newCondition();
/**
* condition.await(); 等待
* condition.signalAll(); 唤醒全部
*/
try {
lock.lock();
// =============== 业务代码 ==================
// 等待
while (number != 0){
condition.await();
}
// 业务
number++;
// 通知其他线程，我加一完毕
System.out.println(Thread.currentThread().getName()+"=>"+number);
// ===========================================
} catch (Exception e) {
throw new RuntimeException(e);
}finally{
lock.unlock();
}
}
// -1操作
public void decrement() throws InterruptedException {
Condition condition = lock.newCondition();
try {
lock.lock();
// =============== 业务代码 ==================
// 等待
while (number == 0){
}
// 业务
number--;
// 通知其他线程，我减一完毕
System.out.println(Thread.currentThread().getName()+"=>"+number);
// ===========================================
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
}
}
Condition 的优势在哪里
可以实现精准的通知和唤醒线程
以下示例实现精准唤醒线程，在A线程执行完后精准唤醒B线程执行，B线程执行完后精准唤醒C线程执行，C线程执行完后精准唤醒A线程执行
package PC;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* A 执行完调用 B，B 执行完调用 C，C 执行调用 A
*/
public class C {
public static void main(String[] args) {
// new 资源类
Data3 data = new Data3();
// 创建线程并执行线程
new Thread(()->{for (int i = 0; i < 5; i++) data.printA();},"A").start();
new Thread(()->{for (int i = 0; i < 5; i++) data.printB();},"B").start();
new Thread(()->{for (int i = 0; i < 5; i++) data.printC();},"C").start();
}
}
//资源类
class Data3{
private Lock lock = new ReentrantLock();
private Condition conditionA = lock.newCondition();
private Condition conditionB = lock.newCondition();
private Condition conditionC = lock.newCondition();
private int number = 1; // 若number=1则A执行，若number=2则B执行，若number=3则C执行
public void printA(){
lock.lock();
try {
// 业务， 判断->执行->通知
while(number != 1){
conditionA.await();
}
System.out.println(Thread.currentThread().getName()+" now is AAAAA time!");
// 唤醒指定的线程B
number ++;
conditionB.signal();
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
}
public void printB(){
lock.lock();
try {
while(number != 2){
conditionB.await();
}
System.out.println(Thread.currentThread().getName()+"now is BBBBB time!");
// 唤醒指定线程C
number++;
conditionC.signal();
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
}
public void printC(){
lock.lock();
try {
while(number != 3){
conditionC.await();
}
System.out.println(Thread.currentThread().getName()+"now is CCCCC time!");
number = 1;
conditionA.signal();
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
}
}
总结：
- Lock锁与synchronized锁的区别要分清
- 在多线程情况下，不要使用if条件语句来判断是否wait或await某一线程，要用while循环语句来判断，否则线程不安全
- Lock锁下，使用await与signal等价于wait和notify，但有所区别，Lock锁更加灵活和可以精准唤醒某些线程