synchronized运用理解(二)

最新推荐文章于 2024-09-14 21:48:00 发布
最新推荐文章于 2024-09-14 21:48:00 发布
阅读量443 收藏 3
点赞数 9
文章标签： java 大数据 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68082638/article/details/141087103
版权

生产者-消费者问题

生产者-消费者问题也叫做有限缓冲问题,是一个多线程同步的经典案例.

问题描述

生产者线程和消费者线程在实际运行发生的问题.生产者不断生产数据放到缓冲区,消费者不断地去缓冲区消费数据.

问题关键

1:保证生产者不会在缓冲区满时加入数据,消费者也不会在缓冲区为空时消耗数据.

2:保证生产者加入过程和消费者消费过程中不会产生错误的数据和行为.

生产者-消费者是一个经典的设计模式,比如线程的阻塞队列,synchronized内置锁还有显示锁lock

还有mq等都有这种思想.

生产者-消费者模式

关键点 

1:生产者与生产者之间 消费者与消费者之间,对数据缓存区的操作是同步进行的.

2:数据缓冲区是有上限的,数据满后,生产者不能再加入数据.缓冲区为空的话,消费者不能再取出数据.

3:数据缓冲区是线程安全的.在并发操作过程中不会出现数据不一致的情况,或者多线程操作并发更改数据后,不会造成出现脏数据的情况.

4:生产者和消费者线程在空闲时,需要尽可能阻塞而不是执行无效的空操作,尽量节省CPU资源.

线程不安全的缓冲区实现版本
public class NotSafeDataBuffer<T> {

    public static final int MAX_AMOUNT = 10;

    private List<T> dataList = new LinkedList<>();

    //保存数量.
    private AtomicInteger amount = new AtomicInteger(0);

    //向数据区添加一个元素.
    public void add(T element) throws Exception {
        if (amount.get() > MAX_AMOUNT) {
            throw new Exception("队列已满");
        }
        dataList.add(element);
        amount.incrementAndGet();
        //如果数据不一致抛出异常.
        if (amount.get() != dataList.size()) {
            throw new Exception(amount.get() + "!=" + dataList.size());
        }
    }

    //从数据区中取出元素.
    public T get() throws Exception {
        if (amount.get() <= 0) {
            System.out.println("队列已经空了.");
            return null;
        }

        T value = dataList.remove(0);
        amount.decrementAndGet();
        //数据不一致抛出异常.
        if (amount.get() != dataList.size()) {
            throw new Exception(amount.get() + "!=" + dataList.size());
        }
        return value;
    }
}
生产者 消费者的逻辑解耦

通过分离变与不变的原则,通过这种方式不同的生产者和消费者公共部门拆分出来,只需要在构建生产者消费者的时候传入对应的动作就可以.增强了灵活性.

通用生产者实现
public class Producer implements Runnable {

    //生产的时间间隔.
    public static final int PRODUCE_GAP = 200;

    //总次数.
    static final AtomicInteger TURN = new AtomicInteger(0);

    //生产者对象编号.
    static final AtomicInteger PRODUCER_NO = new AtomicInteger(0);

    //生产者名称.
    String name = null;

    //生产者的动作.
    Callable action = null;

    int gap = PRODUCE_GAP;

    public Producer(Callable action, int gap) {
        this.action = action;
        this.gap = gap;
        name = "生产者" + PRODUCER_NO.incrementAndGet();
    }

