2. 程式人生 > >解決RxJava記憶體洩漏（前篇）：RxLifecycle詳解及原理分析

解決RxJava記憶體洩漏（前篇）：RxLifecycle詳解及原理分析

阿新 • • 發佈：2019-02-08

隨著RxJava及RxAndroid的逐漸推廣，使用者越來越多，但是有一個問題，RxJava的使用不當極有可能會導致記憶體洩漏。

比如，使用RxJava釋出一個訂閱後，當Activity被finish，此時訂閱邏輯還未完成，如果沒有及時取消訂閱，就會導致Activity無法被回收，從而引發記憶體洩漏。

目前網上對RxJava的記憶體洩漏有幾種方案：

1、通過封裝，手動為RxJava的每一次訂閱進行控制，在指定的時機進行取消訂閱； 
2、使用 Daniel Lew 的 RxLifecycle ，通過監聽Activity、Fragment的生命週期，來自動斷開subscription以防止記憶體洩漏。

筆者上述兩種方式都使用過，RxLifecycle

顯然對於第一種方式，更簡單直接，並且能夠在Activity/Fragment容器的指定生命週期取消訂閱，實在是好用。

依賴並使用RxLifecycle

1、新增依賴

首先在build.gradle檔案中新增依賴：

compile 'com.trello.rxlifecycle2:rxlifecycle:2.2.1'
compile 'com.trello.rxlifecycle2:rxlifecycle-android:2.2.1'
compile 'com.trello.rxlifecycle2:rxlifecycle-components:2.2.1'
  • 1
  • 2
  • 3

2、配置Activity/Fragment容器

Activity/Fragment需繼承RxAppCompatActivity/RxFragment，目前支援的有如下：

RxLifecycle支援的Component

程式碼如下：

//只需要繼承即可
public class MainActivity extends RxAppCompatActivity {
      ...
      ...
}
  • 1
  • 2
  • 3
  • 4
  • 5

3、使用compose操作符繫結容器生命週期

有兩種方式：

3.1 使用bindToLifecycle()

以Activity為例，在Activity中使用bindToLifecycle()方法，完成Observable釋出的事件和當前的元件繫結，實現生命週期同步。從而實現當前元件生命週期結束時，自動取消對Observable訂閱，程式碼如下：

public class MainActivity extends RxAppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 當執行onDestory()時， 自動解除訂閱
        Observable.interval(1, TimeUnit.SECONDS)
            .doOnDispose(new Action() {
                @Override
                public void run() throws Exception {
                    Log.i(TAG, "Unsubscribing subscription from onCreate()");
                }
            })
            .compose(this.<Long>bindToLifecycle())
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long num) throws Exception {
                    Log.i(TAG, "Started in onCreate(), running until onDestory(): " + num);
                }
            });
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

3.2 使用bindUntilEvent()

使用ActivityEvent類，其中的CREATE、START、 RESUME、PAUSE、STOP、 DESTROY分別對應生命週期內的方法。使用bindUntilEvent指定在哪個生命週期方法呼叫時取消訂閱：

public class MainActivity extends RxAppCompatActivity {
    @Override
    protected void onResume() {
        super.onResume();
        Observable.interval(1, TimeUnit.SECONDS)
            .doOnDispose(new Action() {
                @Override
                public void run() throws Exception {
                    Log.i(TAG, "Unsubscribing subscription from onResume()");
                }
            })
              //bindUntilEvent()，內部傳入指定生命週期引數
            .compose(this.<Long>bindUntilEvent(ActivityEvent.DESTROY))
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long num) throws Exception {
                    Log.i(TAG, "Started in onResume(), running until in onDestroy(): " + num);
                }
            });
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

以上，僅僅需要三步：依賴、繼承、compose操作符，即可完成在容器的指定生命週期內，RxJava的自動取消訂閱。

原理分析

RxLifecycle的原理可以說非常簡單。

我們直接看一下這行程式碼的內部原理：

Observable.compose(this.bindToLifecycle())

1、RxAppCompatActivity

