JUC并发编程

最新推荐文章于 2023-07-10 16:45:52 发布
最新推荐文章于 2023-07-10 16:45:52 发布
阅读量79 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45640264/article/details/119804881
版权

JUC

什么是 JUC

https://blog.csdn.net/weixin_44491927/article/details/108560692?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162942786716780265487561%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=162942786716780265487561&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allsobaiduend~default-1-108560692.pc_search_all_es&utm_term=JUC%E5%B9%B6%E5%8F%91%E7%BC%96%E7%A8%8B%E7%8B%82%E7%A5%9E&spm=1018.2226.3001.4187

线程和进程

Java默认有几个线程？
2个，main，GC
Java无法直接操作硬件，通过本地方法，底层C++，开启线程

并发和并行

线程状态

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }

sleep/wait区别

1.不同类
wait=>Object
sleep=>Thread
2.关于锁的释放
wait会释放，sleep不会释放
3.使用范围
wait必须在同步代码块中
sleep可以在任何地方
4.是否需要捕获异常
wait不需要
sleep要捕获异常

lock锁（重点）

Synchronized

公平锁：先来后到
非公平锁：可以插队

public ReentrantLock() {
        sync = new NonfairSync(); //非公平
    }

    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

lock和synchronized区别

  • synchronized内置关键字，lock是一个java类
  • synchronized 无法判断获取锁的状态，lock可以判断是否获取到锁
  • synchronized会自动释放锁，lock必须手动释放锁，否则死锁
  • synchronized 可重入锁，不可以中断，非公平；lock，可重入锁，可以判断锁，非公平
  • synchronized 适合少量代码，lock适合大量代码同步

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

生产者消费者模式

public class ThreadTest {
    public static void main(String[] args) {
        Product product = new Product();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    product.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    product.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}

class Product {
    private int water = 0;

    // + 1
    public synchronized void increment() throws InterruptedException {
        //等待
        if (water != 0) {
            this.wait();
        }
        //业务
        water++;
        System.out.println(Thread.currentThread().getName()+"=>"+water);
        //通知
        this.notifyAll();
    }

    // - 1
    public synchronized void decrement() throws InterruptedException {
        //等待
        if (water == 0) {
            this.wait();
        }
        //业务
        water--;
        System.out.println(Thread.currentThread().getName()+"=>"+water);
        //通知
        this.notifyAll();
    }
}

加入变成A,B,C,D四个线程，虚假唤醒
将if改为while

public class ThreadTest {

    public static void main(String[] args) {
        Product product = new Product();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    product.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    product.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    product.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    product.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

class Product {
    private int water = 0;

    // + 1
    public synchronized void increment() throws InterruptedException {
        //等待
        while (water != 0) {
            this.wait();
        }
        //业务
        water++;
        System.out.println(Thread.currentThread().getName()+"=>"+water);
        //通知
        this.notifyAll();
    }

    // - 1
    public synchronized void decrement() throws InterruptedException {
        //等待
        while (water == 0) {
            this.wait();
        }
        //业务
        water--;
        System.out.println(Thread.currentThread().getName()+"=>"+water);
        //通知
        this.notifyAll();
    }
}

JUC版生产者和消费者

public class ThreadTest {

    public static void main(String[] args) {
        Product product = new Product();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                product.increment();

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

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

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                product.decrement();
            }
        },"D").start();
    }

}

