JUC并发编程 进阶

置顶 已于 2022-03-06 14:33:28 修改
阅读量696 收藏
点赞数 2
分类专栏： Java学习 文章标签： b树 数据库 数据结构
于 2022-03-06 11:45:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ctrl_kun/article/details/123307582
版权
本文深入探讨JUC并发编程，涵盖线程、进程、Lock、并发控制、线程池、函数式接口、流式计算等关键概念。讲解了Lock与synchronized的区别，强调了并发编程中锁的状态判断和精准通知。还介绍了线程池的原理和使用，以及四大函数式接口的应用。最后讨论了JMM、Volatile特性以及并发编程中的常见问题，如ABA问题和死锁。
摘要由CSDN通过智能技术生成

文章目录

JUC并发编程 进阶

jdk环境

保证项目JDK至少有1.8 Project和Moudle都要设置好

在这里插入图片描述

什么是JUC？

源码+官方文档 面试高频

在这里插入图片描述

java.util工具包

业务：普通的线程代码 Thread

Runnable 没有返回值，效率相比Callable低！

线程和进程

线程，进程，如果不能用一句话说出来的技术说明不扎实！

进程：一个进程，QQ.exe Music.exe 程序的集合，运行中的程序

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

java默认有几个线程呢？2个 main+GC

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

Thread、Runnable、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();

并发 并行

并发编程：并发、并行

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

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

并行（多个线程同一时刻执行）

  • CPU多核，多个线程可以同时执行[线程池]
public static void main(String[] args) {
   
    // 获取CPU的核数
    // CPU密集型，IO密集型
    System.out.println(Runtime.getRuntime().availableProcessors());
}

并发编程的本质：充分利用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. sleep不需要被唤醒（休眠之后推出阻塞），但是wait需要（不指定时间需要被别人中断）。

Lock锁（重点）

传统的synchronized


/**
 * 真正的多线程开发（降低耦合性）
 * 线程就是一个单独的资源类 没有任何附属的操作
 * 1. 属性 方法
 */
public class SaleTicketDemo01 {
   
    public static void main(String[] args) {
   

        // 并发：多线程操作同一个资源类，把资源丢进线程
        Ticket ticket = new Ticket();

        // @FunctionalInterface 函数式接口 jdk1.8 兰八大表达式 ( 参数 )->{ 代码 }
        for (String s : Arrays.asList("A", "B", "C")) {
   
            new Thread(()->{
   
                for (int i = 0; i < 60; i++) {
   
                    ticket.sale();
                }
            }, s).start();
        }
    }
}

/**
 * 资源类
 */
class Ticket{
   
    // 属性 方法
    private int number = 50;

    // 买票的方式
    public synchronized void sale(){
   
        if (number > 0) {
   
            System.out.println(Thread.currentThread().getName() + "卖出了" + (number--) + "票，剩余：" + number);
        }
    }

}

Lock 接口

Lock lock = …;

lock.lock();//加锁

lock.unlock();//解锁

可重入锁(常用)

实现类：ReentrantLock,ReentrantReadWriteLock.ReadLock(读锁),ReentrantReadWriteLock.WriteLock(写锁)


/**
 * 真正的多线程开发（降低耦合性）
 * 线程就是一个单独的资源类 没有任何附属的操作
 * 1. 属性 方法
 */
public class SaleTicketDemo02 {
   
    public static void main(String[] args) {
   

        // 并发：多线程操作同一个资源类，把资源丢进线程
        Ticket2 ticket = new Ticket2();

        // @FunctionalInterface 函数式接口 jdk1.8 兰八大表达式 ( 参数 )->{ 代码 }
        for (String s : Arrays.asList("A", "B", "C")) {
   
            new Thread(()->{
   
                for (int i = 0; i < 60; i++) {
   
                    ticket.sale();
                }
            }, s).start();
        }
    }
}

/**
 * 资源类
 *
 * Lock 三部曲
 * 1. new ReentrantLock();
 * 2. lock.lock(); // 加锁
 * 3. 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. Sycnchronized 内置的java关键字，Lock 是一个java类
  2. Synchronized 无法判断取锁的状态，而 Lock 可以判断是否获取到了锁
  3. Synchronized 会自动释放锁， Lock 锁必须要手动释放锁！如果不释放锁，死锁！
  4. Synchronized 线程1 （获得锁，阻塞）、线程2（一直等）；Lock 不会一直等待，会尝试获取锁
  5. Synchronized 可重入锁， 不可以中断的，非公平；Lock ，可重入锁，可以判断锁，非公平（可以自己设置）
  6. Synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码！

锁是什么？如何判断锁的是谁？

生产者和消费者问题

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

生产者和消费者问题 Synchronized 版


/**
 * 线程之间的通信问题 ： 生产者和消费者问题
 * 线程交替执行 A B 操作同一个遍历 num = 0
 * A num + 1
 * B num - 1
 */
