JUC并发多线程进阶

最新推荐文章于 2022-07-29 18:25:26 发布

早上真起不来！

最新推荐文章于 2022-07-29 18:25:26 发布

阅读量260

点赞数 1

分类专栏： Java基础文章标签： juc 锁多线程

本文链接：https://blog.csdn.net/qq_51998352/article/details/117753967

版权

本文详细探讨了Java并发多线程的高级话题，包括JUC库的使用，如Lock锁、生产者消费者问题、并发集合的不安全性及其解决方案、线程池的配置与优化，以及CountDownLatch、Semaphore等辅助类的应用。通过实例解析了并发编程中的常见问题，如虚假唤醒、线程池拒绝策略、读写锁和阻塞队列，还涵盖了函数式接口、Stream流式计算以及Volatile、CAS等并发原理解析。

摘要由CSDN通过智能技术生成

笔记整理来源 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(

最低0.47元/天解锁文章

早上真起不来！

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
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一个进程可
复制链接

扫一扫