class Product {
    private int water = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    // + 1
    public  void increment() {
        lock.lock();
        try {
            //等待
            while (water != 0) {
                condition.await();
            }
            //业务
            water++;
            System.out.println(Thread.currentThread().getName()+"=>"+water);
            //通知
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    // - 1
    public  void decrement() {
        lock.lock();
        try {
            //等待
            while (water == 0) {
                condition.await();
            }
            //业务
            water--;
            System.out.println(Thread.currentThread().getName()+"=>"+water);
            //通知
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

Condition精准通知，唤醒

public class ThreadTest {

    public static void main(String[] args) {
        Product product = new Product();

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

        new Thread(()->{
            for (int i = 0; i < 10; i++) {

                product.printC();

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

    }

}

class Product {
    private int water = 1; //1,2,3

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

    // + 1
    public  void printA() {
        lock.lock();
        try {
            //等待
            while (water != 1) {
                condition1.await();
            }
            //业务
            System.out.println(Thread.currentThread().getName()+"=>AAAAAA");
            water = 2;
            //通知
            condition2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    // - 1
    public  void printB() {
        lock.lock();
        try {
            //等待
            while (water != 2) {
                condition2.await();
            }
            //业务
            System.out.println(Thread.currentThread().getName()+"=>BBB");
            water = 3;
            //通知
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public  void printC() {
        lock.lock();
        try {
            //等待
            while (water != 3) {
                condition3.await();
            }
            //业务
            System.out.println(Thread.currentThread().getName()+"=>CCCC");
            water = 1;
            //通知
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

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

8锁现象

如何判断锁的是谁！

的有
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
尚硅谷大厂必备技术之JUC并发编程基础视频 配套资料（自己根据视频整理课件，和代码）
09-23
【尚硅谷】大厂必备技术之JUC并发编程视频 配套资料，自己根据视频整理 pdf 课件，和代码 视频地址：...
JUC 并发编程
m0_53067943的博客
07-10 984
主要对于juc的知识点总结
周阳老师JUC并发编程
qq_44300280的博客
11-16 5352
周阳老师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并发编程详解
yyhgo_的博客
12-13 461
JUC并发编程详解
JUC 并发编程学习笔记（总）
Java技术一点通
10-19 2284
JUC指的就是工具包的简称，里面的工具类可以很方便的实现多线程的开发。java.util工具包、包、分类。业务：普通的线程代码 Thread。Runnable没有返回值、效率相比Callable相对较低！
JUC并发编程面试题
weixin_45081813的博客
04-06 2421
文章目录1. 并行和并发有什么区别？2. 线程和进程的基本概念、线程的基本状态以及状态之间的关系？3.守护线程是什么？4.创建线程有哪几种方式？5. sleep() 和 wait() 有什么区别？6.线程的 run() 和 start() 有什么区别？7.创建线程池有哪几种方式？8.在 Java 程序中怎么保证多线程的运行安全？9.什么是死锁？怎么防止死锁？10.synchronized 和 volatile 的区别是什么？11.synchronized 和 Lock 有什么区别？12.synchroniz
【JUC并发编程】
蛋饼吧的博客
06-19 955
JUC是Java Util Concurrent的缩写,是Java SE 5.0中新增的一个包,主要提供了在并发编程中使用的工具类和框架。JUC包含了许多用于多线程编程的工具类和接口,如锁、原子变量、线程池、阻塞队列等。这些工具类和接口可以帮助开发者更方便地进行多线程编程,从而提高程序的并发性能和可靠性。JUC包中的工具类和接口都是线程安全的,可以在多线程环境下安全地使用。它们的设计和实现都是基于并发编程的最佳实践和原则,可以有效地避免线程安全问题的发生。
JUC(并发编程)
abc98526的博客
04-17 1万+
1.什么是JUC? JUC是指javaUtil包中的三个操作线程的包! 2.线程进程和程序 程序(Program):是一个静态的概念，一般对应于操作系统中的一个可执行的文件 ，比如：我们要启动酷狗听音乐，则对应酷狗可执行程序。当我们双击酷狗，则加载 程序到内存中，开始执行该程序，于是产生了"进程". 进程:执行中的程序叫做进程(Process),是一个动态的概念。现代的操作系统都可以同时启动多个进程。比如:我们在用酷狗听音乐，也可以使用wps写文档，也可以同时用浏览器查看网页。可以通过
尚硅谷JUC并发编程与源码分析
一个沉迷Java，无法自拔的Coder
07-07 564
深入理解JUC并发编程
Java后端开发，JUC并发编程Java后端开发，JUC并发编程
04-14
Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，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并发编程.rar
12-14
"JUC并发编程.rar"这个压缩包文件包含了关于并发编程的相关案例源码和详细讲解，旨在帮助初学者和经验丰富的开发者深入理解并发编程的核心概念和技术。 首先，让我们来看看并发编程的基本概念。并发是指在一段时间...
关于Go语言0基础小白篇最常见的面试题整理！！！.html
07-10
一个专为Go语言初学者和新手求职者准备的实用资源，它精心挑选了一系列面试中经常出现的Go语言问题，并提供了详尽的答案解析。这份资源从Go语言的基础知识出发，逐步深入到高级特性和最佳实践，旨在帮助读者快速掌握Go语言的核心概念和应用技巧。无论是对Go语言完全陌生的新手，还是有一定基础但希望巩固和提升的开发者，这份资源都是一个宝贵的学习工具。 一个专为Go语言初学者和新手求职者准备的实用资源，它精心挑选了一系列面试中经常出现的Go语言问题，并提供了详尽的答案解析。这份资源从Go语言的基础知识出发，逐步深入到高级特性和最佳实践，旨在帮助读者快速掌握Go语言的核心概念和应用技巧。无论是对Go语言完全陌生的新手，还是有一定基础但希望巩固和提升的开发者，这份资源都是一个宝贵的学习工具。 一个专为Go语言初学者和新手求职者准备的实用资源，它精心挑选了一系列面试中经常出现的Go语言问题，并提供了详尽的答案解析。这份资源从Go语言的基础知识出发，逐步深入到高级特性和最佳实践，旨在帮助读者快速掌握Go语言的核心概念和应用技巧。无论是对Go语言完全陌生的新手，还是有一定基础但希望巩固和提升的开发者，这份资源
电机学题目1.doc
最新发布
07-10
电机学题目1
碳化硅模块（SiCMOS模组）应用过程中出现的串扰问题3种有效应用对策
07-10
碳化硅模块（SiCMOS模组）应用过程中出现的串扰问题3种有效应用对策 https://pan.baidu.com/s/1N250LqWFxgk0T0yRECnJWg提取码425y 针对 SiC MOSFET 模块应用中出现的串扰问题， 本文对测量使用的差分探头进行了详细对比，由结果 可知采用高带宽和高采样率的示波器和差分探头可测 量得到准确的信号波形。同时分析了串扰问题的产生 机制，正dVds dt在反向传输电容上产生流向驱动侧的 位移电流，在栅极阻抗引起正向感应电压，叠加在栅 源极上会引起栅源极电压抬升；而负dVds dt在反向传 输电容上产生流向模块侧的位移电流，在栅极阻抗引 起负向感应电压，造成栅源极出现过大的电压负向峰 值。为解决串扰问题，本文提出了3种有效应用对策： ①减小栅极引线阻抗，从而减小阻抗上的感应压降， 抑制栅源极过压；②采用有源米勒箝位技术，泄放位 移电流，有效保护 SiC MOSFET 模块；③通过三级关 断串扰抑制技术改善栅极驱动波形，有效抑制过大的电压正向抬升和负向电压
Java宝典：数组与集合的神秘面纱-从新手到高手的进阶之路.pdf
07-10
数组与集合+程序员
juc并发编程线程池
06-18
Java并发工具包（Java Util Concurrency, JUC）提供了一个强大的线程池实现，即`java.util.concurrent.Executors`和`java.util.concurrent.ThreadPoolExecutor`。线程池是并发编程中常用的一种机制，它允许您预先创建一组线程，并在需要执行任务时重用这些线程，从而提高性能和资源管理。 `Executors`类提供了一些预定义的线程池工厂方法，如`newFixedThreadPool()`, `newCachedThreadPool()`, `newScheduledThreadPool()`等，这些线程池有不同的特点： 1. `FixedThreadPool`：固定大小的线程池，一旦线程池达到最大线程数，新任务会被排队等待，直到有线程空闲出来。 2. `CachedThreadPool`：可缓存线程的线程池，线程数量根据需要动态调整，任务提交后立即执行，适合执行大量短期任务。 3. `ScheduledThreadPool`：定时线程池，可以安排任务在未来执行，支持定期和延期执行。 4. `SingleThreadExecutor`：单线程线程池，所有任务按照提交的顺序依次执行。 使用线程池时，你可以创建一个线程池实例，然后提交`Runnable`或`Callable`任务到线程池，线程池会负责管理和调度这些任务。此外，线程池还提供了便利的方法，如`submit()`, `execute()`, `call()`等，简化了任务提交和处理结果的过程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值