public class A {
   
    public static void main(String[] args) {
   
        final 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);
        //通知其他线程 我加一完毕了;
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
   
        if (number==0){
   
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        //通知其他线程，我减一完毕了
        this.notifyAll();
    }

}

问题 如果同时存在多个线程 虚假唤醒

在这里插入图片描述

JUC 版，生产者与消费者问题

在这里插入图片描述

必须把if改成while！！！

在这里插入图片描述

代码实现：


/**
 * 线程之间的通信问题 ： 生产者和消费者问题
 * 线程交替执行 A B 操作同一个遍历 num = 0
 * A num + 1
 * B num - 1
 */
public class B {
   
    public static void main(String[] args) {
   
        final 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 = new ReentrantLock();
    Condition condition = lock.newCondition();
    //condition.await(); // 等待
    //condition.signalAll(); // 唤醒全部

    //+1
    public void increment() {
   
        lock.lock();

        try {
   
            //业务代码
            while (number!=0){
   
                //等待
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            //通知其他线程 我加一完毕了;
            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);
            //通知其他线程，我减一完毕了
            condition.signalAll();
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        } finally {
   
            lock.unlock();
        }
    }


}

任何一个新的技术，绝对不是仅仅只是覆盖了原来的技术，优势和补充！

Condition 精准通知和唤醒线程

代码测试：

package kuang.juc.pc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
* Condition 精准通知和唤醒线程
 */
public class C {
   
    public static void main(String[] args) {
   
        final Data3 data = new Data3();

        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                data.printA();
            }
        }, "A").start();

        new Thread(()-> {
   
            for (int i = 0; i < 10; i++) {
   
                data.printB();
            }
        }, "B").start();

        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                data.printC();
            }
        }, "C").start();

    }
}

/**
 * 资源类
 */
class Data3{
   

    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();

    private int number = 1;//A 1 B 2 C 3

