JUC重点详解

最新推荐文章于 2024-07-05 21:23:06 发布
最新推荐文章于 2024-07-05 21:23:06 发布
阅读量946 收藏 1
点赞数 1
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41307492/article/details/112467076
版权
本文详细探讨了Java并发编程中的JUC（java.util.concurrent）包，包括线程与进程的区别、并发与并行的概念、Lock的使用、synchronized与Lock的对比、生产者消费者问题的解决方案，以及各种辅助类如CountDownLatch、CyclicBarrier和Semaphore的应用。此外，还讲解了ReadWriteLock、线程池、阻塞队列和四大函数式接口的重要知识点。
摘要由CSDN通过智能技术生成

一、前瞻

1、什么是JUC

java.util.concurrent包

2、线程与进程

一个进程往往包含多个线程
java默认有两个线程：main、GC(垃圾回收)
java真的可以开启线程吗？
不可以，底层使用C++，java无法直接操作硬件

1>线程六大状态

        //新生
        NEW,

        //运行
        RUNNABLE,

        //阻塞
        BLOCKED,
        //等待
        WAITING,

        //等待超时
        TIMED_WAITING,

        //终止
        TERMINATED;

2>wait和sleep的区别

1、来自不同的类
wait–>Object
sleep–>Thread
2、wait会释放锁，sleep不会释放锁
3、使用范围不同
wait必须在同步代码块中使用
sleep可以在任何地方使用

3、并发与并行

并发即多线程操作同一个资源
单核CPU快速交替
并行即多个线程同时执行；线程池
并发变成的本质：充分利用CPU资源

二、Lock

1、传统的synchronized

package cn.biliball;

public class Test01 {
   
    public static void main(String[] args) {
   
        //获取CPU核数
        //System.out.println(Runtime.getRuntime().availableProcessors());
        
        final Ticket ticket=new Ticket();

        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();

    }
}
//资源类
class Ticket{
   
    private int number=30;
    public synchronized void sale(){
   
        if(number>0){
   
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"张票，剩余"+number+"张票。");
        }
    }
}

2、使用Lock

Lock的三个实现类
ReentrantLock()（重入锁）
ReentrantReadWriteLock.ReadLock()（读锁）
ReentrantReadWriteLock.WriteLock()（写锁）
在这里插入图片描述

公平锁：先来先执行
非公平锁：可以插队
java默认非公平锁，保证CPU利用率

package cn.biliball;

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

public class Test02 {
   

    public static void main(String[] args) {
   
        //获取CPU核数
        //System.out.println(Runtime.getRuntime().availableProcessors());

        final Ticket02 ticket=new Ticket02();

        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();

    }
}
//资源类
class Ticket02{
   
    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();//解锁
        }
    }
}

3、synchronized和Lock的区别

1、synchronized 内置的java关键字，Lock是一个java类
2、synchronized 无法判断获取锁的状态，Lock可以判断是否获取到了锁
3、synchronized 会自动释放锁，Lock必须手动释放锁，如果不释放，死锁
4、synchronized 线程1（获得锁，阻塞）、线程2（等待，啥啥的等）；Lock锁就不一定会等下去
5、synchronized 可重入锁，不可以中断的，非公平；
Lock，可重入锁，可以判断锁，非公平（可以自己设置）
6、synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码

4、生产者和消费者问题

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

package cn.biliball.pc;

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) {
    //0
            // 等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 通知其他线程，我+1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
   
        if (number == 0) {
    // 1
            //问题存在，A B C D 4 个线程！ 虚假唤醒
            //if 改为 while 判断
            // 等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 通知其他线程，我-1完毕了
        this.notifyAll();
    }
}

如果有四个线程，会存在虚假唤醒的问题
在这里插入图片描述

将if换成while

5、JUC版的生产者与消费者问题

package cn.biliball.pc;

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) {
   
        Data02 data = new Data02();
        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();
    }
}

// 判断等待，业务，通知
class Data02 {
    // 数字 资源类
    private int number = 0;

    Lock lock = new ReentrantLock();

    Condition condition = lock.newCondition();

