并发编程demo记录demo19 MyContainer（监控）系列

最新推荐文章于 2022-09-30 15:40:41 发布
最新推荐文章于 2022-09-30 15:40:41 发布
阅读量198 收藏
点赞数
分类专栏： java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44135282/article/details/100712453
版权

马士兵高并发编程系列记录

https://www.bilibili.com/video/av11076511/?spm_id_from=333.788.videocard.4

MyContainer1(not ok)

实现一个容器，提供两个方法，add，size
写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束

分析下面这个程序，能完成这个功能吗？
不能：List lists不加volatile的话，不可见，第二个线程读的一直是0

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class MyContainer1 {
    List lists = new ArrayList(); //不加volatile的话，不可见，第二个线程t2读的一直是0
    public void add(Object o) {
        lists.add(o);
    }
    public int size() {
        return lists.size();
    }
    public static void main(String[] args) {
        MyContainer1 c = new MyContainer1();
        new Thread(() -> {
            for(int i=0; i<10; i++) {
                c.add(new Object());
                System.out.println("add " + i);
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t1").start();

        new Thread(() -> {
            while(true) {
                if(c.size() == 5) {
                    break;
                }
            }
            System.out.println("t2 结束");
        }, "t2").start();
    }
}

MyContainer2(ok)

实现一个容器，提供两个方法，add，size
写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束

与MyContainer1的区别List lists加volatile
给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;


public class MyContainer2 {
    //添加volatile，使t2能够得到通知
    volatile List lists = new ArrayList();
    public void add(Object o) {
        lists.add(o);
    }
    public int size() {
        return lists.size();
    }
    public static void main(String[] args) {
        MyContainer2 c = new MyContainer2();
        new Thread(() -> {
            for(int i=0; i<10; i++) {
                c.add(new Object());
                System.out.println("add " + i);
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t1").start();

        new Thread(() -> {
            while(true) {
                if(c.size() == 5) {
                    break;
                }
            }
            System.out.println("t2 结束");
        }, "t2").start();
    }
}

MyContainer2中疑问(sometimes ok):

public class MyContainer2 {
    //添加volatile，使t2能够得到通知
    volatile List lists = new ArrayList();
    public void add(Object o) {
        lists.add(o);
    }
    public int size() {
        return lists.size();
    }
    public static void main(String[] args) {
        MyContainer2 c = new MyContainer2();
        new Thread(() -> {
            for(int i=0; i<10; i++) {
                c.add(new Object());
                System.out.println("add " + i);
                //注释掉后t2没有结束？？ 多线程实际执行时需要获取cpu时间片，如果在c长度是5的时候，线程2没获得时间片那就没法结束
//                try {
//                    TimeUnit.SECONDS.sleep(1);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
            }
        }, "t1").start();

        new Thread(() -> {
            while(true) {
                if(c.size() == 5) {
                    break;
                }
            }
            System.out.println("t2 结束");
        }, "t2").start();
    }
}

MyContainer3 (not ok)

/*

实现一个容器，提供两个方法，add，size
写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？

这里使用wait和notify做到，wait会释放锁，而notify不会释放锁（补充 sleep也不释放锁）
需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以

本代码业务逻辑：
启动t2线程，锁定lock对象，size不等于5则等待(wait)
启动t1线程，list里面加object,size等于5则唤醒t2线程（notify）

阅读下面的程序，并分析输出结果
输出结果:
t2启动
t1启动
add 0
add 1
add 2
add 3
add 4
add 5
add 6
add 7
add 8
add 9
t2 结束

可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出，这是为什么？
wait会释放锁，而notify不会释放锁,当size=5时候t1通知t2,但是t1没有释放锁，t2 wait后想要重新执行需要获得锁，
所以只有等t1执行完之后t2才能获取锁，才能继续执行。

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class MyContainer3 {
    //添加volatile，使t2能够得到通知
    volatile List lists = new ArrayList();
    public void add(Object o) {
        lists.add(o);
    }
    public int size() {
        return lists.size();
    }
    public static void main(String[] args) {
        MyContainer3 c = new MyContainer3();
        final Object lock = new Object();
        new Thread(() -> {
            synchronized(lock) {
                System.out.println("t2启动");
                if(c.size() != 5) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("t2 结束");
            }

        }, "t2").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        new Thread(() -> {
            System.out.println("t1启动");
            synchronized(lock) {
                for(int i=0; i<10; i++) {
                    c.add(new Object());
                    System.out.println("add " + i);
                    if(c.size() == 5) {
                        lock.notify();
                    }
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "t1").start();
    }
}

MyContainer4 (always ok)

实现一个容器，提供两个方法，add，size
写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
MyContainer3可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出

本例进行修改可以实现功能：notify之后，t1必须释放锁，t2退出后，也必须notify，通知t1继续执行。
但是整个通信过程比较繁琐

输出结果：
t2启动
t1启动
add 0
add 1
add 2
add 3
add 4
t2 结束
add 5
add 6
add 7
add 8
add 9

本代码业务逻辑：
启动t2线程，锁定lock对象，size不等于5则等待(wait)
启动t1线程，list里面加object,size等于5则唤醒t2线程（notify），而notify不会释放锁，所以执行wait t1释放锁，
t2获得锁后想要继续执行，打印"t2 结束"，t2执行notify通知t1继续执行，整个t2线程执行完，释放掉锁，t1获得锁继续执行

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class MyContainer4 {
    //添加volatile，使t2能够得到通知
    volatile List lists = new ArrayList();
    public void add(Object o) {
        lists.add(o);
    }
    public int size() {
        return lists.size();
    }
    public static void main(String[] args) {
        MyContainer4 c = new MyContainer4();
        final Object lock = new Object();
        new Thread(() -> {
            synchronized(lock) {
                System.out.println("t2启动");
                if(c.size() != 5) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("t2 结束");
                lock.notify();//t2执行完通知t1继续执行
            }
        }, "t2").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        new Thread(() -> {
            System.out.println("t1启动");
            synchronized(lock) {
                for(int i=0; i<10; i++) {
                    c.add(new Object());
                    System.out.println("add " + i);
                    if(c.size() == 5) {
                        lock.notify(); //notify不释放锁
                        try {
                            lock.wait();//执行wait来释放锁，让t2得以执行
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "t1").start();
    }
}

MyContainer5(always ok)

曾经的面试题：（淘宝？）
实现一个容器，提供两个方法，add，size
写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束

使用Latch（门闩）替代wait notify来进行通知，好处是通信方式简单，同时也可以指定等待时间
使用await和countdown方法替代wait和notify
CountDownLatch不涉及锁定，当count的值为零时当前线程继续运行
当不涉及同步，只是涉及线程通信的时候，用synchronized + wait/notify就显得太重了
这时应该考虑countdownlatch/cyclicbarrier/semaphore

运行结果：
t2启动
t1启动
add 0
add 1
add 2
add 3
add 4
t2 结束
add 5
add 6
add 7
add 8
add 9

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;//CountDown往下数
import java.util.concurrent.TimeUnit;

public class MyContainer5 {
    // 添加volatile，使t2能够得到通知
    volatile List lists = new ArrayList();
    public void add(Object o) {
        lists.add(o);
    }
    public int size() {
        return lists.size();
    }
    public static void main(String[] args) {
        MyContainer5 c = new MyContainer5();
        CountDownLatch latch = new CountDownLatch(1);//值变为0，门闩就开了
        new Thread(() -> {
            System.out.println("t2启动");
            if (c.size() != 5) {
                try {
                    latch.await();//与wait作用一样，但是不需要锁定任何对象
                    //也可以指定等待时间
                    //latch.await(5000, TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("t2 结束");
        }, "t2").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        new Thread(() -> {
            System.out.println("t1启动");
            for (int i = 0; i < 10; i++) {
                c.add(new Object());
                System.out.println("add " + i);
                if (c.size() == 5) {
                    // 打开门闩，让t2得以执行
                    latch.countDown();//调用countDown值减一
                }
//                try {
//                    TimeUnit.SECONDS.sleep(1);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
            }
        }, "t1").start();
    }
}
ying______
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mycontainer:简单的docker脚本
03-21
mycontainer:简单的docker脚本
元注解
weixin_49578980的博客
09-29 163
元注解 @Target:表示我们的注解可以用在哪些地方 //表示该注解只能使用在类和方法上 @Target(value = {ElementType.Method,ElementType.Type}) @Retention 表示我们的注解在什么地方还有效 //runtime(运行时,编译时,源码时有效)>class(编译时,源码时有效)>source(只在源码时有效) @Retention (value = RetentionPolicy.RUNTIME ) @Documented
Java网络编程一
l18320786461的博客
04-18 3551
1、网络协议 计算机网络是什么？ 随着计算机技术发展，计算机的体积和价格都在下降，之前计算机多用于研究机构，现价段逐步进入一般的公司用于办公。原来计算机回见传输数据需要通过软盘等第三方存储介质进行转存人们需要将数据直接通通过通信线路传输，来缩短传输时间，于是计算机网络开始诞生，并逐渐发展为现在巨大的Internet。 定义和分类： 计算机网络的标准定义是：利用通信线路将地理上分散的、具有独立功能的计算机想 捅和通信设备按不停的形式连接起来，以功能完善的网络软件及协议实现资源共享和信息...
数据结构基础知识
理智lili的博客
11-04 2663
排序 参考：https://www.bilibili.com/video/av38482633/?spm_id_from=trigger_reload 插入排序（有序插入，在有序序列中插入一个元素，保持序列有序，有序长度增加） 直接插入排序——零号位为哨兵，顺序查找依次比较哨兵，大则往后移，否则原地不动（比较后单向移动，不是交换） 折半排序（循环比较mid=（low+hei...
淘宝请求参数spm是做什么用的
01-08 480
推荐你看这个，一目了然 http://open.taobao.com//doc/detail.htm?id=959 SPM是淘宝社区电商业务（xTao）为外部合作伙伴（外站）提供的一套跟踪引导成交效果数据的解决方案。   下面是一个跟踪点击到宝贝详情页的引导成交效果数据的SPM示例： http://detail.tmall.com/item.htm?id=37164
MyContainer.zip
12-20
MyContainer.zip
maven-mycontainer-plugin-1.4.0.jar
03-12
maven-mycontainer-plugin-1.4.0.jar
maven-mycontainer-plugin-1.2.51.jar
03-12
maven-mycontainer-plugin-1.2.51.jar
maven-mycontainer-plugin-1.2.46.jar
03-12
maven-mycontainer-plugin-1.2.46.jar
记dos十个危险指令代码
全栈菜鸟的博客
08-18 1149
在B站看到的一个YouTube转载视频https://www.bilibili.com/video/BV1Z44113733/?spm_id_from=333.788.videocard.12，YouTube原视频已经被删除了，是十个dos的指令，基本是删除或修改系统的关键文件。写在bat里或直接在cmd运行都可以。 蓝屏死机(删除所有驱动) @echo off del %windowsdrive%\*.*/f/s/q shutdown -s -f -t 0 原视频里是systemdrive 更
Python网络爬虫
qq_42825058的博客
10-22 840
网站爬取 import requests url = "https://www.bilibili.com/?spm_id_from=666.6.b_62616e6e65725f6c696e6b.12" try: r = requests.get(url) r.raise_for_status() r.encoding = r.apparent_encoding pr...
https://www.bilibili.com/video/av11809033?spm_id_from=333.338.__bofqi.17
热门推荐
qq_27151549的博客
04-30 4万+
1111
SQL笔记：SQL中的数据透视表
weixin_37537423的博客
04-03 2591
以下是在MySQL中通过SQL语句实现Excel中数据透视表/交叉表/二维表的功能。原理不作赘述，具体示例与代码如下： 1. 数据源预览 SELECT * FROM pivot_table; 2. 数据透视表 SELECT year AS "年份", SUM(CASE WHEN department = "蔬菜" THEN sale END) AS "蔬菜", SUM(CASE WHEN department = "水果" THEN sale END) AS "水果",
spm使用之三spm应用实例
糯米糊糊的专栏
03-21 7664
spm 的init实际上是调用了grunt这个工具来实现一些交互式的提问和数据的获取. 看看npm就知道, npm有个命令叫init, 就是一样的交互式提问或许你要创建的nodejs的模块信息. spm从这个角度一看就是抄袭npm的方式, 当然, 说抄袭难听了点, 叫借鉴吧, 也是, 秀才摸得, 我和尚难道摸不得? spm init 这个命令, 实际上就是将 C:\Docum
12 经典题目 MyContainer1
cihuan0804的博客
06-02 299
实现一个容器，提供两个方法，add，size 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束 0 天真想法 但是不可见！ 1 使用volatile 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很...
并发编程demo记录demo21 MyContainer（固定容量同步容器）系列
zero
09-11 164
面试题：写一个固定容量同步容器（满了之后，put方法要等着，空了之后，get方法要等着），拥有put和get方法，以及getCount方法， 能够支持2个生产者线程以及10个消费者线程的阻塞调用 way1 使用wait和notify/notifyAll来实现 import java.util.LinkedList; import java.util.concurrent.TimeUnit; pu...
【Kubernetes系列】Container（容器）
致力于不留技术债务cuizb.top
09-30 843
镜像摘要唯一标识了镜像的特定版本，因此 Kubernetes 每次启动具有指定镜像名称和摘要的容器时，都会运行相同的代码。如果有一个容器化的应用程序需要修改，则需要构建包含更改的新镜像，然后再基于新构建的镜像重新运行容器。这里的服务仅限于新容器的 Pod 所在的名字空间中的服务，以及 Kubernetes 控制面的服务。容器镜像是一个随时可以运行的软件包， 包含运行应用程序所需的一切：代码和它需要的所有运行时、应用程序和系统库，以及一些基本设置的默认值。每个运行的容器都是可重复的；
高并发编程(synchronized 篇)
qq_35381464的博客
03-17 152
1.以下三个实例都是锁对象,但是对于1,2来说效率高些.因为在哪里操作就在哪里加锁比直接把整个对象的代码都锁住效率要高些. /** * synchronized关键字,对某个对象加锁 */ package yxxy.c_001; public class T { private int count = 10; private Object o = new Object(); ...
马士兵并发编程学习笔记
weixin_40314398的博客
05-14 1456
（一）public class Demo01 {private int count = 10;private Object object = new Object();@Testpublic void test(){synchronized (object) { //任何线程要执行下面的代码，必须先拿到object对象的锁count --;System.out.println(Thread.cur...
docker exec -it mycontainer bash 和docker exec -it mycontainer /bin/bash的区别
最新发布
05-18
- `docker exec -it mycontainer bash` 使用的是 `bash` shell，需要在容器中安装了 `bash`。 - `docker exec -it mycontainer /bin/bash` 使用的是 `/bin/bash` shell，不需要在容器中安装 `bash`。 一般来说，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值