观察者模式Java内存管理进阶篇——如何避免内存泄漏

最新推荐文章于 2022-12-09 12:43:09 发布
最新推荐文章于 2022-12-09 12:43:09 发布
阅读量931 收藏
点赞数
分类专栏： android开发 开发技巧 文章标签： 观察者模式 WeakReference
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SweetTool/article/details/88600141
版权

一、什么叫观察者模式

       观察者模式是常用的设计模式之一；例如在下载文件时，我们可能会更新图标动画，另外在别的控件显示当前下载进度，下载完成后要对文件进行处理，可能这些处理过程都是不同的业务模块，这些模块的生命周期不一样。

简单来说观察者模式可以理解为对多个回调实体对象的管理；

 

二、简单案例


下面我们通过一个简单的例子来讲解如何设计观察者模式：
本案例是新建一个线程可以设定定时器，在时间到时发送当前的时间，最后把时间反馈给注册者。

首先我们定义回调接口

public interface ObserverCallback {
    public void onTime(String textTime);
}

然后在时间触发处管理回调实体

package com.penny.javademo;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class Observer implements Runnable {
    private static final String TAG = Observer.class.getSimpleName();

    private volatile boolean running = false;
    private long interval = 1000;
    private List<ObserverCallback> callbacks = new CopyOnWriteArrayList<>();

    public Observer(long intervalMillsec) {
        if (interval < 1) {
            throw new IllegalArgumentException("interval must be larger than 0. interval: " + interval);
        }
        this.interval = intervalMillsec;
    }

    public void addCallback(ObserverCallback cb) {
        if (null == cb) {
            return;
        }

        synchronized (this) { // 防止异步线程同时find然后插入
            boolean find = false;
            for (ObserverCallback temp : callbacks) {
                if (cb == temp) {
                    find = true;
                    break;
                }
            }
            if (!find) {
                callbacks.add(cb);
            }
        }
    }

    public void removeCallback(ObserverCallback cb) {
        synchronized (this) {
            boolean find = false;
            for (ObserverCallback temp : callbacks) {
                if (cb == temp) {
                    find = true;
                    break;
                }
            }
            if (find) {
                callbacks.remove(cb);
            }
        }
    }

    public void initEvent() {
        synchronized (this) {
            if (! running) {
                new Thread(this).start();
            }
        }
    }

    public void terminate() {
        synchronized (this) {
            this.running = false;
        }
    }

    @Override
    public void run() {
        boolean localRun = running;
        synchronized (this) {
            this.running = true;
            localRun = running;
        }

        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        while (localRun) {
            // 处理回掉事件
            for (ObserverCallback cb : callbacks) {
                cb.onTime(df.format(Calendar.getInstance().getTime()));
            }

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

            synchronized (this) {
                localRun = running;
            }
        }

        synchronized (this) {
            this.running = false;
        }
    }
}

回调管理者，时间触发为定时发送当前时间；
 

