JUC并发编程

最新推荐文章于 2024-09-20 15:32:13 发布
最新推荐文章于 2024-09-20 15:32:13 发布
阅读量172 收藏
点赞数
分类专栏： java基础 文章标签： java jdk
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35996924/article/details/114953187
版权

JUC并发编程

1. 线程和进程

  • 进程: 一个程序，QQ.exe Music.exe 程序的集合; 一个进程往往可以包含多个线程，至少包含一个。

  • Java默认有几个线程: 2 个（mian、GC）。

  • 线程:开了一个进程 Typora，写字，自动保存(线程负责的)

  • 创建线程(对于Java而言):Thread、Runnable、Callable。

  • Java真的可以开启线程吗? 不可以开启线程。

    public synchronized void start() {
    if (threadStatus != 0)throw new IllegalThreadStateException();
    group.add(this);
    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
        }
    }
}
// 本地方法，底层的C++ ，Java 无法直接操作硬件 
private native void start0();

  • 并发(多线程操作同一个资源): CPU 一核 ，模拟出来多条线程，快速交替 。

  • 并行(多个人一起行走): CPU 多核 ，多个线程可以同时执行; 线程池。

    public static void main(String[] args) {
    //获取cpu的核数
    //CPU密集型，IO密集型
    System.out.println(Runtime.getRuntime().availableProcessors());
}

  • 线程有几个状态。

    public enum State {
    //尚未启动的线程的线程状态
    NEW,
    //可运行线程的线程状态
    RUNNABLE,
    //等待监视器锁的阻塞线程的线程状态
    BLOCKED,
	//等待线程的线程状态
    WAITING,
	//具有指定等待时间的等待线程的线程状态
    TIMED_WAITING,
	//终止线程的线程状态
    TERMINATED;
}

  • wait / sleep 区别：

    • 来自不同的类:wait => Object ,sleep => Thread
    • 锁的释放: wait会释放锁，sleep 不会释放锁
    • 使用的范围不同：wait必须在同步代码块中，sleep可以在任何地方
2. Lock锁

  • 传统 Synchronized：

    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
static class Ticket {
    //属性、方法
    private int number = 30;
    //卖票的方式
    //synchronized 本质: 队列，锁
    public synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出了" + (number--) + "票,剩余:" + number);
        }
    }
}
//结果
A卖出了30票,剩余:29
A卖出了29票,剩余:28
...
A卖出了3票,剩余:2
A卖出了2票,剩余:1
A卖出了1票,剩余:0

  • Lock 接口：

    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(); //解锁
static 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(); // 解锁
        }
    }
}
//结果
A卖出了30票,剩余:29
A卖出了29票,剩余:28
...
A卖出了3票,剩余:2
A卖出了2票,剩余:1
A卖出了1票,剩余:0

  • Synchronized 和 Lock区别：

    • Synchronized内置的Java关键字， Lock 是一个Java类。
    • Synchronized无法判断获取锁的状态，Lock可以判断是否获取到了锁。
    • Synchronized会自动释放锁，lock必须要手动释放锁!如果不释放锁，死锁。
    • Synchronized 线程 1(获得锁，阻塞)、线程2(等待，傻傻的等);Lock锁就不一定会等待下去。
    • Synchronized 可重入锁，不可以中断的，非公平;Lock ，可重入锁，可以 判断锁，非公平(可以自己设置)。
    • Synchronized适合锁少量的代码同步问题，Lock 适合锁大量的同步代码。
