当侦听器停止在这个android firebase代码中工作时，我的AsyncTask会死吗？

因此，我将

ChildEventListener

和

ValueEventListener

添加到

AsyncTask

中。 这样主ui线程就不会被打扰了。下面的代码可以正常工作，但问题是当我在down-down

exitFirebase（）方法中终止侦听器时会发生什么

当
AsyncTask
启动时，通过
doInBackground（）
添加FireBase侦听器，然后通过
onPostExecute（）
退出，但侦听器保持
AsyncTask
处于活动状态

当我终止侦听器时会发生什么

   /**
     * Typically when user sign in or app start
     */
    public void userSigneIn() {
        // start listening
        asyncTaskUserAddressHistory().execute();
    }


    public AsyncTask asyncTaskUserAddressHistory() {
        AsyncTask task = new AsyncTask<Object, Object, Object>() {

            /**
             * The User history address child event listener.
             * This is only used when app first install or user wipe data
             */
            ChildEventListener userHistoryAddressChildEventListener = new ChildEventListener() {

                @Override
                public void onChildAdded(DataSnapshot snapshot, String prevKey) {
                    // do the work and continue listen
                }

                @Override
                public void onChildChanged(DataSnapshot snapshot, String prevKey) {
                }

                @Override
                public void onCancelled(DatabaseError error) {
                    // remove listener
                    ChildEventListener listener = mChildListenerMap.get(onCancel);
                    onCancel.removeEventListener(listener);
                    // start over
                    startListenForUserAddressHistory();
                }

                @Override
                public void onChildRemoved(DataSnapshot snapshot) {
                }

                @Override
                public void onChildMoved(DataSnapshot snapshot, String prevKey) {
                }
            };

            ValueEventListener userHistoryAddressvalueEventListener = new ValueEventListener() {
                @Override
                public void onDataChange(DataSnapshot dataSnapshot) {
                    // get history for current user
                    if (dataSnapshot.getChildrenCount() != 0) {
                        // do the work and start over
                        startListenForUserAddressHistory();
                    }
                }

                @Override
                public void onCancelled(DatabaseError databaseError) {
                    // remove listener
                    ValueEventListener listener = mValueListenerMap.get(onCancel);
                    onCancel.removeEventListener(listener);
                    // start over
                    startListenForUserAddressHistory();
                }
            };

            @Override
            protected Object doInBackground(Object... params) {
                // If local user don´t have any history start the ChildEventListener.
                if (HistoryManager.getInstance().getHistoryItems(mFireBaseAuth.getCurrentUser().getUid()).size() == 0) {
                    // Local cache of address history is empty get all address history for this user and start listen for new items
                    final Query query = ref.child(USER_HISTORY).limitToLast(LIMIT);
                    onCancel = query.getRef();
                    mChildListenerMap.put(query.getRef(), userHistoryAddressChildEventListener);
                    query.addChildEventListener(userHistoryAddressChildEventListener);

                } else {
                    // If client have history start the ValueEventListener.
                    // Typically this is not the first time app starts.
                    startListenForUserAddressHistory();
                }
                return null;
            }

            @Override
            protected void onPostExecute(Object o) {
                super.onPostExecute(o);
                // This runs and listeners are alive
            }

            /**
             * Start listen for nye entries based on that server have entries<br>
             * and client have entries, typically this is not the first time App starts.
             * This uses a ValueEventListener.
             */
            private void startListenForUserAddressHistory() {
                // Local history is not empty so we must go get only new items
                final HistoryItem historyItem = HistoryManager.getInstance()
                        .orderHistoryByDateAndGetNewest(mFireBaseAuth.getCurrentUser().getUid());
                final Query query = ref
                        .child(USER_HISTORY)
                        .child(mFireBaseAuth.getCurrentUser().getUid())
                        .child(UserHistory.ADDRESS_HISTORY)
                        .orderByKey()
                        .startAt(historyItem.getPushKey());
                mValueListenerMap.put(query.getRef(), userHistoryAddressvalueEventListener);
                skipStartAtKey = historyItem.getPushKey();
                onCancel = query.getRef();
                query.addValueEventListener(userHistoryAddressvalueEventListener);
            }
        };
        return task;
    }

    /**
     * App is closing or User has signed out
     * Called from both onClose() and userSignedOut()
     */
    private void exitFirebase() {
        if (userLogger != null)
            userLogger.log(USER_SIGNED_OUT);
        // Close ChildEventListener(s)
        for (Map.Entry<DatabaseReference, ChildEventListener> entry : mChildListenerMap.entrySet()) {
            DatabaseReference ref = entry.getKey();
            ChildEventListener listener = entry.getValue();
            if (listener != null && ref != null)
                ref.removeEventListener(listener);
        }
        // Close ValueEventListener(s)
        for (Map.Entry<DatabaseReference, ValueEventListener> entry : mValueListenerMap.entrySet()) {
            DatabaseReference ref = entry.getKey();
            ValueEventListener listener = entry.getValue();
            if (listener != null && ref != null)
                ref.removeEventListener(listener);
        }
        if (userAuthListener != null)
            mFireBaseAuth.removeAuthStateListener(userAuthListener);
        userLogger = null;
    }