public abstract class RxAppCompatActivity extends AppCompatActivity implements LifecycleProvider<ActivityEvent> {

    //1.實際上RxAppCompatActivity內部儲存了一個BehaviorSubject
    private final BehaviorSubject<ActivityEvent> lifecycleSubject = BehaviorSubject.create();

    public final Observable<ActivityEvent> lifecycle() {
        return lifecycleSubject.hide();
    }

    public final <T> LifecycleTransformer<T> bindUntilEvent(@NonNull ActivityEvent event) {
        return RxLifecycle.bindUntilEvent(lifecycleSubject, event);
    }

    //2.實際上返回了一個LifecycleTransformer
    public final <T> LifecycleTransformer<T> bindToLifecycle() {
        return RxLifecycleAndroid.bindActivity(lifecycleSubject);
    }

    //3.Activity不同的生命週期，BehaviorSubject物件會發射對應的ActivityEvent
    @Override
    @CallSuper
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        lifecycleSubject.onNext(ActivityEvent.CREATE);
    }

    @Override
    @CallSuper
    protected void onStart() {
        super.onStart();
        lifecycleSubject.onNext(ActivityEvent.START);
    }

    @Override
    @CallSuper
    protected void onResume() {
        super.onResume();
        lifecycleSubject.onNext(ActivityEvent.RESUME);
    }

    @Override
    @CallSuper
    protected void onPause() {
        lifecycleSubject.onNext(ActivityEvent.PAUSE);
        super.onPause();
    }

    @Override
    @CallSuper
    protected void onStop() {
        lifecycleSubject.onNext(ActivityEvent.STOP);
        super.onStop();
    }

    @Override
    @CallSuper
    protected void onDestroy() {
        lifecycleSubject.onNext(ActivityEvent.DESTROY);
        super.onDestroy();
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62

我們繼承的RxAppCompatActivity，其內部實際上儲存了一個BehaviorSubject，關於BehaviorSubject，實際上也還是一個Observable，不瞭解的朋友可以閱讀筆者的前一篇文章,本文不再贅述：

這個BehaviorSubject會在不同的生命週期發射不同的ActivityEvent，比如在onCreate()生命週期發射ActivityEvent.CREATE，在onStop()發射ActivityEvent.STOP。

在2中，我們可以看到，bindToLifecycle()方法實際返回了一個LifecycleTransformer，那麼這個LifecycleTransformer是什麼呢？

2、LifecycleTransformer

public final class LifecycleTransformer<T> implements ObservableTransformer<T, T>,
                                                      FlowableTransformer<T, T>,
                                                      SingleTransformer<T, T>,
                                                      MaybeTransformer<T, T>,
                                                      CompletableTransformer
{
    final Observable<?> observable;

    LifecycleTransformer(Observable<?> observable) {
        checkNotNull(observable, "observable == null");
        this.observable = observable;
    }

    @Override
    public ObservableSource<T> apply(Observable<T> upstream) {
        return upstream.takeUntil(observable);
    }
    //隱藏其餘程式碼，這裡只以Observable為例
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

熟悉Transformer的同學都應該能看懂，LifecycleTransformer實際是實現了不同響應式資料類（Observable、Flowable等）的Transformer介面。

以Observable為例，實際上就是通過傳入一個Observable序列並存儲為成員，然後作為引數給上游的資料來源執行takeUntil方法。

takeUntil操作符

takeUntil操作符:當第二個Observable發射了一項資料或者終止時，丟棄原Observable發射的任何資料。

takeUntil操作符

回顧

 Observable.interval(1, TimeUnit.SECONDS)
            .doOnDispose(new Action() {
                @Override
                public void run() throws Exception {
                    Log.i(TAG, "Unsubscribing subscription from onCreate()");
                }
            })
            .compose(this.<Long>bindToLifecycle())
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long num) throws Exception {
                    Log.i(TAG, "Started in onCreate(), running until onDestory(): " + num);
                }
            });
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

