java实现王道多线程情景的编写

已于 2023-04-12 18:57:04 修改
阅读量152 收藏
点赞数
文章标签： java 开发语言
于 2023-04-12 18:23:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43193533/article/details/130112708
版权
本文展示了Java中使用Semaphore实现的生产者消费者问题解决方案，以及多生产者多消费者模型。同时，讨论了读写分离场景下的公平写法，防止写线程饥饿，并提供了两种不同的读写锁实现来确保并发控制的公平性。
摘要由CSDN通过智能技术生成

#java实现王道多线程情景的编写

生产者消费者

在这里插入图片描述


public class 生产者消费者 {
    public static void main(String[] args) {
        Semaphore full = new Semaphore(0);//表示 empty();
        Semaphore empty = new Semaphore(3);//表示 empty();
        Deque<Integer> dq = new LinkedList<>();
        Object lock=new Object();
        new Thread(new Runnable(){
            //生产者代码
            public void run(){
                while(true){
                    try {
                        empty.acquire();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (lock){
                        dq.offerFirst(1);
                        System.out.println("放入了一个资源");
                    }
                    full.release();
                }
            }
        }).start();
        new Thread(new Runnable() {
            //这里是消费者代码
            @SneakyThrows
            @Override
            public void run() {
                while (true){
                    try {
                        full.acquire();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (lock){
                        Thread.sleep(500);
                        Integer first = dq.pollFirst();//直接取，保证有;
                        System.out.println(first);
                    }
                    empty.release();
                }
            }
        }).start();
    }
}

多生产者多消费者

在这里插入图片描述


public class 多消费者模型 {


    public static void main(String[] args) {


        Semaphore plate = new Semaphore(1);

        Semaphore orange=new Semaphore(0);
        Semaphore apple=new Semaphore(0);
        Thread dad = new Thread(new Runnable() {
            //dad、、 往里面放橙子
            @SneakyThrows
            @Override
            public void run() {
                while(true){
                    Thread.sleep(300);
                    try {
                        plate.acquire();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    orange.release();//女儿爱吃橘子
                }

            }
        });
        Thread mom = new Thread(new Runnable() {
            //mom 往里面放apple
            @SneakyThrows
            @Override
            public void run() {
                while(true){
                    Thread.sleep(1000);//苹果生产速度很慢
                    try {
                        plate.acquire();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    apple.release();//儿子爱吃苹果
                }
            }
        });
        Thread son = new Thread(new Runnable() {
            //dad、、 往里面放橙子
            @Override
            public void run() {
                while(true){
                    try {
                        apple.acquire();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("儿子吃到了一个苹果");
                    plate.release();
                }

            }
        });
        Thread daughter = new Thread(new Runnable() {
            //dad、、 往里面放橙子
            @Override
            public void run() {
                while (true){
                    try {
                        orange.acquire();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("女儿吃到了一个橘子");
                    plate.release();
                }

            }
        });
        dad.start();
        mom.start();
        son.start();
        daughter.start();
    }
}

读写分离，饥饿的情况

在这里插入图片描述


public class 读写锁公平写法 {
    static  int count=0;
    public static void main(String[] args) {
        Lock mu =new ReentrantLock();
        Lock rw=new ReentrantLock();
        new Thread(()->{
            while(true){
                try{
                    rw.lock();
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("我是写线程");
                }catch (Exception e){
                }
                finally {
                    rw.unlock();
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
       new Thread(()->{
           while (true){
               mu.lock();
               count++;
               if(count==1){
                   rw.lock();
               }
               mu.unlock();
               try {
                   Thread.sleep(100);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println("我在读1");
               mu.lock();
               count--;
               if(count==0){
                   rw.unlock();
               }
               mu.unlock();
           }
       }).start();
       //读的线程是可以并发跑起来的;
        new Thread(()->{
            while (true){
                mu.lock();
                count++;
                if(count==1){
                    rw.lock();
                }
                mu.unlock();
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("我在读2");
                mu.lock();
                count--;
                if(count==0){
                    rw.unlock();
                }
                mu.unlock();
            }
        }).start();

    }
}

读写分离 保护写不会被饥饿

在这里插入图片描述


public class 读写锁公平写法2 {
    static  int count=0;
    public static void main(String[] args) {
        Lock mu =new ReentrantLock();
        Lock rw=new ReentrantLock();
        Lock r3=new ReentrantLock();
       new Thread(()->{
           while (true){
               try{
                   r3.lock();
                   mu.lock();
                   if(count==0){
                       rw.lock();
                   }
                   count++;
               }catch (Exception e){}
               finally {
                   mu.unlock();
                   r3.unlock();
               }
               try {
                   Thread.sleep(100);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println("我在读1");
               try{
                   mu.lock();
                   count--;
                   if(count==0){
                       rw.unlock();
                   }
               }catch (Exception e){}
               finally {
                   mu.unlock();
               }

           }
       },"读者1").start();
       //读的线程是可以并发跑起来的;
        new Thread(()->{
            while (true){
                try{
                    r3.lock();
                    mu.lock();
                    if(count==0){
                        rw.lock();
                    }
                    count++;
                }catch (Exception e){}
                finally {
                    mu.unlock();
                    r3.unlock();
                }
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("我在读2");
                try{
                    mu.lock();
                    count--;
                    if(count==0){
                        rw.unlock();
                    }
                }catch (Exception e){}
                finally {
                    mu.unlock();
                }
            }
        },"读者2").start();
        new Thread(()->{
            while(true){
                try{
                    r3.lock();
                    rw.lock();
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("我是写线程");
                }catch (Exception e){
                }
                finally {
                    rw.unlock();
                    r3.unlock();
                }
            }
        }).start();
    }
}
BMWkqkq
关注
【王道Java】网络编程实战详解三【TCP完结】
一键难忘的博客
05-15 511
一，前言 上篇文章，写了通信协议，服务端与客户端的文本传输原理。 这篇写一下文件的传输原理。
【王道Java】网络编程实战学习一
一键难忘的博客
05-13 514
文章目录一，网络编程1.2，目的：二，Java万物皆对象2.1，InetAddress类2.2，端口2.3 InetSocketAddress类三，最后 一，网络编程 网络编程在很大程度上是发送和接收信息的功能，中间传输是物理线路。 1.2，目的： 计算机网络： 计算机网络是指在网络操作系统、网络管理软件和网络通信协议的管理和协调下，通过通信线路将不同地理位置上具有独立功能的多台计算机及其外部设备连接起来，实现资源共享和信息传输的计算机系统。 网络编程目的： 数据交流，数据交互。就是通信。 过程： 1，确
Java学习王道
码龙008
06-15 1956
学习方法       |_浪曦视频在线_风中叶_学习程序设计方法       |_浪曦视频在线_风中叶_学习岂有无痛之理       |_浪曦视频在线_胡屹_如何获取学习资源 J2SE 基础       |_尚学堂科技_马士兵_JAVA视频教程_J2SE      |_尚学堂科技_马士兵_JAVA视频教程_J2SE_专题（可以根据实际情况调整此部分学习） 
王道Java全栈工程师培养计划
frankie_liu的博客
01-07 1391
第一方面 前端开发 HTML5/ CSS3/ Javascript Jquery 第二方面 Java编程语言 Java基础知识 继承/多态/抽象类/接口 异常处理 多线程开发 IO流/文件操作 网络编程 反射、注解 内存管理 第三方面 Android移动前端开发 Android 开发环境搭建
【王道】数据结构与算法线性表(二)，Java面试题库
m0_62261166的博客
04-02 753
2.6、顺序表的查找3、单链表顺序表：用顺序存储结构实现的线性表叫做顺序表顺序表优点：可随机存取，存储密度高顺序表缺点：要求大片连续空间，改变容量不方便链表：用链式存储结构实现的线性表叫做链表，链表分为：单链表双链表循环链表静态链表单链表优点：不要求大片连续空间，改变容量方便单链表缺点：不可随机存取，要耗费一定空间存放指针3.1、单链表的定义typedef struct LNode{ //定义单链表结点类型//定义单链表结点类型(数据域)
JAVA MyBatis框架(超详细教程)
淡若清风
01-28 1345
MyBatis 框架 1.是什么？ 一个用于简化jdbc操作的持久层框架。 2.应用的优势？ 简单、开源、稳定，功能强大–灵活的SQL定制，参数映射，结果映射 3.SpingBoot工程中的mybatis应用环境搭建？ 3.1）添加依赖(mybatis) : 1）官网http://mybatis. org/spring- boot- starter/mybatis-spring -boot-autoconfi gure/ 2）拷贝现成的依赖 3）alt+insert打开插件连接官网下载 3.2）初始配置(事
Java的各种实验包括反射，算法，多线程，面试题，springboot
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客上的面经及王道考研相关视频，并改进了其中说法矛盾或含糊之处。 包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多...
2022java面试题、JVM面试题、多线程面试题、并发编程
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客上的面经及王道考研相关视频，并改进了其中说法矛盾或含糊之处。 包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多...
202面试题，Java面试题、JVM面试题、多线程面试题、并发编程
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客上的面经及王道考研相关视频，并改进了其中说法矛盾或含糊之处。 包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多...
王道训练营Java工程师 课程大纲1
08-03
介绍，垃圾回收原理，常见垃圾回收算法，OOM及第二阶段数据结构和算法、Week4JAVA 集合的使用，CollectionHashMapWeek5Java 数据
Java基于ssm的王道考研购物网站的实现.zip
06-23
Java基于ssm的王道考研购物网站的实现.zip 开发语言：Java 框架：ssm JDK版本：JDK1.8 服务器：tomcat7 数据库：mysql 5.7 数据库工具：Navicat11 开发软件：eclipse/myeclipse/idea Maven包：Maven3.3.9
王道训练营—Java编程经典50题
WoodyWoodyLee的博客
12-29 5057
纯手敲，转载请说明出处，谢谢~~~ 【程序1】 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？ 1.程序分析：兔子的规律为数列1,1,2,3,5,8,13,21… /** * @auther WoodyWoodyLee39@gmail.com */ public class Main01{...
Java实现《王道数据结构》伪代码
David的博客
02-28 1144
一、单链表 1.结点定义 public class ListNode { int data; ListNode next; ListNode (int data){ this.data=data; } } 2.建立链表 /** * 头插法建立链表 * @return 链表指针 */ public Lis...
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1119
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
最新发布
xiaocaij_icai的博客
09-15 157
");
基于SpringBoot的考研资讯平台设计与实现
linzhongshu的专栏
09-13 889
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 926
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
Java多线程并发实战：面试重点与解答
"多线程/并发-王道2020年操作系统" 在IT行业中，多线程和并发处理是提升系统性能的关键技术。在操作系统中，理解并掌握多线程的创建、线程安全、死锁预防以及并发相关的关键字如Volatile，对于构建高效且稳定的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值