3. 生产者和消费者问题

  • 生产者和消费者问题Synchronized版：

    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();
}
// 判断等待，业务，通知
static class Data { // 数字 资源类
    private int number = 0;
    public synchronized void increment() throws InterruptedException {
        if (number != 0) {  //0
            // 等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number); // 通知其他线程，我+1完毕了
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
        if (number == 0) { // 1
            // 等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number); // 通知其他线程，我-1完毕了
        this.notifyAll();
    }
}
//结果
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
...

  • 问题存在，A B C D4个线程! 虚假唤醒：
    在这里插入图片描述

  • JUC版的生产者和消费者问题：

    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) {
                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();
}
// 判断等待，业务，通知
static class Data2 { // 数字 资源类
    private int number = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    //condition.await(); //等待
    //condition.signalAll(); //唤醒全部
    public void increment() throws InterruptedException {
        lock.lock();
        try {
            //业务代码
            while (number != 0) { //0
                //等待
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "=>" + number); // 通知其他线程，我+1完毕了
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public synchronized void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (number == 0) { // 1
                // 等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "=>" + number); // 通知其他线程，我-1完毕了
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}
//结果
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
...
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
...

  • Condition 精准的通知和唤醒线程：

    public static void main(String[] args) {
    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();
}
static class Data3 { //资源类 Lock
    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() + "=>AAAAAAA"); // 唤醒，唤醒指定的人，B
            number = 2;
            condition2.signal();
        } 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() + "=>BBBBBBBBB"); // 唤醒，唤醒指定的人，c
            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() + "=>CCCCCCC"); // 唤醒，唤醒指定的人，c
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
//结果
A=>AAAAAAA
B=>BBBBBBBBB
C=>CCCCCCC
A=>AAAAAAA
B=>BBBBBBBBB
C=>CCCCCCC
A=>AAAAAAA
B=>BBBBBBBBB
C=>CCCCCCC
...
残*影
关注
专栏目录
JUC 并发编程
m0_53067943的博客
07-10 1130
主要对于juc的知识点总结
周阳老师JUC并发编程
qq_44300280的博客
11-16 5746
周阳老师JUC并发编程
JUC并发编程详解
yyhgo_的博客
12-13 705
JUC并发编程详解
JUC并发编程超详细详解篇
热门推荐
白大锅的博客，毕设WangLoveBai_999
12-15 7万+
文章目录前言一、JUC并发编程简介及准备1.1.本系列讲解思路1.2.知识储备1.3.用到的依赖1.4.logback.xml 配置二、进程与线程2.1.进程与线程2.1.1.进程2.1.2.线程2.1.3.对比2.2.并行与并发2.2.1.两者区别直观解释2.3.应用2.3.1. 应用之异步调用（案例1）2.3.2.应用之提高效率（案例1）三、Java 线程3.1.本节主讲内容3.2.创建和运行线程3.2.1.方法一，直接使用 Thread3.2.2.方法二，使用 Runnable 配合 Thread3.
JUC 并发编程学习笔记（总）
Java技术一点通
10-19 2382
JUC指的就是工具包的简称，里面的工具类可以很方便的实现多线程的开发。java.util工具包、包、分类。业务：普通的线程代码 Thread。Runnable没有返回值、效率相比Callable相对较低！
JUC并发编程面试题
weixin_45081813的博客
04-06 3313
文章目录1. 并行和并发有什么区别？2. 线程和进程的基本概念、线程的基本状态以及状态之间的关系？3.守护线程是什么？4.创建线程有哪几种方式？5. sleep() 和 wait() 有什么区别？6.线程的 run() 和 start() 有什么区别？7.创建线程池有哪几种方式？8.在 Java 程序中怎么保证多线程的运行安全？9.什么是死锁？怎么防止死锁？10.synchronized 和 volatile 的区别是什么？11.synchronized 和 Lock 有什么区别？12.synchroniz
JUC并发编程初学
weixin_53622554的博客
06-16 1343
一. 什么是JUC。
JUC并发编程——锁
weixin_39555954的博客
12-30 768
锁
【JUC并发编程】
蛋饼吧的博客
06-19 1489
JUC是Java Util Concurrent的缩写,是Java SE 5.0中新增的一个包,主要提供了在并发编程中使用的工具类和框架。JUC包含了许多用于多线程编程的工具类和接口,如锁、原子变量、线程池、阻塞队列等。这些工具类和接口可以帮助开发者更方便地进行多线程编程,从而提高程序的并发性能和可靠性。JUC包中的工具类和接口都是线程安全的,可以在多线程环境下安全地使用。它们的设计和实现都是基于并发编程的最佳实践和原则,可以有效地避免线程安全问题的发生。
尚硅谷大厂必备技术之JUC并发编程基础视频 配套资料（自己根据视频整理课件，和代码）
09-23
【尚硅谷】大厂必备技术之JUC并发编程视频 配套资料，自己根据视频整理 pdf 课件，和代码 视频地址：...
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档
09-21
1、根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档 2、包含源码 视频地址：https://www.bilibili.com/video/BV1ar4y1x727/?p=1&vd_source=c634d163b940964d44747b4c3976117b 参考资料：...
JUC并发编程与源码分析视频课.zip
12-16
《JUC并发编程与源码分析视频课》是一门深入探讨Java并发编程的课程，主要聚焦于Java Util Concurrency（JUC）库的使用和源码解析。JUC是Java平台提供的一组高级并发工具包，它极大地简化了多线程编程，并提供了更...
Java后端开发，JUC并发编程Java后端开发，JUC并发编程
04-14
### Java后端开发与JUC并发编程 #### 进程和线程的概念 在Java后端开发与JUC（Java.util.concurrent包）并发编程中，进程和线程是两个核心概念。 **进程**是系统进行资源分配的基本单位，具有并发性、异步性、...
JDK17新增语法特性
最新发布
2201_76124988的博客
09-20 757
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 266
faiss版本 faiss-v1.7.4。
面试突击-多线程和IO专题(至尊典藏版)
人生若只初相见@的博客
09-18 2211
金九银十多线程和IO大厂面试专题
Mybatis-plus进阶篇(四)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
09-19 1406
nested 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于创建一个独立的查询条件块，不带默认的 AND 或 OR 逻辑。last 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它允许你直接在查询的最后添加一个 SQL 片段，而不受 MyBatis-Plus 的查询优化规则影响。exists 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于在查询中添加一个 EXISTS 子查询。这个方法特别适用于需要对数值字段进行减量操作的场景。
Java JUC并发编程高级教程
Java JUC（java.util.concurrent）是Java 5.0及以后版本引入的一个重要包，专门用于提升并发编程的效率和可管理性。这个包包含了一系列工具类和接口，旨在简化多线程编程，提高程序的并发性能，并减少线程同步的复杂...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值