Loading...
Loading...
Loading...
Loading...

A Pattern to Simplify Multiple Async Waiting for Android

View: 192    Dowload: 0   Comment: 0   Post by: admin   Category: Android   Fields: Other

Download  a-pattern-to-simplify-multiple.zip (157.48 KB)

You need to Sign In to download the file a-pattern-to-simplify-multiple.zip
If you do not have an account then Sign up for free here

Introduction

Provide a multiple-async-waiting operation management pattern for Android.

Background

Commonly, when we have some IO FileDescriptor (File, Pipe, Socket, etc.) to do the async-operation, we have to create a dedicated thread to handle the async waiting. If some modules/components require the async waiting simultaneously, we may have to create multiple threads, these will cause some resource wasting.

To reduce the resource consumption and simplify the multiple-async-waiting management, we will create a pattern/method to handle the async waiting in a single dedicated thread.

Using the Code

This article provides native(C++) implementation & Java implementation.

Native(C++) Implementation

Prepare the looper for Native Implementation
void *looperThreadCallback(void *data) {
    *(ALooper **) data = ALooper_prepare(0);
    ALooper_pollAll(-1, 0, NULL, NULL);     //this function will return when call ALooper_wake
    return NULL;
}

ALooper *createLooper(const char *threadName) {
    ALooper *looper = NULL;
    pthread_t t;
    pthread_create(&t, NULL, looperThreadCallback, &looper);
    pthread_setname_np(t, threadName);
    pthread_detach(t);  //detach the pthread_t, because we don't care the thread termination
    while (looper == NULL) { usleep(0); }   //simple spin wait, because the looper should be ready quickly
    return looper;
}

void createDefaultLooper() {
    g_defaultWaitIOLooper = createLooper("DefaultNativeIO");
}
Native main Function
void *registerWaitForSingleFD(int fd, int events, ALooper_callbackFunc func, 
                              void *data, bool isLongRunListener) {
    LOGD("registerWaitForSingleFD: fd=%d events=%d", fd, events);
    ALooper *looper = NULL;
    if (isLongRunListener) {
        looper = createLooper("LongRunNativeIO");
    } else {
        pthread_once(&g_defaultWaitIOLooper_once_t, createDefaultLooper);
        looper = g_defaultWaitIOLooper;
    }
    ALooper_addFd(looper, fd, 0, events, func, data);
    return looper;
}

void unregisterWaitForSingleFD(void *hWait, int fd) {
    LOGD("unregisterWaitForSingleFD: fd=%d", fd);
    ALooper_removeFd((ALooper *) hWait, fd);
    if (hWait != g_defaultWaitIOLooper) {   //check whether LongRunListener
        ALooper_wake((ALooper *) hWait);    //notify ALooper_pollAll to return
    }
}

Java Implementation

Prepare the looper for Java Implementation
private static final HandlerThread mHandlerThread = new HandlerThread("DefaultJavaIO") {{
    start();
}};
Java main Function
public static WaitIOThreadPool registerWaitForSingleFD(FileDescriptor fd, int events, 
MessageQueue.OnFileDescriptorEventListener listener, boolean isLongRunListener) {
    final Looper looper;
    if (isLongRunListener) {
        looper = new HandlerThread("LongRunJavaIO") {{
            start();
        }}.getLooper();
    } else {
        looper = mHandlerThread.getLooper();
    }
    looper.getQueue().addOnFileDescriptorEventListener(fd, events, listener);
    return new WaitIOThreadPool(looper, isLongRunListener);
}

public void unregisterWaitForSingleFD(FileDescriptor fd) {
    mLooper.getQueue().removeOnFileDescriptorEventListener(fd);
    if (mIsLongRunListener) {
        mLooper.quitSafely();
    }
}

In this way, we can handle the multiple-async-waiting in a single dedicated thread for multiple modules/components.

Points of Interest

  1. Android has provided the threadpool implementation in Java side, so we can execute the async callback(MessageQueue.OnFileDescriptorEventListener) in threadpool instead of inline execution (using by the demo code). Because the inline executation may cause some latency on IO data handling.
  2. You even can utilize the main looper(in the UI thread) as the waitor, then no additional dedicated thread require

A Pattern to Simplify Multiple Async Waiting for Android

Provide a multiple-async-waiting operation management pattern for Android

Posted on 07-03-2018 

Comment:

To comment you must be logged in members.

Files with category

 
File suggestion for you
File suggestion for you
File suggestion for you
File suggestion for you
Loading...
Loading...
Loading...
Loading...
File top downloads
File top downloads
File top downloads
File top downloads
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Codetitle - library source code to share, download the file to the community
Copyright © 2018. All rights reserved. codetitle Develope by Vinagon .Ltd