/**
*通常在用户登录或应用程序启动时
*/
public void userSigneIn（）{
//开始听
asyncTaskUserAddressHistory（）.execute（）；
}
公共AsyncTask asyncTaskUserAddressHistory（）{
AsyncTask任务=新建AsyncTask（）{
/**
*用户历史记录地址子事件侦听器。
*这仅在应用程序首次安装或用户擦除数据时使用
*/
ChildEventListener userHistoryAddressChildEventListener=新建ChildEventListener（）{
@凌驾
公共void onchildaded（DataSnapshot快照，字符串prevKey）{
//做作业，继续听
}
@凌驾
公共void onChildChanged（DataSnapshot快照，字符串prevKey）{
}
@凌驾
已取消的公共无效（DatabaseError错误）{
//删除侦听器
ChildEventListener=mChildListenerMap.get（onCancel）；
onCancel.removeEventListener（侦听器）；
//重新开始
startListenForUserAddressHistory（）；
}
@凌驾
公共void onChildRemoved（DataSnapshot快照）{
}
@凌驾
public void onChildMoved（DataSnapshot快照，字符串prevKey）{
}
};
ValueEventListener userHistoryAddressvalueEventListener=新的ValueEventListener（）{
@凌驾
公共void onDataChange（DataSnapshot DataSnapshot）{
//获取当前用户的历史记录
如果（dataSnapshot.getChildrenCount（）！=0）{
//完成工作，重新开始
startListenForUserAddressHistory（）；
}
}
@凌驾
已取消的公共void（DatabaseError DatabaseError）{
//删除侦听器
ValueEventListener=mValueListenerMap.get（onCancel）；
onCancel.removeEventListener（侦听器）；
//重新开始
startListenForUserAddressHistory（）；
}
};
@凌驾
受保护对象doInBackground（对象…参数）{
//如果本地用户没有任何历史记录，请启动ChildEventListener。
if（HistoryManager.getInstance（）.getHistoryItems（mFireBaseAuth.getCurrentUser（）.getUid（））.size（）=0）{
//地址历史记录的本地缓存为空获取此用户的所有地址历史记录并开始侦听新项目
最终查询查询=ref.child（用户历史）。limitToLast（限制）；
onCancel=query.getRef（）；
mChildListenerMap.put（query.getRef（），userHistoryAddressChildEventListener）；
addChildEventListener（userHistoryAddressChildEventListener）；
}否则{
//如果客户端具有历史记录，则启动ValueEventListener。
//通常这不是应用程序第一次启动。
startListenForUserAddressHistory（）；
}
返回null；
}
@凌驾
受保护的void onPostExecute（对象o）{
super.onPostExecute（o）；
//这将运行，并且侦听器处于活动状态
}
/**
*开始侦听基于该服务器的nye条目have entries

*客户端有条目，通常这不是应用程序第一次启动。
*这将使用ValueEventListener。
*/
private void startListenForUserAddressHistory（）{
//本地历史记录不是空的，因此我们必须只获取新项目
final HistoryItem HistoryItem=HistoryManager.getInstance（）
.OrderHistoryByDateAndGetNewst（mFireBaseAuth.getCurrentUser（）.getUid（））；
最终查询查询=ref
.child（用户历史记录）
.child（mFireBaseAuth.getCurrentUser（）.getUid（））
.child（UserHistory.ADDRESS\u历史记录）
.orderByKey（）
.startAt（historyItem.getPushKey（））；
mValueListenerMap.put（query.getRef（），userHistoryAddressvalueEventListener）；
SkipStartKey=historyItem.getPushKey（）；
onCancel=query.getRef（）；
addValueEventListener（userHistoryAddressvalueEventListener）；
}
};
返回任务；
}
/**
*应用程序正在关闭或用户已注销
*从onClose（）和userSignedOut（）调用
*/
私有void exitFirebase（）{
if（userLogger！=null）
logger.log（用户已注销）；
//关闭ChildEventListener（个）
对于（Map.Entry:mChildListenerMap.entrySet（））{
DatabaseReference=entry.getKey（）；
ChildEventListener listener=entry.getValue（）；
if（侦听器！=null&&ref！=null）
参考removeEventListener