# Java--多线程--JUC、死锁、lock、生产者与消费者问题、线程池

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

Java–多线程–JUC、死锁、lock、生产者与消费者问题、线程池

JUC

package com.zy.thread;

import java.util.concurrent.CopyOnWriteArrayList;

/**
 *description: Java--多线程--JUC
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-28 21:13
 */
public class StudyThreadJUC {

    public static void main(String[] args) {
        // 默认线程安全
        CopyOnWriteArrayList list = new CopyOnWriteArrayList();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("List大小："+list.size());
    }
}

死锁

package com.zy.thread;

/**
 *description: Java--多线程--死锁
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-28 21:24
 */
public class StudyThreadDeadLock {

    /*
    死锁：多个线程互相抱着对方需要的资源，然后形成僵持。
    产生死锁的4个必要条件：
        1.互斥条件：一个资源每次只能被一个进程使用；
        2.请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放；
        3.不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺；
        4.循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
     */

    public static void main(String[] args) {
        Makeup g1 = new Makeup(0, "灰姑娘");
        Makeup g2 = new Makeup(1, "白雪公主");

        g1.start();
        g2.start();
    }
}

class Lipstick{

}

class Mirror{

}

class Makeup extends Thread{

    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;
    String girlName;

    public Makeup(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }

    private void makeup() throws InterruptedException {
        if(choice == 0){
            synchronized (lipstick){
                // 获得口红锁
                System.out.println(this.girlName+"获得口红");
                Thread.sleep(1000);

                synchronized (mirror){
                    // 1秒钟后获得镜子
                    System.out.println(this.girlName+"获得镜子");
                }
            }
        }else{
            synchronized (mirror){
                // 获得口红锁
                System.out.println(this.girlName+"获得镜子");
                Thread.sleep(2000);

                synchronized (lipstick){
                    // 2秒钟后获得镜子
                    System.out.println(this.girlName+"获得口红");
                }
            }
        }
    }

    @Override
    public void run() {
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

lock

package com.zy.thread.lock;

import java.util.concurrent.locks.ReentrantLock;

/**
 *description: Java--多线程--Lock
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-28 21:41
 */
public class StudyThreadLock {

    /*
    synchronized 与 Lock 的对比：
        1.lock锁是显示锁（手动开启和关闭），synchronized是隐式锁，出了作用域自动释放；
        2.lock只有代码块锁，synchronized有代码块锁和方法锁；
        3.使用lock锁，jvm将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）；
        4.优先使用顺序：lock>同步代码块>同步方法。
     */

    public static void main(String[] args) {
        TestLock testLock = new TestLock();

        new Thread(testLock).start();
        new Thread(testLock).start();
        new Thread(testLock).start();
    }
}

class TestLock implements Runnable{

    int ticketNums = 10;

    // 定义可重入锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            // 加锁
            lock.lock();
            try {
                if(ticketNums>0){
                    Thread.sleep(1000);
                    System.out.println(ticketNums--);
                }else{
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 解锁
                lock.unlock();
            }
        }
    }
}

PCP–》管程法

package com.zy.thread.pcp;

/**
 *description: Java--多线程--生产者与消费者问题（多线程通信）
 * 利用缓冲区解决：管程法
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-28 22:07
 */
public class StudyThreadPCP {

    public static void main(String[] args) {
        Buffer buffer = new Buffer();

        new Productor(buffer).start();
        new Consumer(buffer).start();
    }
}

// 生产者
class Productor extends Thread{
    Buffer buffer;

    public Productor(Buffer buffer){
        this.buffer = buffer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            buffer.push(new Product(i));
            System.out.println("生产了"+i+"个产品");
        }
    }
}

// 消费者
class Consumer extends Thread{
    Buffer buffer;

    public Consumer(Buffer buffer){
        this.buffer = buffer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了-->"+buffer.pop().id+"个产品");
        }
    }
}

// 产品
class Product{
    int id;

    public Product(int id){
        this.id = id;
    }
}

// 缓冲区
class Buffer{

    // 产品容器
    Product[] products = new Product[10];
    // 产品计数
    int count;

