Android 在长时间运行的线程之间传递数据（不推荐使用LocalBroadcastManager）

我有以下场景：一个前台服务产生2个HandlerThreads（a和B）。A必须不时地向B发送一些数据，B对此数据执行特定操作，并将操作结果发送回A。我不知道如何在这两个线程之间有效地传递数据。最初，我将消息发布到MainService线程（通过处理程序），而MainService线程又将消息发布到相应的线程。但这似乎有点过分：

• （线程A）将消息发布到主线程处理程序
• （主线程）接收消息并将其发布到线程B处理程序
• （线程B）执行某些操作并将结果发布回主线程处理程序
• （主线程）接收消息并将其发布到线程处理程序
• （A）做点什么

我原以为可以使用LocalBroadcastManager，但现在似乎不推荐使用它。你对此有什么建议吗

编辑1 程序的简化版本。我担心在线程之间添加更多信号后，显示的代码会变得太复杂

MainService.java

公共类MainService扩展服务{
私有静态最终字符串TAG=“MainService”；
公共静态最终整数起始\u A=0；
公共静态最终整数DO_STH_IN_B=1；
公共静态最终整数响应_从_B_到_A=2；
私有处理程序mServiceHandler=新处理程序（Looper.getMainLooper（））{
//这是线程间消息的调度程序
@凌驾
公共无效handleMessage（@NonNull Message msg）{
超级handleMessage（msg）；
消息消息；
如果（msg.what==做某事）
msg_s=Message.get（myThreadB.getHandler（））；
else if（msg.what==从_B_响应到_A）
msg_s=Message.get（myThreadA.getHandler（））；
否则返回；
msg_.what=msg.what；
msg_.s.sendToTarget（）；
}
};
私有MyThreadA MyThreadA=新的MyThreadA（mServiceHandler）；
私有MyThreadB MyThreadB=新的MyThreadB（mServiceHandler）；
@凌驾
public void onCreate（）{
super.onCreate（）；
myThreadA.start（）；
myThreadB.start（）；
系统时钟。睡眠（100）；
}
@凌驾
公共int onStartCommand（Intent Intent、int标志、int startId）{
Intent notificationIntent=新的Intent（this，MainActivity.class）；
下垂的，下垂的=
PendingEvent.getActivity（this，0，notificationIntent，0）；
通知=
新建NotificationCompat.Builder（此“M_ID”）
.setContentTitle（“通知标题”）
.setContentText（“通知文本”）
.setSmallIcon（R.drawable.ic_android）
.setContentIntent（挂起内容）
.build（）；
启动前（1，通知）；
Message msg=Message.get（myThreadA.getHandler（））；
msg.what=START_A；
msg.sendToTarget（）；
//stopSelf（）；
返回开始时间不粘；
}
@凌驾
公共空间{
super.ondestory（）；
myThreadA.quit（）；
myThreadB.quit（）；
}
@可空
@凌驾
公共IBinder onBind（意向）{
返回null；
}
}

MyThreadA.java

公共类MyThreadA扩展HandlerThread{
私有静态最终字符串TAG=“MyThreadA”；
私人经理人；
私有处理程序和服务处理程序；
公共MyThreadA（处理程序）{
超级（标记、进程、线程\u优先级\u后台）；
mMainServiceHandler=handler；
}
@SuppressLint（“HandlerLeak”）
@凌驾
受保护的void onloperprepared（）{
mHandler=新处理程序（）{
@凌驾
公共无效handleMessage（@NonNull Message msg）{
if（msg.what==MainService.START_A）{
mHandler.post（我的例行程序）；
}else if（msg.what==MainService.response_FROM_B_TO_A）{
mHandler.post（MyRoutinerRespond）；
}
}
};
}
公共处理程序getHandler（）{return mHandler；}
private Runnable myRoutine=new Runnable（）{
@凌驾
公开募捐{
Log.d（标记“run:[thread A]myRoutine”）；
//在这里做点什么（可能是阻塞）
系统时钟。睡眠（1000）；
//将消息发送到线程B（通过主服务传递）
Message msg=Message.get（mMainServiceHandler）；
msg.what=MainService.DO；
msg.sendToTarget（）；
//重复常规
mHandler.post（我的例行程序）；
}
};
private Runnable myRoutineRespond=new Runnable（）{
@凌驾
公开募捐{
d（标记“run:[thread A]respond handler”）；
//在这里用B的回复做点什么
SystemClock.sleep（2000年）；
}
};
}

MyThreadB.java

公共类MyThreadB扩展HandlerThread{
私有静态最终字符串标记=“MyThreadB”；
私人经理人；
私有处理程序和服务处理程序；
公共MyThreadB（处理程序）{
超级（标记、进程、线程\u优先级\u后台）；
mMainServiceHandler=handler；
}
@SuppressLint（“HandlerLeak”）
@凌驾
受保护的void onloperprepared（）{
mHandler=新处理程序（）{
@凌驾
公共无效handleMessage（@NonNull Message msg）{
如果（msg.what==MainService.dou STH\u在B中）{
mHandler.post（我的例行程序）；
}
}
};
}
公共处理程序getHandler（）{return mHandler；}
private Runnable myRoutine=new Runnable（）{