    //+1
    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 (InterruptedException e) {
   
            e.printStackTrace();
        } finally {
   
            lock.unlock();
        }

    }

    //-1
    public synchronized void decrement() throws InterruptedException {
   
        lock.lock();

        try {
   
            while (number == 0) {
    // 1
                //问题存在，A B C D 4 个线程！ 虚假唤醒
                //if 改为 while 判断
                // 等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
最低0.47元/天 解锁文章
x超
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实现线程（3种方法）
weixin_46143360的博客
10-21 405
实现线程 1.第一种方式： 编写一个类，直接继承java.lang.Thread,重写run方法 package com; import java.io.*; public class Test { public static void main(String[] args) throws IOException { //这里是main方法。这里代码是属于主线程，在主栈中运行。 //新建一个分支线程对象 MyThread myThread = ne
java多线程总结五：线程池的原理及实现
stefshawn的专栏
11-01 2947
1、线程池简介：     多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。         假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。     如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。                 一个线程
java并发编程 JUC-基础篇 快速入门
最新发布
制定持续可量化的目标，不断坚持。
07-05 1117
程序有指令与数据组成，指令要运行，数据要读写，就必须指令加载到CPU。数据加载到内容，指令运行需要用到磁盘。当一个程序被运行时，从磁盘加载这个程序的代码至内存，这时开启了一个进程。
实现线程的四种方式
qq_41854180的博客
09-17 408
进程 进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能 线程 线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序 程序 程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。 主线程 jvm启动后，必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束，这个线程在java中称之为主线程。
java 绿色线程和本地线程区别_在 java 中守护线程和本地线程区别？
weixin_35882722的博客
02-16 383
java 中的线程分为两种：守护线程(Daemon)和用户线程(User)。任何线程都可以设置为守护线程和用户线程，通过方法 Thread.setDaemon(boolon)；true 则把该线程设置为守护线程，反之则为用户线程。Thread.setDaemon()必须在 Thread.start()之前调用，否则运行时会抛出异常。两者的区别：唯一的区别是判断虚拟机(JVM)何时离开，Daemon...
多线程的创建，状态，安全问题(同步代码块)
qq_44807271的博客
10-08 331
Java学习笔记之----------多线程进程线程多线程存在的意义创建多线程 进程 进程：应用程序在内存中分配的空间(正在运行中的程序) 线程 线程： 进程中负责程序执行的执行单元，也称为执行路径 一个进程至少有一个线程负责该进程的执行，称主线程 如果一个进程启用了多个线程，就称该程序为多线程程序 多线程存在的意义 多线程有时并不能提高效率，所以多线程存在的意义不是提高效率，多线程其实是合理使用资源 解决多部分代码同时执行的需求，合理使用CPU资源 多线程的运行是根据CPU的切换完成的，如何切换是由CPU
juc详解juc详解juc详解juc详解juc详解juc详解juc详解
08-02
Java并发编程库（Java Util Concurrency，简称JUC）是Java平台中用于高效并发处理的重要工具包，包含在`java.util.concurrent`包下。JUC提供了丰富的并发原语，如线程池、同步器、并发容器等，极大地简化了多线程...
06、JUC并发工具类在大厂的应用场景详解-ev
03-07
06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev...
Java——JUC
12-29
Java并发编程是Java开发中的重要领域，而Java并发工具包（Java Concurrency Utility，简称JUC）则是Java标准库提供的一套强大而丰富的工具，它极大地简化了多线程环境下的编程工作。JUC主要包含在`java.util....
heima-JUC-资料
04-25
Java并发编程是Java Util Concurrency（JUC）库的核心内容，它为多线程环境提供了高效、安全且灵活的工具和API。JUC是Java 5及后续版本引入的一个重要特性，极大地提升了Java在多处理器和高并发环境下的性能表现。 ...
JUC线程锁框架
12-31
JUC，全称为Java Util Concurrency，是Java并发包的简称，包含了大量用于处理并发问题的类和接口，极大地简化了多线程环境下的编程。在这个深度解析JUC线程锁框架的主题中，我们将探讨其核心组件、设计模式以及如何...
实现线程的几种方式
pt_house的博客
03-31 126
实现线程的几种方式 本系列读《实战java高并发程序设计》有感（02）。 前面提到并发，那么怎样要去创建并发程序呢？答案就是使用线程。 线程又是什么呢？来，请看大屏幕：线程就是轻量级的进程，是操作系统调度的最小单位。这里又出来一个进程，它呢就是系统进行资源分配和调度的基本单位，是操作系统结构的基础。就比茶馆可以看成一个进程，隔壁可能开的是饭店，也可以看成一个进程，里面的小二，收银等就可以看成进程里...
线程的几种实现方式?
斧头湖懒客
04-09 92
1、通过继承Thread类实现一个线程 2、通过实现Runnable接口实现一个线程 继承thread类的实例是线程的创建者，调用start方法用来开启线程。 实现runnable接口的实例是线程任务的定义者，通过代码我们发现Runnable的实现类并不是线程，它只是作为参数传递到thread类中，thread才是真正的线程，Runnable只是任务，任务和线程是分开的，任务放到线程才会执行，通过Runnable接口实现了设置线程任务和开启线程的分离。 ...
实现线程的方式到底有几种？
Java烂猪皮
09-19 1409
走过路过不要错过点击蓝字关注我们这篇文章主要讲解实现线程的方式到底有几种？以及实现 Runnable 接口究竟比继承 Thread 类实现线程好在哪里？实现线程是并发编程中基础中的基础，...
实现线程的四种方法
bailaoshi666的博客
05-11 1081
1、继承Thread类创建线程 Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如： package test; /** * Created by IntelliJ IDEA. .
实现线程的三种方式
xf18810669377的博客
06-15 181
3.实现Callable接口（JDK8新特性） 这种方式可以获得线程的返回值，前两种方式无法获取线程返回值，因为run方法返回值为void import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask;//JUC包下，属于Java的并发包，老JDK中没有这个包 public class ThreadTest15 {...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值