@Test
public void testObserver() {
	final String tag = "testObserver";
	Observer o = new Observer(2000);
	o.addCallback(new ObserverCallback() {
		@Override
		public void onTime(String textTime) {
			LogUtils.debug(tag, "111 textTime: " + textTime);
		}
	});
	o.addCallback(new ObserverCallback() {
		@Override
		public void onTime(String textTime) {
			LogUtils.debug(tag, "222 textTime: " + textTime);
		}
	});
	o.initEvent();
	try {
		Thread.sleep(10000);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	LogUtils.debug(TAG, "testDemo finish.");
}

输出结果：

D/testObserver  111 textTime: 2019-03-16 15:11:06
D/testObserver  222 textTime: 2019-03-16 15:11:06
D/testObserver  111 textTime: 2019-03-16 15:11:08
D/testObserver  222 textTime: 2019-03-16 15:11:08
D/testObserver  111 textTime: 2019-03-16 15:11:10
D/testObserver  222 textTime: 2019-03-16 15:11:10
D/testObserver  111 textTime: 2019-03-16 15:11:12
D/testObserver  222 textTime: 2019-03-16 15:11:12
D/testObserver  111 textTime: 2019-03-16 15:11:14
D/testObserver  222 textTime: 2019-03-16 15:11:14
D/ObserverTest  testDemo finish.

Process finished with exit code 0

上述代码虽然功能完善，但是存在一个问题，假如有观察对象注册了callback然后忘记注销，由于定时器一直持有该对象那么就会导致内存泄漏。

 

三、WeakReference加持

对于内存泄漏这个问题我们可以通过Java软引用来解决。

1. 首先用一个List来存储所有回调callback，该list用软引用WeakReference方式持有callback；

2. 用第二个List在存储强制类型的回调callback，该list直接持有callback；

3. 注册者在向定时器注册回调时可以设置注册引用类型，如果为强引用，那么步骤1、2的List都加入该对象；如果为软引用，那么只有步骤1的List会加入该对象。

4. 定时器触发事件时只需要遍历步骤1的Lit；

5. 注销某个注册者时需要遍历步骤1、2的callback，然后删除之。

package com.penny.javademo;

import java.lang.ref.WeakReference;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class ObserverWeakRef3 implements Runnable {
    private static final String TAG = ObserverWeakRef3.class.getSimpleName();

    private volatile boolean running = false;
    private long interval = 1000;
    private List<WeakReference<ObserverCallback>> callbacks = new CopyOnWriteArrayList<>();
    private List<ObserverCallback> strongList = new CopyOnWriteArrayList<>();

    public ObserverWeakRef3(long intervalMillsec) {
        if (interval < 1) {
            throw new IllegalArgumentException("interval must be larger than 0. interval: " + interval);
        }
        this.interval = intervalMillsec;
    }

    public void addCallback(ObserverCallback cb, boolean isWeakRef) {
        if (null == cb) {
            return;
        }

        synchronized (this) { // 防止异步线程同时find然后插入
            boolean find = false;
            for (WeakReference<ObserverCallback> ref : callbacks) {
                if (cb == ref.get()) {
                    find = true;
                    break;
                }
            }
            if (!find) {
                callbacks.add(new WeakReference<>(cb));
                if (!isWeakRef) {
                    strongList.add(cb);
                }
            }
        }
    }

    public void removeCallback(ObserverCallback cb) {
        synchronized (this) {
            boolean find = false;
            List<WeakReference<ObserverCallback>> delList = new ArrayList<>();
            ObserverCallback localCallback = null;
            for (WeakReference<ObserverCallback> ref : callbacks) {
                localCallback = ref.get();
                if (null == localCallback || cb == localCallback) {
                    delList.add(ref);
                }
                if (cb == localCallback) {
                    find = true;
                }
            }
            if (find) {
                strongList.remove(cb);
            }
            for (WeakReference<ObserverCallback> temp : delList) {
                callbacks.remove(temp);
            }
            delList.clear();
        }
    }

    public void initEvent() {
        synchronized (this) {
            if (! running) {
                new Thread(this).start();
            }
        }
    }

    public void terminate() {
        synchronized (this) {
            this.running = false;
        }
    }

    @Override
    public void run() {
        boolean localRun = running;
        synchronized (this) {
            this.running = true;
            localRun = running;
        }

        ObserverCallback localCallback;
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        while (localRun) {
            // 处理回掉事件
            for (WeakReference<ObserverCallback> cb : callbacks) {
                localCallback = cb.get();
                if (null != localCallback) {
                    localCallback.onTime(df.format(Calendar.getInstance().getTime()));
                } else {
                    LogUtils.debug(TAG, "localCallback: null");
                }
            }

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

            synchronized (this) {
                localRun = running;
            }
        }

        synchronized (this) {
            this.running = false;
        }
    }
}

测试代码:

@Test
public void testObserverWeakRef3() {
	final String tag = "testObserverWeakRef3";
	ObserverWeakRef2 o = new ObserverWeakRef2(2000);
	for (int i = 0; i < 10; i++) {
		final String text = String.format("%d%d%d", i, i, i);
		o.addCallback(new ObserverCallback() {
			byte[] buf = new byte[1024 * 1024 * 10]; // 增大空间,诱发虚拟机回收内存
			@Override
			public void onTime(String textTime) {
				LogUtils.debug(tag, text + " textTime: " + textTime);
			}
		}, i > 4);
	}
	o.initEvent();
	try {
		Thread.sleep(6000);
		System.gc(); // 手动触发gc，最终执行还是靠虚拟机的策略
		Thread.sleep(6000);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	LogUtils.debug(TAG, "testDemo finish.");
}

输出结果。

D/testObserverWeakRef3  000 textTime: 2019-03-16 15:36:55
D/testObserverWeakRef3  111 textTime: 2019-03-16 15:36:55
D/testObserverWeakRef3  222 textTime: 2019-03-16 15:36:55
D/testObserverWeakRef3  333 textTime: 2019-03-16 15:36:55
D/testObserverWeakRef3  444 textTime: 2019-03-16 15:36:55
D/testObserverWeakRef3  555 textTime: 2019-03-16 15:36:55
D/testObserverWeakRef3  666 textTime: 2019-03-16 15:36:55
D/testObserverWeakRef3  777 textTime: 2019-03-16 15:36:55
D/testObserverWeakRef3  888 textTime: 2019-03-16 15:36:55
D/testObserverWeakRef3  999 textTime: 2019-03-16 15:36:55
D/testObserverWeakRef3  000 textTime: 2019-03-16 15:36:57
D/testObserverWeakRef3  111 textTime: 2019-03-16 15:36:57
D/testObserverWeakRef3  222 textTime: 2019-03-16 15:36:57
D/testObserverWeakRef3  333 textTime: 2019-03-16 15:36:57
D/testObserverWeakRef3  444 textTime: 2019-03-16 15:36:57
D/testObserverWeakRef3  555 textTime: 2019-03-16 15:36:57
D/testObserverWeakRef3  666 textTime: 2019-03-16 15:36:57
D/testObserverWeakRef3  777 textTime: 2019-03-16 15:36:57
D/testObserverWeakRef3  888 textTime: 2019-03-16 15:36:57
D/testObserverWeakRef3  999 textTime: 2019-03-16 15:36:57
D/testObserverWeakRef3  000 textTime: 2019-03-16 15:36:59
D/testObserverWeakRef3  111 textTime: 2019-03-16 15:36:59
D/testObserverWeakRef3  222 textTime: 2019-03-16 15:36:59
D/testObserverWeakRef3  333 textTime: 2019-03-16 15:36:59
D/testObserverWeakRef3  444 textTime: 2019-03-16 15:36:59
D/testObserverWeakRef3  555 textTime: 2019-03-16 15:36:59
D/testObserverWeakRef3  666 textTime: 2019-03-16 15:36:59
D/testObserverWeakRef3  777 textTime: 2019-03-16 15:36:59
D/testObserverWeakRef3  888 textTime: 2019-03-16 15:36:59
D/testObserverWeakRef3  999 textTime: 2019-03-16 15:36:59
D/testObserverWeakRef3  000 textTime: 2019-03-16 15:37:01
D/testObserverWeakRef3  111 textTime: 2019-03-16 15:37:01
D/testObserverWeakRef3  222 textTime: 2019-03-16 15:37:01
D/testObserverWeakRef3  333 textTime: 2019-03-16 15:37:01
D/testObserverWeakRef3  444 textTime: 2019-03-16 15:37:01
D/ObserverWeakRef3  localCallback: null
D/ObserverWeakRef3  localCallback: null
D/ObserverWeakRef3  localCallback: null
D/ObserverWeakRef3  localCallback: null
D/testObserverWeakRef3  999 textTime: 2019-03-16 15:37:01
D/testObserverWeakRef3  000 textTime: 2019-03-16 15:37:03
D/testObserverWeakRef3  111 textTime: 2019-03-16 15:37:03
D/testObserverWeakRef3  222 textTime: 2019-03-16 15:37:03
D/testObserverWeakRef3  333 textTime: 2019-03-16 15:37:03
D/testObserverWeakRef3  444 textTime: 2019-03-16 15:37:03
D/ObserverWeakRef3  localCallback: null
D/ObserverWeakRef3  localCallback: null
D/ObserverWeakRef3  localCallback: null
D/ObserverWeakRef3  localCallback: null
D/testObserverWeakRef3  999 textTime: 2019-03-16 15:37:03
D/testObserverWeakRef3  000 textTime: 2019-03-16 15:37:05
D/testObserverWeakRef3  111 textTime: 2019-03-16 15:37:05
D/testObserverWeakRef3  222 textTime: 2019-03-16 15:37:05
D/testObserverWeakRef3  333 textTime: 2019-03-16 15:37:05
D/testObserverWeakRef3  444 textTime: 2019-03-16 15:37:05
D/ObserverWeakRef3  localCallback: null
D/ObserverWeakRef3  localCallback: null
D/ObserverWeakRef3  localCallback: null
D/ObserverWeakRef3  localCallback: null
D/testObserverWeakRef3  999 textTime: 2019-03-16 15:37:05
D/ObserverTest  testDemo finish.

Process finished with exit code 0

通过打印输出可以看到，通过WeakReference软引用的callback在 2019-03-16 15:37:01时就被系统回收了，因此找不到对应的callback。证明用软引用是有效的，可以避免内存泄漏；

 

四、总结

       当然，最重要的还是调用者本身要懂得对注册者的生命周期类型，如果把原本弱周期的注册者放到定时器是使用强引用方式注册，然后又不注销，那么也会导致内存泄漏。对于这种情况我只能说——我也很无奈啊！！！

 

二流小宝
关注
专栏目录
Java并发编程进阶——多线程的安全与同步
行者无疆的博客
03-14 638
多线程的安全与同步 多线程的操作原则 多线程 AVO 原则 A：即 Atomic，原子性操作原则。对基本数据类型变量的读和写是保证原子性的，要么都成功，要么都失败，这些操作不可中断。 V：即 volatile，可见性原则。使用 volatile 关键字，保证了变量的可见性，到主存拿数据，不是到缓存里拿。 O：即 order， 就是有序性。代码的执行顺序，在代码编译前的和代码编译后的执行顺序不变。 单 CPU 时代的多线程 概念：单核 CPU 上，同一时刻只能有一条线程运行，单核 CPU 上运行的单线程程序和
Java学习笔记：进阶语法
坤舆湖畔的万某某的博客
08-03 1747
对于Java的对象内存管理、Debug调试，API文档，String类、正则表达式、Object类常用方法、包装类、file类、FileFilter文件过滤器、RandomAccessfile类、JavaIO（各种流）、异常处理机制进行了相对细致的解释与演示！
Java中关于内存泄漏出现的原因汇总及如何避免内存泄漏（超详细版）
09-01
主要介绍了Java中关于内存泄漏出现的原因汇总及如何避免内存泄漏（超详细版）的相关资料,需要的朋友可以参考下
java final 内存泄漏_干货详解：一文教你如何避免内部类中的内存泄漏
weixin_33636371的博客
02-16 419
我先假设读者已经熟悉在Java代码中使用嵌套类的基础知识。在本文里，我将展示嵌套类的陷阱，内部类在JVM中引起内存泄漏和内存不足错误的地方。之所以会发生这种类型的内存泄漏，是因为内部类必须始终能够访问其外部类。从简单的嵌套过程到内存不足错误(并可能关闭JVM)是一个过程。我们一步步看他是如何产生的。步骤1：内部类引用其外部类内部类的任何实例都包含对其外部类的隐式引用。例如，考虑以下带有嵌套的Enc...
java程序内存泄漏场景及预防
weixin_34209851的博客
01-27 256
为什么80%的码农都做不了架构师？>>> ...
在Android开发中巧妙使用观察者模式避免内存泄露
ithouse的专栏
07-19 1261
发生内存泄露的场景： 场景1：静态变量引用Activity对象 场景2：静态View 场景3：内部类和匿名类 场景4：Handler 场景5：Threads和TimerTask 场景6：监听器 场景7：静态集合对象引起的泄漏 场景8：资源对象未关闭 场景9：使用对象池避免频繁创建对象 场景10：Back键退出引起的泄漏 现在有这么一个场景（场景3|场景6）：在Activit
MVP设计模式减少内存泄漏
ZkMao1007的博客
01-18 488
//写在Present类中 自定义方法名 public void onBindDestory(){ if(loginView!=null){ loginView=null; } }写在 view层类中private Presenter presenter;@Overrideprotected void onDestroy() { super.onDest
115个Java面试题和答案——终极（下）(1).rar
07-16
- **常用设计模式**：单例、工厂、观察者、装饰者、代理、适配器、策略、模板等23种设计模式。 以上就是文档中可能涉及的一些Java面试知识点，理解并熟练掌握这些内容将有助于你在面试中展现出扎实的Java基础和...
115个Java面试题和答案——终极列表(下)-word版本
11-06
5. **内存管理**：Java的垃圾收集机制（GC）是自动进行的，但面试可能会涉及内存泄漏、对象生命周期、强、软、弱、虚引用的区别等。 6. **多线程**：Java提供了丰富的多线程支持，如Thread类、Runnable接口、...
Android 性能优化之内存泄漏的检测与修复
clevergump的专栏
07-24 6974
转载请注明本文出自 clevergump 的博客：http://blog.csdn.net/clevergump/article/details/52013873, 谢谢!在 Android 开发中, 内存优化是APP性能优化中很重要的一个部分. 而在内存优化中, 最重要的就是修复内存泄漏问题. 本文就来介绍一下内存泄漏的基本概念以及常用的检测手段.1. 什么是内存泄漏简单来说, 当一个对象不再被使
java防止内存泄露_如何防止java中的内存泄漏
weixin_30821881的博客
02-16 1007
展开全部尽管java虚拟机和垃圾回收机制治理着大部分62616964757a686964616fe4b893e5b19e31333335313838的内存事务，但是在java软件中还是可能存在内存泄漏的情况。的确，在大型工程中，内存泄漏是一个普遍问题。避免内存泄漏的第一步，就是要了解他们发生的原因。这篇文章就是要介绍一些常见的缺陷，然后提供一些非常好的实践例子来指导你写出没有内存泄漏的代码。一旦你...
Java内存泄露及避免方法
fh09102103的专栏
04-25 494
内存泄露原因：              内存管理一直是Java 所鼓吹的强大优点。开发者只需要简单地创建对象,而Java的垃圾收集器将会自动管理内存空间的分配和释放.但在很多情况下,事情并不那么简单,在 Java程序中总是会频繁地发生内存泄露(Memory Leaks). 内存泄露是什么? 内存泄露的定义: 当某些对象不再被应用程序所使用,但是由于仍然被引用而导致垃圾收集器不能释放(Rem
Java：Java中内存泄漏的原因以及如何避免它们
yueqian_edu的博客
06-21 443
内存泄漏是没有使用对象的情况，但是垃圾收集器无法将它们从内存中删除，因为它们仍然被引用。如果你是程序员，那么Java中的内存泄漏对你不利，因为它阻塞了内存资源并随着时间的推移降低系统性能。如果不处理，系统会显示 java.lang.OutOfMemoryError 错误。...
Java内存体系结构（模型），垃圾回收和内存泄漏
最佳 Java 编程
05-31 294
Java内存架构（Java内存模型） 上面是堆的Java内存模型以及Java虚拟机（JVM）中运行的任何Java应用程序的PermGen。 还提供了比率，以使您更好地了解如何在每种世代类型之间分配允许的内存。 以上所有内容完全适用于Java 1.7版（含）。 上面也称为内存模型的“管理区域”。 除上述内容外，还有一个堆栈区域，可以使用-Xss选项进行配置。 该区域保存堆上的引用...
观察者模式
weixin_33697898的博客
07-30 81
观察者模式： 观察者模式定义了一种一对多的依赖关系，当一个对象改变状态时，它的所有依赖者都会受到通知，并自动更新。 注意：观察者模式会造成内存泄漏，一定要记得取消订阅 UML关系图如下： UML 观察者模式提供了一种对象设计，让主题和观察者之间松耦合。 观察者与主题之间依赖于接口，主题不需要知道观察者的具体实现 可以...
2020校招备战日记4.22 ---- 二叉树遍历，适配器模式，模板方法模式，组合模式，观察者模式，原型模式，进程虚拟内存，内存管理
ustc_sse_shenzhang的博客
04-23 241
文章目录0.目标完成情况1. 白天所学回顾1.1 LeetCode题目1.2 五种设计模式1.3 进程虚拟内存虚拟内存的作用地址翻译的过程（不命中）1.4 Linux虚拟内存2. 自己的感悟3. 明日目标 0.目标完成情况 LeetCode两道题 虚拟内存剩下的部分两天内看完。 侯捷C++一定要看一节。 可以再看一点Linux扫盲课程。 严格遵循时间表来作息。 今天的工作量还是挺多...
CopyOnWriteArrayList内存占用过多
最新发布
m0_53914150的博客
12-09 414
CopyOnWrite，顾名思义就是写的时候会将共享变量新复制一份出来，这样做的好处是读操作完全无锁。 CopyOnWriteArrayList的add()方法 publicbooleanadd(Ee){ //获取独占锁 finalReentrantLocklock=this.lock; lock.lock(); try{ //获取array Object[]elements=getArray();
【Java并发编程】并发容器之CopyOnWriteArrayList
05-15 931
问题是什么？ArrayList 在使用iterator的时候会遇到ConcurrentModificationException的异常，就是由于遍历的时候，又进行写操作。 解决办法就是:可以通过同步锁来限制它们同时发生。自己加锁有些麻烦，有现成的方案吗？CopyOnWriteArrayList来看看其add方法：public synchronized boolean add(E e) {
java:多线程观察者模式
qq_45299533的博客
04-11 469
一、普通观察者模式 观察者模式：一般分为Subject(主题即目标对象,一旦发生改变要发出通知)，observer(观察者一旦目标发生改变,自动触发回调方法) /** * 观察者模式：目标对象 * */ @Getter public class Subject { //定义观测者集合，存需要通知对象 private List<Observer> observers = new ArrayList<>(); private int state; /
Java内存泄漏详解与避免策略
"Java内存泄漏的原因与避免方法详解" 在Java编程中，内存泄漏是一个重要的问题，它会导致程序性能下降，甚至可能导致程序崩溃。本文将深入探讨Java内存泄漏的成因，提供避免内存泄漏的策略，并对Java内存分配机制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值