JUC - 类汇总和学习指南 | Java 全栈知识体系什么是JUC 线程和进程 Lock锁（重点）生产者和消费者问题

什么是JUC
线程和进程
Lock锁（重点）
生产者和消费者问题
8锁现象
集合类不安全 Callable 常用的辅助类(必会)
读写锁阻塞队列
线程池(重点)
四大函数式接口（必需掌握）
Stream流式计算 ForkJoin 异步回调 JMM Volatile 彻底玩转单例模式
深入理解CAS 原子引用
各种锁的理解：公平锁、非公平锁、可重入锁、自旋锁、死锁

业务：普通的线程代码 Thread

Runnable 没有返回值、效率相比入 Callable 相对较低！

进程和线程

进程：一个程序，QQ.exe Music.exe 程序的集合；

一个进程往往可以包含多个线程，至少包含一个！

Java默认有几个线程？ 2 个 mian、GC

线程：开了一个进程 Typora，写字，自动保存（线程负责的）

对于Java而言：Thread、Runnable、Callable

并发编程：并发、并行

并发（多线程操作同一个资源）

CPU 一核，模拟出来多条线程，天下武功，唯快不破，快速交替

并行（多个人一起行走）

CPU 多核，多个线程可以同时执行；线程池

线程有几个状态

` public enum State {

// 新生

NEW, // 运行

RUNNABLE,

// 阻塞

BLOCKED,

// 等待，死死地等

WAITING,

// 超时等待

TIMED_WAITING,

// 终止

TERMINATED;

} `

wait/sleep 区别

1、来自不同的类

wait => Object
sleep => Thread

2、关于锁的释放

wait 会释放锁，sleep 睡觉了，抱着锁睡觉，不会释放！

3、使用的范围是不同的

wait 必须在同步代码块中使用
sleep 可以再任何地方睡

4、是否需要捕获异常

wait 不需要捕获异常
sleep 必须要捕获异常

传统 Synchronized

/**

* 真正的多线程开发，公司中的开发，降低耦合性

* 线程就是一个单独的资源类，没有任何附属的操作！

* 1、 属性、方法

*/

public class SaleTicketDemo01 {

public static void main(String[] args) {

// 并发：多线程操作同一个资源类, 把资源类丢入线程

Ticket ticket = new Ticket();

// @FunctionalInterface 函数式接口，jdk1.8 lambda表达式 (参数)->{ 代码 }

new Thread(()->{

for (int i = 1; i < 40 ; i++) {

ticket.sale();

}

},"A").start();

new Thread(()->{

for (int i = 1; i < 40 ; i++) {

ticket.sale();

}

},"B").start();

new Thread(()->{

for (int i = 1; i < 40 ; i++) {

ticket.sale();

}

},"C").start();

}

}

// 资源类 OOP

class Ticket {

// 属性、方法

private int number = 30;

// 卖票的方式

// synchronized 本质: 队列，锁

public synchronized void sale(){

if (number>0){

System.out.println(Thread.currentThread().getName()+"卖出了"+(number-

-)+"票,剩余："+number);

}

}

}

Lock 接口

公平锁：十分公平：可以先来后到

非公平锁：十分不公平：可以插队（默认）

package com.kuang.demo01;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class SaleTicketDemo02 {

public static void main(String[] args) {

// 并发：多线程操作同一个资源类, 把资源类丢入线程

Ticket2 ticket = new Ticket2();

// @FunctionalInterface 函数式接口，jdk1.8 lambda表达式 (参数)->{ 代码 }

new Thread(()->{for (int i = 1; i < 40 ; i++)

ticket.sale();},"A").start();

new Thread(()->{for (int i = 1; i < 40 ; i++)

ticket.sale();},"B").start();

new Thread(()->{for (int i = 1; i < 40 ; i++)

ticket.sale();},"C").start();

}

}

// Lock三部曲

// 1、 new ReentrantLock();

// 2、 lock.lock(); // 加锁

// 3、 finally=> lock.unlock(); // 解锁

class Ticket2 {

// 属性、方法

private int number = 30;

Lock lock = new ReentrantLock();

public void sale(){

lock.lock(); // 加锁

try {

// 业务代码

if (number>0){

System.out.println(Thread.currentThread().getName()+"卖出了"+

(number--)+"票,剩余："+number);

}

} catch (Exception e) {

e.printStackTrace();

} finally {

lock.unlock(); // 解锁

}

}

}

Synchronized 和 Lock 区别

1、Synchronized 内置的Java关键字， Lock 是一个Java类

2、Synchronized 无法判断获取锁的状态，Lock 可以判断是否获取到了锁

3、Synchronized 会自动释放锁，lock 必须要手动释放锁！如果不释放锁，死锁

4、Synchronized 线程 1（获得锁，阻塞）、线程2（等待，傻傻的等）；Lock锁就不一定会等待下去；

5、Synchronized 可重入锁，不可以中断的，非公平；Lock ，可重入锁，可以判断锁，非公平（可以自己设置）；

6、Synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码！

锁是什么，如何判断锁的是谁！

面试的：单例模式、排序算法、生产者和消费者、死锁

生产者和消费者问题 Synchronized 版

package com.kuang.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) {

e.printStackTrace();

}

}

},"A").start();

new Thread(()->{

for (int i = 0; i < 10; i++) {

try {

data.decrement();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

},"B").start();

}

}

// 判断等待，业务，通知

class Data{ // 数字 资源类

private int number = 0;

//+1

public synchronized void increment() throws InterruptedException {

if (number!=0){ //0

// 等待

this.wait();

}

number++;

System.out.println(Thread.currentThread().getName()+"=>"+number);

// 通知其他线程，我+1完毕了

this.notifyAll();

}

//-1

public synchronized void decrement() throws InterruptedException {

if (number==0){ // 1

// 等待

this.wait();

}

number--;

System.out.println(Thread.currentThread().getName()+"=>"+number);

// 通知其他线程，我-1完毕了

this.notifyAll();

}

}

if 改为 while 判断

package com.kuang.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) {

e.printStackTrace();

}

}

},"A").start();

new Thread(()->{

for (int i = 0; i < 10; i++) {

try {

data.decrement();

} catch (InterruptedException e) {

e.printStackTrace();

}}

}

},"B").start();

new Thread(()->{

for (int i = 0; i < 10; i++) {

try {

data.increment();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

},"C").start();

new Thread(()->{

for (int i = 0; i < 10; i++) {

try {

data.decrement();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

},"D").start();

}

}

// 判断等待，业务，通知

class Data{ // 数字 资源类

private int number = 0;

//+1

public synchronized void increment() throws InterruptedException {

while (number!=0){ //0

// 等待

this.wait();

}

number++;

System.out.println(Thread.currentThread().getName()+"=>"+number);

// 通知其他线程，我+1完毕了

this.notifyAll();

}

//-1

public synchronized void decrement() throws InterruptedException {

while (number==0){ // 1

// 等待

this.wait();

}

number--;

System.out.println(Thread.currentThread().getName()+"=>"+number);

// 通知其他线程，我-1完毕了

this.notifyAll();

}

}