JUC并发多线程进阶
笔记整理来源 B站UP主狂神说Java https://space.bilibili.com/95256449/
JUC并发多线程进阶
1、什么是JUC
源码+官方文档
JUC是 java util concurrent
面试高频问JUC~！
java.util 是Java的一个工具包~
业务：不会通过普通的线程代码 Thread 来实现
Runnable： 没有返回值、效率相比于Callable 相对较低！
2、线程和进程
进程：一个程序，QQ.exe Music.exe；数据+代码+pcb
一个进程可以包含多个线程，至少包含一个线程！
Java默认有几个线程？2个线程！ main线程、GC线程
线程：开了一个进程Typora，写字，等待几分钟会进行自动保存(线程负责的)
对于Java而言：Thread、Runable、Callable进行开启线程的，我们之前。
提问？JAVA真的可以开启线程吗？ 开不了的！
public synchronized void start() {
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
throw new IllegalThreadStateException();
/* Notify the group that this thread is about to be started
* so that it can be added to the group's list of threads
* and the group's unstarted count can be decremented. */
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}
//这是一个C++底层，Java是没有权限操作底层硬件的
private native void start0();
Java是没有权限去开启线程、操作硬件的(因为java运行在jvm上的)，这是一个native的一个本地方法，它调用的底层的C++代码。
并发、并行
并发： 多线程操作同一个资源。
- CPU 只有一核，模拟出来多条线程。那么我们就可以使用CPU快速交替，来模拟多线程。
并行： 多个人一起行走
- CPU多核，多个线程可以同时执行。 我们可以使用线程池！
public class Test1 {
public static void main(String[] args) {
//获取cpu的核数
System.out.println(Runtime.getRuntime().availableProcessors());
}
}
并发编程的本质：充分利用CPU的资源！
线程有几个状态？
线程的状态：6个状态
public enum State {
NEW, //新生
RUNNABLE, //运行
BLOCKED, //阻塞
WAITING, //等待 死死的等
TIMED_WAITING, //超时等待
TERMINATED; //终止
}
wait/sleep的区别
1、来自不同的类
wait => Object
sleep => Thread
一般情况企业中使用休眠是：
TimeUnit.DAYS.sleep(1); //休眠1天
TimeUnit.SECONDS.sleep(1); //休眠1s
2、关于锁的释放
wait 会释放锁；
sleep睡觉了，不会释放锁；
3、使用的范围是不同的
wait 必须在同步代码块中；
sleep 可以在任何地方睡；
3、Lock锁（重点）
传统的Synchronized
/**
* 真正的多线程开发,公司开发降低耦合性
* 线程就是一个单独的资源类，没有任何的附属操作！
*/
public class SaleTicketDemo01 {
public static void main(String[] args) {
//多线程操作
//并发：多线程操作同一个资源类，把资源类丢入线程
Ticket ticket = new Ticket();
//@FunctionalInterface 函数式接口 jdk1.8之后 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();
}
}
//资源类
//属性+方法
//oop 面向对象 不在是继承或者是实现什么接口 类变得很纯粹 降低耦合性
class Ticket{
private int number=50;
//卖票的方式
// synchronized 本质：队列 排队，锁
public synchronized void sale(){
if(number>0){
System.out.println(Thread.currentThread().getName()+" 卖出了第"+number+" 张票,剩余："+--number+" 张票");
}
}
}
Lock接口
公平锁： 十分公平， 必须先来后到~；
非公平锁： 十分不公平，可以插队；(默认为非公平锁)
package com.liu;
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();
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三部曲
//1、 Lock lock=new ReentrantLock();
//2、 lock.lock() 加锁
//3、 finally=> 解锁：lock.unlock();
class Ticket2{
private int number=50;
Lock lock=new ReentrantLock();
//卖票的方式
// 使用Lock 锁
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 就不一定会一直等待下去，Lock会有一个trylock去尝试获取锁，不会造成长久的等待。
-
5、Synchronized 可重入锁，不可以中断的，非公平的；
Lock 可重入锁，可以判断锁，可以自己设置公平锁和非公平锁；
-
6、Synchronized 适合锁少量的代码同步问题
Lock 适合锁大量的同步代码；
锁到底是什么？ 如何判断锁的是谁？
4、生产者和消费者问题！
面试高频：单例模式、八大排序算法、生产者和消费者、死锁
Synchronized wait notify可以实现，该方法是传统版本；
Synchronized版本
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){
//等待操作
this.wait();
}
number++;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他线程 我+1完毕了
this.notifyAll();
}
//-1
public synchronized void decrement() throws InterruptedException {
if(number==0){
//等待操作
this.wait();
}
number--;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他线程 我-1完毕了
this.notifyAll();
}
}
问题存在，A线程B线程，现在如果我有四个线程A B C D！
解决方案： if 改为while即可，防止虚假唤醒
这样就不存在问题了
什么是虚假唤醒
假如被阻塞的多个线程都被唤醒，但实际情况是被唤醒的线程中有一部分线程是不应该被唤醒的，那么对于这些不应该被唤醒的线程而言就是虚假唤醒
为什么会存在虚假唤醒
Object.wait会自动释放锁，并请求操作系统挂起当前线程，从而使得其他线程能够获取这个锁并修改对象的状态
因为if判断在值发生改变的时候，它不会停，只判断一次
而 while 在值发生改变的时候 会进行等待 不会出现两个线程同时去操作我们的属性值
if和while的区别
- while是用来做循环的，也就是说只要条件满足，就会执行一次循环体，执行完以后会再判断一次条件，如果满足条件，还会再执行一次，终而复始，除非你在循环中对条件进行了改变才会从循环中跳出来。
- if只做一次判断，条件不满足就不执行，满足就执行一次，执行完就往下执行，不会再回过头来继续执行。
JUC版本的生产者和消费者问题
await、signal 替换 wait、notify
通过Lock找到Condition
package com.liu;
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++) {
data.increment();
}
},"A").start();
new Thread(()->{
for(int i=0;i<10;i++) {
data.decrement();
}},"B").start();
new Thread(()->{
for(int i=0;i<10;i++) {
data.increment();
}
},"C").start();
new Thread(()->{
for(int i=0;i<10;i++) {
data.decrement();
}
},"D").start();
}
}
class Data2{
//数字 资源类
private int number = 0;
//lock锁
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
//+1
public void increment() {
lock.lock();
try{
//业务
while (number!=0){
//等待操作
condition.await();
}
number++;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他线程 我+1完毕了
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
//-1
public void decrement() {
lock.lock();
try{
//业务
while (number==0){
//等待操作
condition.await();
}
number--;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他线程 我+1完毕了
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
Condition的优势：精准的通知和唤醒的线程！
如果我们要指定通知的下一个进行顺序怎么办呢？ 我们可以使用Condition来指定通知进程~
package com.liu;
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) {
Data3 data3 = new Data3();
new Thread(()->{
for(int i=0;i<10;i++){
data3.printA();
}
},"A").start();
new Thread(()->{
for(int i=0;i<10;i++){
data3.printB();
}
},"B").start();
new Thread(()->{
for(int i=0;i<10;i++){
data3.printC();
}
},"C").start();
}
}
class Data3{
//资源类
private Lock lock=new ReentrantLock();
private Condition condition1 = lock.newCondition();
private Condition condition2 = lock.newCondition();
private Condition condition3 = lock.newCondition();
private int number = 1; //1A 2B 3C
public void printA(){
lock.lock();
try {
//业务 判断 -> 执行 -> 通知
while(number!=1){
//等待
condition1.await();
}
//操作
System.out.println(Thread.currentThread().getName()+",AAAAA");
//唤醒指定的线程
number=2;
condition2.signal(); // 唤醒2
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printB(){
lock.lock();
try {
//业务 判断 -> 执行 -> 通知
while (number!=2){
condition2.await();
}
System.out.println(Thread.currentThread().getName()+",BBBBB");
//唤醒3
number=3;
condition3.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printC(){
lock.lock();
try {
//业务 判断 -> 执行 -> 通知
while(number!=3){
condition3.await();
}
System.out.println(Thread.currentThread().getName()+",CCCCC");
//唤醒1
number=1;
condition1.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
5、八锁现象
八锁 就是关于锁的八个问题
如何判断锁的是谁！锁到底锁的是谁？
锁会锁住：对象、Class
深刻理解我们的锁
- 问题1：
package com.liu;
import java.util.concurrent.TimeUnit;
/*
* 八锁 就是关于锁的八个问题*/
public class Test1 {
public static void main(String[] args) throws InterruptedException {
Phone phone = new Phone();
new Thread(()->{
phone.sendSms();
},"A").start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
phone.call();
},"B").start();
}
}
class Phone{
public synchronized void sendSms(){
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
结果是：先发短信，如何再打电话！
为什么？ 是因为顺序在前吗？不， 这个答案是错误的！
- 问题2：
我们再来看：我们让发短信 延迟4s
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
现在结果是什么呢？
结果：还是先发短信，然后再打电话！
why？
原因：并不是顺序执行！是因为synchronized 锁的对象是方法的调用者！对于两个方法用的是同一个锁，谁先拿到谁先执行！另外一个则等待！
- 问题3：
如果我们添加一个普通方法，那么先执行哪一个呢？
package com.liu;
import java.util.concurrent.TimeUnit;
public class Test1 {
public static void main(String[] args) throws InterruptedException {
Phone phone = new Phone();
new Thread(()->{
phone.sendSms();
},"A").start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
phone.hello();
},"B").start(