    public void printA(){
   
        lock.lock();
        try {
   
            // 业务 判断->执行->通知
            while (number != 1) {
   
                //等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "=> A");
            // 唤醒 B
            number = 2;
            condition2.signal();
        } catch (Exception e) {
   
            e.printStackTrace();
        } finally {
最低0.47元/天 解锁文章
情、狠现实
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC进阶详细笔记
qq_44619964的博客
04-21 1447
多线程进阶-JUC并发 文章目录**多线程进阶-JUC并发****1、搭建基础环境****2、什么是JUC****3、线程和进程****并发编程：并发、并行****并发编程的本质：充分利用CPU的资源****线程有几个状态****wait/sleep区别****4、Lock锁(重点)****传统的Synchronized****Lock接口**公平锁：非公平锁：Synchronized和Lock锁...
JUC进阶
qq_44787933的博客
08-01 123
java.util工具包，包，分类Runnable 没有返回值、效率相比于Callable相对比较低进程：一个程序（QQ.exe Music.exe） 的集合一个进程往往可以包含多个线程，至少包含一个！java默认有几个线程？ 2个 main、GC线程：开了一个oneNote，写字，自动保存（线程负责）对于Java而言：Thread、Runnable、Callable 并发编程：并发、并行并发（多线程操作同一个资源）并行（多个人一起行走） 并发编程的本质：充分利用CPU的资源 1.来自不同的类wait
多线程进阶(JUC)
m0_60631323的博客
08-29 318
JUC
juc进阶篇
HungryAndHumble的博客
07-06 166
juc进阶
JUC并发编程的进阶之路
weixin_44702189的博客
07-29 142
并发编程以及一些底层原理
JUC并发多线程进阶
早上真起不来的博客
06-09 286
笔记整理来源 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-JUC-多线程 进阶
07-05
Java-JUC-多线程进阶resources是 Java 并发编程的高级课程，涵盖了 Java 中的并发编程概念、线程安全、锁机制、集合类、线程池、函数式接口、Stream流式计算等多个方面。 什么是JUC JUC（Java Utilities for ...
Java并发编程进阶——多线程的安全与同步
行者无疆的博客
03-14 622
多线程的安全与同步 多线程的操作原则 多线程 AVO 原则 A：即 Atomic，原子性操作原则。对基本数据类型变量的读和写是保证原子性的，要么都成功，要么都失败，这些操作不可中断。 V：即 volatile，可见性原则。使用 volatile 关键字，保证了变量的可见性，到主存拿数据，不是到缓存里拿。 O：即 order， 就是有序性。代码的执行顺序，在代码编译前的和代码编译后的执行顺序不变。 单 CPU 时代的多线程 概念：单核 CPU 上，同一时刻只能有一条线程运行，单核 CPU 上运行的单线程程序和
基于《狂神说Java》JUC并发编程--学习笔记
wudidahuanggua的博客
06-15 839
本笔记仅做学习与复习使用，不存在刻意抄袭。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!点击跳转至遇见狂神说哔哩哔哩首页如果你也是狂神的小迷弟，可以加我好友一起探讨学习。 ...
JUC-多线程进阶
limi_yo的博客
07-09 176
JUC-多线程进阶 什么是JUC? Java.util.concurrent Java.util.concurrent.atomic 原子性 Java.util.concurrent.locks lock锁 线程与进程 一个进程可以包含多个线程，至少包含一个。 Java默认有几个线程？ 2个，main、GC。 Java真的可以开启线程吗？ Java无法操作硬件，底层调用本地方法start0()。 并发与并行 并发：单核CPU，多线程操作同一个资源 并行：多核CPU，多个线程同时执行；线程池 并发编程的
Java进阶-JUC篇
llx522的博客
05-12 372
Java的进阶篇，真正的和工作当中相关的知识，必须得有多线程相关的知识！
Java/JUC进阶/Java 并发 - 05 CLH、MCS 队列锁简介
小枫逐日
08-06 173
一、自旋锁简介 通常情况下解决多线程共享资源逻辑一致性问题有两种方式： 1. 互斥锁： 当发现资源被占用的时候，会阻塞自己直到资源解除占用，然后再次尝试获取 2. 自旋锁： 当发现占用时，一直尝试获取锁（线程没有被挂起的过程，也就没有线程调度切换的消耗）； 对于这两种方式没有优劣之分，只有是否适合当前的场景。 但是如果竞争非常激烈的时候，使用自旋锁就会产生一些额外的问题： 可能导致一些...
【多线程进阶二】JUC工具类 && 线程安全的集合类 && 死锁
qq_48479056的博客
05-22 1485
（4）创建线程，线程的构造方法传入FutureTask，此时新线程就会执行FutureTask内部的Callable接口中的call方法，完成计算。（4）循环等待：线程1等待线程2释放锁，线程2要释放锁要先等待线程3释放锁，线程3释放锁要先等待线程1释放锁...形成了循环关系。（1）Vector，Stack，HashTable是线程安全的，是JDK中提供的线程安全的类，但是强烈不推荐使用。（2）锁竞争激烈的时候，使用ReentrantLock，搭配trylock更加灵活的控制加锁的行为，而不是死等；
JUC并发编程
qq_42513661的博客
09-22 653
JUC并发编程 synchronized 和 Lock的区别 Synchronized内置的Java关键字，Lock是一个Java类 Synchronized无法判断获取锁的状态，Lock 可以判断是否获取到了锁 Synchronized 会自动释放锁，lock必须要手动释放锁!如果不释放锁，死锁 Synchronized 线程1(获得锁，阻塞）、线程2(等待，傻傻的等）;Lock锁就不一定会等待下去; Synchronized可重入锁，不可以中断的，非公平;Lock，可重入锁，可以判断锁，非公平(可以自
JUC并发编程（多线程进阶整理）
weixin_47701015的博客
06-12 1521
JUC并发编程 JUC就是java.utilconcurrent 包的工具类
【狂神说笔记】JUC并发编程（多线程进阶）
qq_48575500的博客
04-28 1285
源码+官方文档（面试高频）进程：Java真的能开启线程吗？并发：（多线程操作同一资源）并行：（多个人同时走路）并发编程的本质：充分利用CPU的资源 2.6、wait和sleep的区别 来自不同的类：关于锁的释放使用的范围是不同的是否需要捕获异常参考链接参考链接作用：用法：怎么理解：实例： 3.2、Lock接口（Lock锁） 公平锁：十分公平，先来后到（排队）3h 3s非公平锁：不公平，可以插队（为了“公平”，引入非公平锁）–默认Lock锁“三部曲”： 3.4、synchronized 和 Lock 的区别
【数据结构6】AVL树、AVL树的旋转-左旋和右旋、二叉搜索树的扩展应用-B树(B-Tree)、B+树
linjun的博客
08-24 278
【代码】【数据结构6】AVL树、AVL树的旋转-左旋和右旋、二叉搜索树的扩展应用-B树(B-Tree)、B+树。
B+树的原理及实现
最新发布
NiNg_1_234的博客
08-27 521
B+树以其高效的数据存储和访问能力，在数据库索引和文件系统索引中扮演着重要角色。通过Java实现B+树，我们能够更加深入地理解其工作原理和内部机制。本文提供的代码示例为框架性实现，具体细节需要根据B+树的特性进行设计和优化。版权声明：本博客内容为原创，转载请保留原文链接及作者信息。参考文章B+树的原理及实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值