Click here to Skip to main content
13,705,376 members
Click here to Skip to main content
Add your own
alternative version

Tagged as

Stats

4.9K views
34 downloads
3 bookmarked
Posted 8 Jan 2018
Licenced CPOL

A Pattern to Simplify Multiple Async Waiting for Android

, 5 Feb 2018
Rate this:
Please Sign up or sign in to vote.
Provide a multiple-async-waiting operation management pattern for Android

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

 

History

  • 8th January, 2018: Initial post

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Yesy
Software Developer (Senior)
China China
No Biography provided

You may also be interested in...

Pro

Comments and Discussions

 
Questioni cant find full source code Pin
lyricc17-Jan-18 15:58
grouplyricc17-Jan-18 15:58 
AnswerRe: i cant find full source code Pin
Yesy4-Feb-18 23:14
memberYesy4-Feb-18 23:14 
QuestionA few things... Pin
Afzaal Ahmad Zeeshan8-Jan-18 4:13
mvpAfzaal Ahmad Zeeshan8-Jan-18 4:13 
GeneralRe: A few things... Pin
David Crow15-Jan-18 10:32
memberDavid Crow15-Jan-18 10:32 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Permalink | Advertise | Privacy | Cookies | Terms of Use | Mobile
Web01-2016 | 2.8.180920.1 | Last Updated 5 Feb 2018
Article Copyright 2018 by Yesy
Everything else Copyright © CodeProject, 1999-2018
Layout: fixed | fluid