    @Override
    public void run() {
        while (true) {
            //执行生产者的动作.
            try {
                Object value = action.call();
                //输出生产结果.
                if (null != value) {
                    System.out.println("第" + TURN.get() 
                   + "轮生产:" + value);
                }
                Thread.sleep(gap);
                TURN.incrementAndGet();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
通用消费者实现
public class Consumer implements Runnable {

    //生产的时间间隔.
    public static final int PRODUCE_GAP = 200;

    //总次数.
    static final AtomicInteger TURN = new AtomicInteger(0);

    //生产者对象编号.
    static final AtomicInteger PRODUCER_NO = new AtomicInteger(0);

    //消费者名称.
    String name = null;

    //消费者的动作.
    Callable action = null;

    int gap = PRODUCE_GAP;

    public Consumer(Callable action, int gap) {
        this.action = action;
        this.gap = gap;
        name = "消费者" + PRODUCER_NO.incrementAndGet();
    }

    @Override
    public void run() {
        while (true) {
            //执行消费者的动作.
            try {
                Object value = action.call();
                //输出消费结果.
                if (null != value) {
                    System.out.println("第" + TURN.get() 
                 + "轮生产:" + value);
                }
                Thread.sleep(gap);
                TURN.incrementAndGet();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
数据缓冲区实例 生产动作 消费动作 
public class NotSafePetStore {

    //数据缓冲区静态实例.
    private static NotSafeDataBuffer<IGoods> notSafeDataBuffer
            = new NotSafeDataBuffer<>();

    //生产者执行的动作.
    static Callable<IGoods> produceAction = () -> {
        //生成一个产品.
        IGoods goods = Goods.produceOne();
        try {
            notSafeDataBuffer.add(goods);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return goods;
    };

    //消费者的动作.
    static Callable<IGoods> consumerAction = () -> {
        //从petStore获取商品.
        IGoods goods = null;
        try {
            goods = notSafeDataBuffer.get();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return goods;
    };
}
 不安全的生产者和消费者的版本
public class NotSafePetStore {

    //数据缓冲区静态实例.
    private static NotSafeDataBuffer<IGoods> notSafeDataBuffer
            = new NotSafeDataBuffer<>();

    //生产者执行的动作.
    static Callable<IGoods> produceAction = () -> {
        //生成一个产品.
        IGoods goods = Goods.produceOne();
        try {
            notSafeDataBuffer.add(goods);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return goods;
    };

    //消费者的动作.
    static Callable<IGoods> consumerAction = () -> {
        //从petStore获取商品.
        IGoods goods = null;
        try {
            goods = notSafeDataBuffer.get();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return goods;
    };

    public static void main(String[] args) {
        //同时并发执行的线程数.
        final int THREAD_TOTAL = 20;
        //线程池多用于线程测试模拟.
        ExecutorService threadPool
                = Executors.newFixedThreadPool(THREAD_TOTAL);
        for (int i = 0; i < 5; i++) {
            //生产者实例每生产一个产品,间隔五百毫秒.
            threadPool.submit(new Producer(produceAction, 500));
            //消费者实例消费一个产品间隔1500
            threadPool.submit(new Consumer(consumerAction, 1500));
        }
    }
}

 

  从运行结果可以看出出现了共享数据不一致问题.

线程安全的实现版本
public class SafeDataBuffer<T> {

    public static final int MAX_AMOUNT = 10;

    private LinkedList<T> dataList = new LinkedList<>();

    //保存数量.
    private AtomicInteger amount = new AtomicInteger(0);

    //向数据区添加一个元素.
    public synchronized void add(T element) throws Exception {
        if (amount.get() > MAX_AMOUNT) {
            throw new Exception("队列已满");
        }
        dataList.add(element);
        amount.incrementAndGet();
        //如果数据不一致抛出异常.
        if (amount.get() != dataList.size()) {
            throw new Exception(amount.get() + "!=" + dataList.size());
        }
    }

    //从数据区中取出元素.
    public synchronized T get() throws Exception {
        if (amount.get() <= 0) {
            System.out.println("队列已经空了.");
            return null;
        }
        T value = dataList.remove(0);
        amount.decrementAndGet();
        //数据不一致抛出异常.
        if (amount.get() != dataList.size()) {
            throw new Exception(amount.get() + "!=" + dataList.size());
        }
        
        return value;
    }
}

 很简单就是给两个方法加上synchronized关键字就不会出现对应的问题了.

有时候我就在想我们会不会像我们听到的歌曲一样,让自己的一切弹奏出美妙的旋律.或者更具体点,会不会像毕玄寒泉子他们一样,会不会有一天我也可以云淡风轻的站在那里.

如果大家喜欢我的分享的话,可以关注下微信公众号.

心有九月星辰.

心有九月星辰
关注
synchronized的简单理解
沉淀、分享、成长，让自己和他人都能有所收获！
04-12 1万+
synchronized是Java中解决并发问题的一种最常用的方法，也是最简单的一种方法。它能够保证在同一时刻，被修饰的代码块或方法只会有一个线程执行，以达到保证并发安全的效果。原子性：确保线程互斥地访问同步代码；可见性：保证共享变量的修改能够及时可见；有序性：有效解决重排序问题。原子性"表示一个操作是不可分割的，要么成功执行，要么完全不执行。通常与线程同步相关，可以确保多个线程同时对共享变量进行读写时不会产生竞争条件和数据冲突。可见性。
java中的synchronized理解
u010980545的专栏
12-12 1744
原文网址：http://www.cnblogs.com/GnagWang/archive/2011/02/27/1966606.html synchronized是java语言的关键字（跟static一样），貌似有的地方翻译成同步锁（阻止同步执行的），这个名称挺形象的，从他的名字中就能猜出他大致的用法：当用它来修饰一个方法或者代码块的时候，能够保证在同一时刻最多只有一个线层执行synch
Java-synchronized深入理解
一小平民
11-11 931
java中synchronized用法 打个比方：一个object就像一个大房子，大门永远打开。房子里有 很多房间（也就是方法）。 这些房间有上锁的（synchronized方法）， 和不上锁之分（普通方法）。房门口放着一把钥匙（key），这把钥匙可以打开所有上锁的房间。 另外我把所有想调用该对象方法的线程比喻成想进入这房子某个 房间的人。所有的东西就这么多了，下面我们看看这些东
Synchronized的使用及原理理解
pengli
10-21 319
1，synchronized的使用 synchronized 有三种方式来加锁，分别是 修饰实例方法，作用于当前实例加锁，进入同步代码前 要获得当前实例的锁 静态方法，作用于当前类对象加锁，进入同步代码前要 获得当前类对象的锁 修饰代码块，指定加锁对象，对给定对象加锁，进入同 步代码库前要获得给定对象的锁。 不同的修饰类型，代表锁的控制粒度。 在这里插入代码片 2，锁是如何存储的 1>对象在内存中的布局：(对象是怎么存储的) 在 Hotspot 虚拟机中，对象在内存中的存储布局，可以分为三个区域
Android synchronized用法二
Lucky_bo的专栏
08-22 1470
Android synchronized用法二 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。   1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：   public synchronized void accessVal(int
synchronized 的理解
08-09
### 二、`synchronized`的使用方式 #### 1. 修饰方法 当`synchronized`用于修饰实例方法时，其锁对象是当前对象的实例。这意味着在任意时刻，都只有一个线程可以访问该实例的所有`synchronized`方法，或者进入由`...
深入讲解java线程与synchronized关键字
08-31
理解并熟练运用synchronized关键字对于编写并发安全的Java代码至关重要，它可以有效地解决多线程环境下的数据同步问题，避免竞态条件和数据不一致。在实际编程中，应结合使用其他并发工具类（如Semaphore、Lock等）...
volatile和synchronized的区别
04-19
### volatile与synchronized的区别 #### 一、锁的特性：互斥与可见性 在并发编程中，锁作为实现...总之，在实际开发中，理解并灵活运用这两种机制是非常重要的，它们可以帮助我们构建出高效、可靠的多线程应用程序。
Java多线程synchronized同步方法详解
08-24
Java中的`synchronized`...理解并熟练掌握`synchronized`的用法，包括其锁对象、锁重入和异常处理机制，是编写高效、线程安全的Java代码的关键。在实际开发中，应根据需求灵活运用，以达到最佳的性能和并发控制效果。
Java-网络
2301_81543552的博客
09-14 388
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 371
如果在新建Android项目时报错：Read timed out或者connect timed out。
上传文件到钉盘流程详解
jspyth的博客
09-14 474
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Java集合：Stack详解
yang_brother的博客
09-10 598
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
面试题篇: 跨域问题如何处理(Java和Nginx处理方式)
最新发布
m0_66572126的博客
09-14 489
最常见的解决方案是在服务器端配置 CORS 头。服务器需要在响应中添加适当的 Access-Control-Allow-头来允许跨域请求。
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 773
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
C#基础（11）函数重载
a6s686的博客
09-12 806
我们通过这些例子的学习，想毕你一定已经掌握了函数重载的相关内容，我相信你只要稍加练习，便能达到很熟练的程度。不过不管知识点难或者简单，还是那句话，学习路上，戒骄戒躁，脚踏实地。请期待我的下一篇博客！
Spring AMQP给消息添加头信息
yong472727322的博客
09-10 277
【代码】Spring AMQP给消息添加头信息。
Java多线程教程：深入理解synchronized关键字
onized代码块时，其他线程对“该对象”的该“synchronized方法”或者“synchronized代码块”的访问将被阻塞。这意味着如果线程A正在执行...理解和熟练运用synchronized关键字对于编写健壮的多线程应用程序至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值