現在回頭來看這段程式碼，就很好理解了，Activity.bindToLifecycle()實際上就是指定上游的資料來源，當接收到某個Observable（就是LifecycleTransformer中那個神祕的成員變數）的某個事件時，該資料來源自動解除訂閱。

老師，原理已經搞清楚了，我還有最後一個問題：

神祕人是誰？

回到RxAppCompatActivity中來，我們來看bindToLifecycle()方法：

public abstract class RxAppCompatActivity extends AppCompatActivity implements LifecycleProvider<ActivityEvent> {

    private final BehaviorSubject<ActivityEvent> lifecycleSubject = BehaviorSubject.create();

    public final <T> LifecycleTransformer<T> bindToLifecycle() {
        //執行了這行程式碼，返回了LifecycleTransformer
        return RxLifecycleAndroid.bindActivity(lifecycleSubject);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

不難猜測，實際上，那個神祕人，就是我們RxAppCompatActivity 中的BehaviorSubject成員變數（它本身就是一個Observable）！

我們點進去看看：

    //1.執行了 bind(lifecycle, ACTIVITY_LIFECYCLE);
    public static <T> LifecycleTransformer<T> bindActivity(@NonNull final Observable<ActivityEvent> lifecycle) {
        return bind(lifecycle, ACTIVITY_LIFECYCLE);
    }

    //2.執行了bind(takeUntilCorrespondingEvent(lifecycle.share(), correspondingEvents))
    public static <T, R> LifecycleTransformer<T> bind(@Nonnull Observable<R> lifecycle,
                                                      @Nonnull final Function<R, R> correspondingEvents) {
        return bind(takeUntilCorrespondingEvent(lifecycle.share(), correspondingEvents));
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
    //3.最終抵達這裡，這個方法執行了什麼呢？
    private static <R> Observable<Boolean> takeUntilCorrespondingEvent(final Observable<R> lifecycle,
                                                                       final Function<R, R> correspondingEvents) {
        return Observable.combineLatest(
            lifecycle.take(1).map(correspondingEvents),
            lifecycle.skip(1),
            new BiFunction<R, R, Boolean>() {
                @Override
                public Boolean apply(R bindUntilEvent, R lifecycleEvent) throws Exception {
                    return lifecycleEvent.equals(bindUntilEvent);
                }
            })
            .onErrorReturn(Functions.RESUME_FUNCTION)
            .filter(Functions.SHOULD_COMPLETE);
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

最後我們走到了3，我們一行一行分析：

Observable.combineLatest

這行程式碼實際上是將lifecycle（就是我們傳進來的BehaviorSubject）的事件進行了一次分割：

lifecycle.take(1)指的是最近發射的事件，比如說我們在onCreate()中執行了bindToLifecycle，那麼lifecycle.take(1)指的就是ActivityEvent.CREATE，經過map(correspondingEvents)，這個map中傳的函式就是 1中的ACTIVITY_LIFECYCLE：

private static final Function<ActivityEvent, ActivityEvent> ACTIVITY_LIFECYCLE =
        new Function<ActivityEvent, ActivityEvent>() {
            @Override
            public ActivityEvent apply(ActivityEvent lastEvent) throws Exception {
                switch (lastEvent) {
                    case CREATE:
                        return ActivityEvent.DESTROY;
                    case START:
                        return ActivityEvent.STOP;
                    case RESUME:
                        return ActivityEvent.PAUSE;
                    case PAUSE:
                        return ActivityEvent.STOP;
                    case STOP:
                        return ActivityEvent.DESTROY;
                    case DESTROY:
                        throw new OutsideLifecycleException("Cannot bind to Activity lifecycle when outside of it.");
                    default:
                        throw new UnsupportedOperationException("Binding to " + lastEvent + " not yet implemented");
                }
            }
        };
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

也就是說，lifecycle.take(1).map(correspondingEvents)實際上是返回了 CREATE 對應的事件 DESTROY ,它意味著本次訂閱將在Activity的onDestory進行取消。

lifecycle.skip(1)就簡單了，除去第一個保留剩下的，以ActivityEvent.Create為例，這裡就剩下：

ActivityEvent.START 
ActivityEvent.RESUME 
ActivityEvent.PAUSE 
ActivityEvent.STOP 
ActivityEvent.DESTROY

第三個引數 意味著，lifecycle.take(1).map(correspondingEvents)的序列和 lifecycle.skip(1)進行combine，形成一個新的序列：

false,false,fasle,false,true

這意味著，當Activity走到onStart生命週期時，為false,這次訂閱不會取消，直到onDestroy，為true，訂閱取消。

而後的onErrorReturn和filter是對異常的處理和判斷是否應該結束訂閱：

    //異常處理
    static final Function<Throwable, Boolean> RESUME_FUNCTION = new Function<Throwable, Boolean>() {
        @Override
        public Boolean apply(Throwable throwable) throws Exception {
            if (throwable instanceof OutsideLifecycleException) {
                return true;
            }
            Exceptions.propagate(throwable);
            return false;
        }
    };
    //是否應該取消訂閱，可以看到，這依賴於上游的boolean
    static final Predicate<Boolean> SHOULD_COMPLETE = new Predicate<Boolean>() {
        @Override
        public boolean test(Boolean shouldComplete) throws Exception {
            return shouldComplete;
        }
    };
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

bind生成LifecycleTransformer

看懂了3，我們回到2，我們生成了一個Observable，然後通過bind(Observable)方法，生成LifecycleTransformer並返回：

    public static <T, R> LifecycleTransformer<T> bind(@Nonnull final Observable<R> lifecycle) {
        return new LifecycleTransformer<>(lifecycle);
    }
  • 1
  • 2
  • 3

神祕人的神祕面紗就此揭開。

總結

RxLifecycle並不難以理解，相反，它的設計思路很簡單：

1.在Activity中，定義一個Observable（Subject），在不同的生命週期發射不同的事件； 
2.通過compose操作符（內部實際上還是依賴takeUntil操作符），定義了上游資料，當其接收到Subject的特定事件時，取消訂閱； 
3.Subject的特定事件並非是ActivityEvent，而是簡單的boolean，它已經內部通過combineLast操作符進行了對應的轉化。

實際上，Subject和ActivityEvent對RxLifecycle的使用者來講，是對應隱藏的。我們只需要呼叫它提供給我們的API,而內部的實現者我們無需考慮，但是也只有去閱讀和理解了它的思想，我們才能更好的選擇使用這個庫。

轉折：AutoDispose

作為RxLifecycle的作者，Daniel Lew客觀陳述了使用RxLifecycle在開發時所遇到的窘境。並且為我們提供了一個他認為更優秀的設計：

我花了一些時間研究了一下AutoDispose，不得不承認，AutoDispose相比較RxLifecycle，前者更加健壯，並且擁有更優秀的拓展性，如果我的專案需要一個處理RxJava自動取消訂閱的庫，也許AutoDispose更為適合。

更讓我感到驚喜的是，AutoDispose的設計思想，有很大一部分和RxLifecycle相似，而且我在其文件上，看到了Uber的工程師對於Daniel Lew 所維護的 RxLifecycle 感謝，也感謝Daniel Lew 對於 AutoDispose的很大貢獻：

以下摘錄於AutoDispose的官方文件：

Special thanks go to Dan Lew (creator of RxLifecycle), who helped pioneer this area for RxJava in android and humored many of the discussions around lifecycle handling over the past couple years that we’ve learned from. Much of the internal scope resolution mechanics of 
AutoDispose are inspired by RxLifecycle.

在我嘗試將AutoDispose應用在專案中時，我發現國內對於這個庫所應用的不多，我更希望有更多朋友能夠和我一起使用這個庫，於是我準備寫一篇關於AutoDispose使用方式的文章。

但在這之前，我還是希望能夠先將RxLifecycle的個人心得分享給大家，原因有二：

一是RxLifecycle更簡單，原理也更好理解，學習一個庫不僅僅是為了會使用它，我們更希望能夠從原始碼中學習到作者優秀的設計和思想。因此，如果是從未接觸過這兩個庫的開發者，直接入手AutoDispose，在我看來不如先入手RxLifecycle。

二是AutoDispose的很大一部分設計核心源於RxLifecycle，理解了RxLifecycle，更有利於AutoDispose的學習。

接下來我將會嘗試向大家闡述AutoDispose的使用及其內部原理，和RxLifecycle不同，我們不再需要去繼承RxActivity/RxFragment，而是內部依賴使用了google不久前推出的架構元件 Lifecycle（事實上這也是我青睞AutoDispose的原因之一，儘量避免繼承可以給程式碼更多選擇的餘地）。

2018-3-1追加更新

填坑後歸來：

相關推薦

解決RxJava記憶體洩漏（前篇）：RxLifecycle詳解及原理分析

隨著RxJava及RxAndroid的逐漸推廣，使用者越來越多，但是有一個問題，RxJava的使用不當極有可能會導致記憶體洩漏。比如，使用RxJava釋出一個訂閱後，當Activity被finish，此時訂閱邏輯還未完成，如果沒有及時取消訂閱，就會導致Activity無法被回

Dubbo（概念篇）：Dubbo 詳解，架構演變及優缺點

架構演變 單一應用框架(ORM) 當網站流量很小時，只需一個應用，將所有功能如下單支付等都部署在一起，以減少部署節點和成本。 缺點：單一的系統架構，使得在開發過程中，佔用的資源越來越多，而且隨著流量的增加越來越難以維護。 垂直應用框架(MVC) 垂直應用架構解決了單一應用架

文本分類需要CNN？No！fastText完美解決你的需求（前篇）

來講 text 關聯性 watermark 似的 review 自然 bag 進入 http://blog.csdn.net/weixin_36604953/article/details/78195462?locationNum=8&fps=1 文本分類需要CNN

文字分類需要CNN？ No！fastText完美解決你的需求（前篇）

文字分類需要CNN？No！fastText完美解決你的需求（前篇） fastText是個啥？簡單一點說，就是一種可以得到和深度學習結果準確率相同，但是速度快出幾個世紀的文字分類演算法。這個演算法類似與CBOW，可愛的讀著是不是要問CBOW又是個什麼鬼？莫急，聽

Struts2（Interceptor篇）：攔截器的實現原理以及程式碼示例

目錄 Interceptor 簡介 理解 Interceptor 概念 理解 Interceptor 原理 建立 Interceptor 監聽器 在pom.xml加入相關依賴 自定義 Interceptor 自定義一個實現了Interceptor介面的類，或者繼承抽象

Docker筆記（十一）：Dockerfile詳解與最佳實踐

Dockerfile是一個文字檔案，包含了一條條指令，每條指令對應構建一層映象，Docker基於它來構建一個完整映象。本文介紹Dockerfile的常用指令及相應的最佳實踐建議。 1. 理解構建上下文（build context） Docker映象通過docker build指令構建，該指令執行時當前的工作目

文本分類需要CNN？No！fastText完美解決你的需求（後篇）

一段 soft 因此 6.0 大數 知識 huffman編碼 過多 常數 http://blog.csdn.net/weixin_36604953/article/details/78324834 想必通過前一篇的介紹，各位小主已經對word2vec以及CBOW和Skip-

專案二：Kaggle房價預測（前篇）

概述 Kaggle房價預測比賽(高階技能篇) notebook的背景是kaggle房價預測比賽高階迴歸技能篇 背景搬運如下： 這個notebook主要是通過資料探索和資料視覺化來實現。 我們把這個過程叫做EDA（(Exploratory Data Analysi

第三章：CSS樣式（前篇）

文章目錄 前言 第一節：層疊式樣式表 ==什麼是層疊式樣式表== ==樣式編寫位置== ==CSS 盒子模型(Box Model)== 標準盒子模型 盒子的屬性和

MY-SQL-----資料庫（前篇）

資料庫 操作資料庫 建立資料庫：crate database 資料庫名稱 丟棄資料庫：drop database 資料庫名稱 顯示資料庫：show databases 使用資料庫：use 資料庫名稱 操作表 建立表：create table 表名稱(列名 列資料型別

Android應用程式程序啟動過程（前篇）

前言 在此前我講過Android系統的啟動流程，系統啟動後，我們就比較關心應用程式是如何啟動的，這一篇我們來一起學習Android7.0 應用程式程序啟動過程，需要注意的是“應用程式程序啟動過程”，而不是應用程式啟動過程。關於應用程式啟動過程，我會在後

OpenCV霍夫變換系列（前篇）-經典霍夫線變換

前言：最近新來的的我的大學室友（現在也是我的學弟）在研究霍夫線變換，我之前只是知道這玩意可以拿來做直線檢測，並沒有深入研究，那既然提到了，還是按照我們的老規矩，原理，示例以及OpenCV這一套流程走下來。 菜鳥一枚，好多寫的不好，有點囉嗦，見諒 主要參考部落格：

前端開發----微信小程式入門級教程（前篇）

前言 前段時間，憑藉著出生牛犢不怕虎的勁頭，憑藉著一點Java基礎和前端入門的知識水平，買了域名和伺服器準備搭建自己的一個技術站點，初衷是旨在打造自己成為一個T形全站工程師。後經過各種百度，各種折騰終於大概在半個月左右的時間寫好了幾個基本介面，能上傳圖片，釋出

Android架構中新增AutoDispose解決RxJava記憶體洩漏

概述 如何通過使用 RxLifecycle 解決Android開發中RxJava的可能會導致的記憶體洩漏問題； 在文章的最後，我提到了 AutoDispose 這個庫，這個庫同樣可以解決Android生命週期元件導致的RxJava的記憶體洩漏情況。

Guru of the Week 條款09：記憶體管理（上篇）

  GotW #09 Memory Management - Part I 著者：Herb Sutter 翻譯：kingofark [宣告]：本文內容取自www.gotw.ca網站上的Guru of the Week欄目，其著作權歸原著者本人所有。譯者kingofark在未經

HTML常用標籤大全（前篇）

1.HTML簡介 什麼是HTML? HTML 是用來描述網頁的一種語言。 HTML 指的是超文字標記語言: HyperText Markup Language HTML 不是一種程式語言，而是一種標記語言 標記語言是一套標記標籤 (markup tag

OpenCV背景虛化（前篇）

最近剛接到這個東西，心想不是太難，前後做了幾種方案。 首先想到的方案一： 摳圖得到影象的前景區域，對背景使用高斯模糊，然後將原圖前景區域疊加到第二步得到的圖層對應區域。 第一步摳圖我使用的是圖割演算法，因為手上有現成的程式，當然還有其他許多摳圖演算法，

android 記憶體優化 （圖片篇）一

記憶體簡介： RAM（random access memory）隨機存取儲存器。說白了就是記憶體。 一般Java在記憶體分配時會涉及到以下區域： 暫存器（Registers）：速度最快的儲存場所，因為暫存器位於處理器內部，我們在程式中無法控制 棧（Stack）：存放基本

RxLifecycle解決RxJava記憶體洩漏

1.RxJava導致記憶體洩漏 使用RxJava釋出一個訂閱後，當頁面被finish，此時訂閱邏輯還未完成，如果沒有及時取消訂閱，就會導致Activity/Fragment無法被回收，從而引發記憶體洩漏。 寫段程式碼測試一下，定義一個Activity，佈局中顯示一張圖片，

漫談併發程式設計：用MPI進行分散式記憶體程式設計（入門篇）

0x00 前言 本篇是MPI的入門教程，主要是為了簡單地瞭解MPI的設計和基本用法，方便和現在的Hadoop、Spark做對比，並嘗試理解它們之間在設計上有什麼區別。 身處Hadoop、Spark這些優秀的分散式開發框架蓬勃發展的今天，老的分散式程式