C/C++编程：为什么要引入Observer

￡神魔★判官ぃ 2022-10-07 13:51 119阅读 0赞

一个动态创建的对象是否还活着，光看指针是看不出来的(引用也看不出来)。指针就是指向了一块内存，这块内存上的对象如果已经销毁，那么久不能访问，既然不能访问又如何知道对象的状态呢？换句话说，判断一个指针是不是合法指针没有高效的方法，这时C/C++指针问题的根源(在Java中，一个引用只要不为NULL，它就一定指向有效的对象)(可能原址又创建了一个新的对象)

在面向对象的设计中，对象的关系主要有三种：composition、aggregation、association。composition(组合)关系在多线程里不会遇到什么麻烦，因为对象x的生命周期由其唯一的拥有者owner控制，owner析构的时候会把x也析构调。从形式上，x是owner的直接数据成员，或者scoped\_ptr成员，或者owner持有的容器的元素

后两者关系在C++里比较难办？处理不好就会造成内存泄露或者重复释放。association(关联)是一种很宽泛的关系，它表示一个对象a用到了另一个对象b，调用了后者的成员函数。从代码形式上看，a持有b的指针(或者引用)，但是b的生命周期不由a单独控制。 aggregation(聚合)关系从形式上看与association相同，除了a和b由逻辑上的整体和部分关系。如果b是动态创建创建的并在整个程序结束前有可能被释放，那么久会出现[这里][Link 1]提到的竞态条件

那么似乎一个简单的解决方法是：只创建不销毁。程序使用一个对象池来暂存用过的对象，下次申请新对象时，如果对象池里有存货，就重复利用现有对象，否则就创建一个。对象用完了，不是直接释放调，而是放回池子里。这个方法当然有其自身的很多缺点，但至少能够避免访问失效对象的情况发生。

这种办法的问题有：

*  对象池的线程安全，如果安全的、完整的把对象放回池子里，防止出现“部分放回”的竞态？(线程A认为对象x已经放回了，线程B认为对象还活着)
 *  全局共享数据引发的lock contention，这个集中化的对象池会不会把多线程并发的操作串行化
 *  如果共享对象的类型不止一种，那么是重复实现对象池还是使用类模板？
 *  会不会造成内存泄露与分片？因为对象池占用的内存只增不减，而且多个对象池不能共享内存。 【？？？】

> 锁竞争(Lock Contention)：是指大量的线程在同一个锁上发生竞争。

> association是用于一对一和多对一，而collection是用于一对多的关系
> 
>  *  人和身份证是一对一关联关系
>  *  学生与班级是多对一的关系
>  *  班级和学生是一对多聚合关系
> 
>     public class Student implements Serializable {
>          
>     private Integer id;
>     private String name;
>     private String sex;
>     private Integer age;
>            //学生与班级是多对一的关系
>     private Clazz clazz;
>     //省略set/get方法
>     }
> 
>     public class Clazz implements Serializable{
>          
>     private Integer id;
>     private String code;
>     private String name;
>            //班级与学生是一对多的关系
>     private List<Student> students;
> 
>     public class Person{
>          
>     private Integer id;
>     private String name;
>     private String sex;
>     private Integer age;
>     //人和身份证是一对一的关系
>     private Card card;

回到正题上来，如果对象x注册了任何非静态成员函数回调，那么必然在某处持有了指向x的指针，这就暴露在了race condition之下

一个典型的场景是Observer模式  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]  
当Observable通知每一个Observer模式  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]  
当Observable通知每一个Observer时（ζ17），它从何得知Observer对象x还活着？要不要试试在Observer的析构函数里调用unregister()？空难有效。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 2]  
我们试着让Observer的析构函数去调用unregister(this)，这里有两个race conditions。其一：ζ32如何得知subject\_还活着？其二：就算subject\_指向某个永远存在的对象，那么还是有问题：

*  线程A执行到ζ32之前，还没有来得及unregister本对象
 *  线程B执行到ζ17，x正好指向的是ζ32正在析构的对象

这时就出现了问题，既然x所指的Observer对象正在析构，调用它的任何非静态成员函数都是不安全的。更糟的是，Observer是个基类，执行到ζ32时，派生类对象已经析构调了，这时候整个对象出于将死未死的状态，core dump恐怕是最好的结果

这些race condition似乎可以通过加锁来解决，但在哪里加锁，谁持有这些互斥锁，又不是那么显而易见的。要是有什么活的对象能帮帮我们就好了，它提供一个isAlive()之类的程序函数，告诉我们那个对象还在不在。可惜引用和指针都不是对象，它们是内建类型

[Link 1]: https://blog.csdn.net/zhizhengguan/article/details/118019284
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: /images/20221005/da92088aedb34c409a5432821a66c72e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]: /images/20221005/0f3f9f199e76421aa2b0b1d28d386072.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 2]: /images/20221005/0945a96510834b0fa791b61e795f2a58.png