    /**
     * @Description 生产
     * @author zy
     * [product]
     * void
     * @date 2023-3-28 22:17
     */
    public synchronized void push(Product product) {
        // 容器满了等待消费
        if(count == products.length){
            // 通知消费者消费，生产者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 容器未满，丢入产品
        products[count] = product;
        count++;

        // 通知消费
        this.notify();
    }

    /**
     * @Description 消费
     * @author zy
     * []
     * com.zy.thread.pcp.Product
     * @date 2023-3-28 22:17
     */
    public synchronized Product pop() {
        // 判断消费
        if(count == 0){
            // 通知生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 消费
        count--;
        Product product = products[count];
        // 通知生产
        this.notify();

        return product;
    }
}

PCP–》信号灯法

package com.zy.thread.pcp;

/**
 *description: Java--多线程--生产者与消费者问题（多线程通信）
 * 信号灯法：标志位解决
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-28 22:07
 */
public class StudyThreadPCP2 {

    public static void main(String[] args) {

        TV tv = new TV();

        new Player(tv).start();
        new Audience(tv).start();
    }
}

// 生产者--》演员
class Player extends Thread{

    private TV tv;

    public Player(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            tv.play("第"+i+"个节目");
        }
    }
}

// 消费者--》观众
class Audience extends Thread{

    private TV tv;

    public Audience(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            tv.watch();
        }
    }
}

// 产品--》节目
class TV{
    private String program;
    private boolean flag = true;

    public synchronized void play(String program){
        // 节目不存在，观众等待
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("演员表演了："+program);
        this.program = program;
        this.flag = !this.flag;
        this.notify();
    }

    public synchronized void watch(){
        // 节目存在，演员等待
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("观众观看了："+program);
        this.flag = !this.flag;
        this.notify();
    }
}

线程池

package com.zy.thread;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import static java.lang.Thread.sleep;

/**
 *description: Java--多线程--线程池
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-28 23:06
 */
public class StudyThreadPool {


    public static void main(String[] args) {
        ExecutorService service = new ThreadPoolExecutor(3,10,3,
                TimeUnit.SECONDS,new ArrayBlockingQueue<>(4));

        /*ExecutorService service = Executors.newFixedThreadPool(10);*/

        //service.prestartAllCoreThreads();

        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        service.shutdown();
    }
}

class MyThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"--》"+i);
        }
    }
}
m0_37570287
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java--JUC快速入门（彻底搞懂JUC）
weixin_43888181的博客
05-08 10万+
java–JUC快速入门（彻底搞懂JUC） 文章目录java--JUC快速入门（彻底搞懂JUC）1、学习多线程之前需要知道的一些概念。2、JUC的结构3、Lock锁(重点)4、集合类不安全5、Callable()6、常用的辅助类7、读写锁8、阻塞队列9、线程池 1、学习多线程之前需要知道的一些概念。 1.1 JUC是什么？ JUC是java.util.concurrent包的简称，在Java5.0添加，目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！...
JUC - 多线程之Synchronized和Lock锁；生产者消费者模式（一）
MinggeQingchun的博客
10-17 576
JUC首先，再简单说一下并行、并发；进程、线程。
JAVA多线程-生产者消费者模型
SIESTA030的博客
01-27 623
生产者消费者模型 一个经典的同步模型。 在Java中要制作这个模型，得满足以下几个条件： 高内聚低耦合前提下，线程操纵资源类。 判断、干活、唤醒通知。 严防多线程并发状态下的虚假唤醒。 传统的：sync、wait、notify JUC变种：lock、await、signal 以上这俩种都不是我们的重点。 下面还是来实现一下。 传统JUC锁版 示例 双线程情况，大于双线程就得加多个 condition class Data { private int number
JUC 死锁 Lock 线程协作 线程池
weixin_50224527的博客
03-05 86
JUC 版本更迭 ,我用concurrent还是导致了不安全, 给没给线程沉睡,主程序跑完 新线程还在创建 package com.cjg.xiancheng; import java.util.concurrent.CopyOnWriteArrayList; public class threadCu { public static void main(String[] args) { CopyOnWriteArrayList<String> list =new C
Java多线程学习（二）- 线程同步、锁、JUC、线程池、生产消费模式
jianyong的博客
01-17 189
线程状态 线程方法 线程停止 不推荐使用JDK提供的stop()、destroy()方法。【已废弃】 推荐线程自己停止下来 建议使用一个标志位进行终止变量，当flag=false,则终止线程运行 线程休眠sleep() sleep(时间)指定当前线程阻塞的毫秒数 sleep存在InterruptedException异常 sleep时间达到后线程处于就绪状态 sleep可以模拟网络延时，倒计时等 每一个对象..
Java核心技术之- 多线程并发-JUC总结-并发编程
Aili的博客
05-24 488
1. 线程基础线程的创建与启动方式- 线程生命周期管理- 线程的状态转换- 线程同步与互斥- 程优先级设置2. 线程间通信- synchronized 关键字及其实现原理- wait() ， notify() ，notifyAll()，join()方法的使用- Lock 和 Condition 的使用- volatile 关键字的使用 - 原子类的使用- ConcurrentHashMap 和 ConcurrentLinkedQueue 的使用- CountD
Java多线程学习二（同步、死锁、lock锁、线程通讯生产消费者、线程池）
无极
04-14 295
并发 概念：同一个对象被多个线程同时操作 线程同步 线程同步sync形成条件（实现原理）：队列和锁 三大不安全案例： 案例1：不安全买票 输出： 案例2：不安全的取钱 sleep可以放大问题的发生性 不加延时可能不会出现问题，因为一开始第一个线程执行完了之后再执行第二个线程的话，第二个线程就拿到变化之后的资源进行判断了，加延时的话他们都拿到了未变化的资源。 案例3：线程不安全的...
多线程进阶（下篇）---Callable 接口、JUC（java.util.concurrent) 的常见类、线程池、线程安全的集合类、死锁、其他常见面试题
m0_64247824的博客
05-05 421
本篇包含：Callable 接口、JUC（java.util.concurrent) 的常见类、线程池、线程安全的集合类、死锁、其他常见面试题
JUC-01-JUC简介，进程和线程，Lock锁，生产消费问题
09-25 218
目录01，什么是JUC？02，进程和线程03，java开线程的三种方法 01，什么是JUC？ 所谓JUC就是java并发工具包：java.util.concurrent 学习JUC主要学习三个包的使用： java.util.concurrent java.util.concurrentatomic java.util.concurrent.locks 02，进程和线程 进程： 进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，即进程空间或（虚空间） 进程不依赖于线程而独立存在，一个
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 299
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
（javaweb）请求响应postman
2301_79144798的博客
08-08 473
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 215
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
SpringBoot快速入门（手动创建）
最新发布
m0_74124657的博客
08-11 251
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
Spring事务
c1tenj2的博客
08-07 440
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
反射和注解
supercool7的博客
08-08 260
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
安卓Android & JAVA校招/实习面试合集:多线程、强软弱虚引用、进程、内存管理、Activity、Fragment......
qq_41915623的博客
08-10 396
安卓Android、java面试资料合集：内存管理、多线程、进程、强软弱虚应用、Activity
Java：继承，this，super
m0_75257168的博客
08-10 316
可以同名，但参数列表不能相同（有参无参构造）
JVM 加载阶段 Class对象加载位置是在 堆中还是方法区？
萧曳丶
08-06 408
Class对象的加载位置：Class对象本身是加载到堆区中的。类的类型信息加载位置：类的类型信息（元数据）是加载到方法区（或元空间）中的。因此，对于问题“jvm 加载阶段 Class加载到堆中还是方法区”，答案是：Class对象加载到堆中，而类的类型信息加载到方法区（或元空间）中。这两个区域在JVM的类加载过程中都扮演着重要的角色，共同支持着Java程序的运行。
Spring一个强大便捷的代理工厂类
330553352的专栏
08-10 261
但如果你需要一种更加灵活和可配置性，那么Spring还提供了一个非常方便强大的ProxyFactoryBean类，该类特别适合那些需要更多自定义和控制的场景，例如当你需要为特定的Bean创建代理，或者需要在不修改原始代码的情况下为现有类添加额外的功能时。在Spring框架中，AOP（面向切面编程）是一种强大的编程范式，它允许开发者在不修改原有代码的情况下，为程序添加额外的功能，如日志记录、事务管理、安全控制等。在上面配置拦截器时，我们都是指定的具体拦截器，其实我们还可以使用通配符，指定拦截器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值