JUC（1）

原创 已于 2022-02-08 22:56:41 修改 · 363 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#JUC

于 2022-02-06 16:17:51 首次发布

1、JUC是什么

全称：java.util.concurrent 在并发编程中使用的工具类

2、进程/线程是什么

进程：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。

线程：通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程可以利用进程所拥有的资源，在引入线程的操作系统中，通常都是把进程作为分配资源的基本单位，而把线程作为独立运行和独立调度的基本单位，由于线程比进程更小，基本上不拥有系统资源，故对它的调度所付出的开销就会小得多，能更高效的提高系统多个程序间并发执行的程度。

3、wait/sleep的区别

wait放开手去睡，放开手里的锁

sleep握紧手去睡，醒了手里还有锁

4、总结

* 1 高聚低合前提下，线程操作资源类
* 2 判断、干活、通知
* 3 多线程交换中，必须要防止多线程虚假唤醒，也即（判断只用while,不能用if）
package com.cb.demo.example;

class AirConditioner
{
    private int number=0;
    public synchronized void  increment() throws InterruptedException {
        //老版本方法加synchronized

        //1 判断
        while (number !=0){
            this.wait();
        }
        //2 干活
        number++;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        //3 通知
        this.notifyAll();
    }

    public synchronized void  decrement() throws InterruptedException {
        //老版本方法加synchronized

        //1 判断
        while (number ==0){
            this.wait();
        }
        //2 干活
        number--;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        //3 通知
        this.notifyAll();
    }
}

/**
 * 题目：现在两个线程，可以操作初始化值为零的一个变量，
 * 实现一个线程对该变量加1，一个线程对该变量减1，
 * 实现交替，来10轮，变量初始值为零
 *
 * 1 高聚低合前提下，线程操作资源类
 * 2 判断、干活、通知
 * 3 多线程交换中，必须要防止多线程虚假唤醒，也即（判断只用while,不能用if）
 */
public class ThreadWaitNotifyDemo {
    public static void main(String[] args) {
        AirConditioner airConditioner = new AirConditioner();
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    Thread.sleep(2000);
                    airConditioner.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();


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

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


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

新版

package com.cb.demo.example;

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

class AirConditioner
{
    private int number=0;
    private Lock lock=new ReentrantLock();
    private Condition condition=lock.newCondition();
    public  void  increment() throws InterruptedException {
     lock.lock();
     try{
         //1 判断
         while (number !=0){
             //this.wait();
             condition.await();
         }
         //2 干活
         number++;
         System.out.println(Thread.currentThread().getName()+"\t"+number);
         //3 通知
         //this.notifyAll();
         condition.signalAll();
     }catch (Exception e){
         e.printStackTrace();
     }finally{
         lock.unlock();
     }
    }

    public  void  decrement() throws InterruptedException {
        lock.lock();
        try{
            //1 判断
            while (number ==0){
                //this.wait();
                condition.await();
            }
            //2 干活
            number--;
            System.out.println(Thread.currentThread().getName()+"\t"+number);
            //3 通知
            //this.notifyAll();
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }


   /* public synchronized void  increment() throws InterruptedException {
        //老版本方法加synchronized

        //1 判断
        while (number !=0){
            this.wait();
        }
        //2 干活
        number++;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        //3 通知
        this.notifyAll();
    }

    public synchronized void  decrement() throws InterruptedException {
        //老版本方法加synchronized

        //1 判断
        while (number ==0){
            this.wait();
        }
        //2 干活
        number--;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        //3 通知
        this.notifyAll();
    }*/
}

/**
 * 题目：现在两个线程，可以操作初始化值为零的一个变量，
 * 实现一个线程对该变量加1，一个线程对该变量减1，
 * 实现交替，来10轮，变量初始值为零
 *
 * 1 高聚低合前提下，线程操作资源类
 * 2 判断、干活、通知
 * 3 多线程交换中，必须要防止多线程虚假唤醒，也即（判断只用while,不能用if）
 */
public class ThreadWaitNotifyDemo {
    public static void main(String[] args) {
        AirConditioner airConditioner = new AirConditioner();
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    //Thread.sleep(2000);
                    airConditioner.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();


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

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


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

JUC
小神仙的博客
03-04 1196
JUC 并发编程 + 底层原理 文章目录JUC 并发编程 + 底层原理1、什么是JUC（重要）2、进程和线程回顾3、Lock锁4、生产者和消费者（高频） 注意，一定要是JDK1.8、IDE 一定要设置 1、什么是JUC（重要） java.util.concurrent在并发编程中使用的工具类 2、进程和线程回顾 进程 / 线程是什么？ 进程：是并发执行的程序在执行过程中分配和管理资源的...
一. JUC
weixin_42480780的博客
04-28 134
JUC 1. 什么是JUC？ 2. 什么是进程/线程？ 进程：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。 线程：通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程可以利用进程所拥有的资源，在引入线程的操作系统中，通常都是把进程作为分配资源的基本单位，而把线程作为独立运行和独立调度的基本单位，由于线程比进程更小，基本上不拥有系统资源，故对它的调度所付出
juc
mingwulipo的博客
06-16 507
1.原子类 AtomicInteger，AtomicReference，AtomicStampedReference AtomicLong，LongAdder 2.锁 AbstractQueuedSynchronizer ReentrantLock ReentrantReadWriteLock 3.集合 ReentrantReadWriteLock CopyOnWriteArrayList 4.线...
JUC1 指令翻译 v1.0.rar
06-14
《JUC1指令翻译v1.0：深入理解微指令与指令系统》 在计算机科学领域，指令系统是计算机硬件和软件之间的桥梁，它定义了计算机可以执行的操作。JUC1模型机是一种教学用的简单计算机模型，其设计用于帮助学生理解和...
JUC个人笔记1
08-04
在Java并发编程中，"JUC个人笔记1"主要探讨了多线程并发控制的一些核心概念和技巧。首先，遵循高内聚低耦合的原则，将线程的操作与资源类进行解耦，使得代码结构更加清晰，易于维护。在多线程交互中，特别是涉及到`...
精选资源
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
精选资源
狂神说JUC代码狂神说JUC代码
09-11
1. **线程池**：ExecutorService是JUC中线程池的主要接口，它提供了一种管理和控制线程的方式，避免了大量线程创建销毁带来的开销。ThreadPoolExecutor是ExecutorService的实现，可以自定义线程池的核心线程数、最大...
根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档
09-21
1、根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档 2、包含源码 视频地址：https://www.bilibili.com/video/BV1ar4y1x727/?p=1&vd_source=c634d163b940964d44747b4c3976117b 参考资料：...
Juc
最新发布
08-15
TimeUnit.SECONDS.sleep(1); flag = false; System.out.println("修改完毕!"); } } ``` ### 原子性操作 在并发编程中，原子性操作是非常重要的概念。一个操作要么全部完成要么完全不执行，不会被其他操作中断...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

追逐路上的小人物

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值