移动应用为支持各种功能，大多采用了多线程技术。使用单独的线程执行某些任务，同时不影响界面的刷新，在线程执行过程中，可能需要通知一些信息给界面线程，在线程结束之后，需要告诉界面线程执行的结果，这是较为通用的一种线程执行方式。
在C#中，实现该功能的类是BackgroundWorker, 而在android和ios中，并无类似的封装好的类。通常在开发应用的时候需要考虑可移植性，存在为多种平台开发相同应用的情况，为简化不同平台应用的开发，编程需要考虑相同的逻辑结构。因此在android和ios实现与BackgroundWorker类似的功能和接口。
1.C#的BackgroundWorker
BackgroundWorker包含的主要属性和接口说明如下：
主要属性:
event DoWorkEventHandler DoWork; //线程的主体
event ProgressChangedEventHandler ProgressChanged; //线程运行过程中的消息
event RunWorkerCompletedEventHandler RunWorkerCompleted; //线程结束时的处理
主要函数：
void CancelAsync(); 取消线程的运行
void ReportProgress(int percentProgress, object userState); //报告线程的消息
void RunWorkerAsync(object argument); //开始执行线程
为了方面使用，可以将BackgroundWorker进行封装如下
public class StarBackgroundWorker
{
private BackgroundWorker m_worker;
public StarBackgroundWorker()
{
m_worker = new BackgroundWorker();
}
public void CancelAsync()
{
m_worker.CancelAsync();
}
public void RunAsync(DoWorkEventHandler DoWork, object userState, ProgressChangedEventHandler ProgressChanged, RunWorkerCompletedEventHandler RunWorkerCompleted)
{
m_worker.DoWork += DoWork;
m_worker.WorkerSupportsCancellation = true;
m_worker.RunWorkerCompleted += RunWorkerCompleted;
if (ProgressChanged != null)
{
m_worker.ProgressChanged += ProgressChanged;
m_worker.WorkerReportsProgress = true;
}
m_worker.RunWorkerAsync(userState);
}
public void ReportProgress(int percentProgress, object userState)
{
m_worker.ReportProgress(percentProgress, userState);
}
}
使用方法：
StarCoreBackgroundWorker myworker = new StarCoreBackgroundWorker();
myworker.RunAsync(
(object sender1, DoWorkEventArgs e1) =>
{
BackgroundWorker worker = sender1 as BackgroundWorker;
//线程的主体
},
null,
(object sender1, ProgressChangedEventArgs e1) =>
{
//--在界面线程中执行，可以刷新界面
},
(object sender1, RunWorkerCompletedEventArgs e1) =>
{
//--在界面线程中处理，线程运行结束后的处理
}
);2.Android中实现类似BackgroundWorker的功能
Android中使用java编程，通常创建线程使用Thread和Runnable，线程与界面线程通信使用消息的方式，从界面线程中的handler获取一条消息结构，填充参数，使用sendMessage将消息发送给界面线程。界面线程的Handler获取消息队列中的消息进行处理。利用这些方式，可以实现类似c# BackgroundWorker功能
a. 封装Handler
由于采用Handler处理所有BackgroundWorker线程中的消息，为了区分不同的线程，需要线程在创建时进行登记。代码如下：
public class StarUIHander {
static public Handler handler;
static int InvokeTag = 0;
static HashMap<Integer,HandlerCallBack> CallBackList;
public interface HandlerCallBack {
void Invoke(Message msg);
}
static int Register(HandlerCallBack CallBack)
{
int Val = InvokeTag;
CallBackList.put(InvokeTag,CallBack);
InvokeTag ++;
return Val;
}
static void Remove(int Which)
{
CallBackList.remove(Which);
}
static void InitStarUIHander()
{
handler = new android.os.Handler() {
public void handleMessage(Message msg) {
HandlerCallBack CallBack = CallBackList.get(msg.what);
if( CallBack != null )
CallBack.Invoke(msg);
}
};
CallBackList = new HashMap<Integer,HandlerCallBack>();
}
}
在android应用主Activity中，调用InitStarUIHander初始化Handler，对于创建的线程，调用Register注册消息处理函数，获取标识，使用该标识发送消息时。
b. 实现BackgroundWorker功能
在实现BackgroundWorker之前，参照c#的定义，需要实现一些相关的接口。有以下几个：
CancellationTokenSource, ProgressChangedEventArgs, DoWorkEventArgs，RunWorkerCompletedEventArgs，具体代码可参考附件
public BackgroundWorker()
{
//_dispatcher = this.Dispatcher;
cts = new CancellationTokenSource();
HandlerQueue = StarUIHander.Register(new StarUIHander.HandlerCallBack() {
@Override
public void Invoke(Message msg) {
Object[] Para = (Object[])msg.obj;
switch ((int)Para[0]) {
case Message_ReportProgress:
if (ProgressChanged != null ){
ProgressChanged.Invoke(this,(ProgressChangedEventArgs)Para[1]);
}
break;
case Message_OnRunWorkerCompleted:
if (RunWorkerCompleted != null)
RunWorkerCompleted.Invoke(this,(RunWorkerCompletedEventArgs)Para[1]);
break;
}
}
});
}
报告状态:
public void ReportProgress(int percentProgress, Object userState)
{
if (ProgressChanged != null ){
Message message = StarUIHander.handler.obtainMessage();
message.what = HandlerQueue;
message.obj = new Object[]{Message_ReportProgress,new ProgressChangedEventArgs(percentProgress,userState)};
StarUIHander.handler.sendMessage(message);
}
}
创建线程执行:
public void RunWorkerAsync(Object userState)
{
final BackgroundWorker m_worker = this;
if (DoWork != null)
{
IsBusy = true;
try {
final DoWorkEventArgs args = new DoWorkEventArgs(userState);
new Thread(new Runnable(){
@Override
public void run() {
DoWork.Invoke(m_worker, args);
IsBusy = false;
if (RunWorkerCompleted != null) {
Message message = StarUIHander.handler.obtainMessage();
message.what = HandlerQueue;
message.obj = new Object[]{Message_OnRunWorkerCompleted, new RunWorkerCompletedEventArgs(args.Result, null, args.Cancel)};
StarUIHander.handler.sendMessage(message);
}
}
}).start();
}
catch (Exception ex) {
IsBusy = false;
if (RunWorkerCompleted != null) {
Message message = StarUIHander.handler.obtainMessage();
message.what = HandlerQueue;
message.obj = new Object[]{Message_OnRunWorkerCompleted, new RunWorkerCompletedEventArgs(false, ex, false)};
StarUIHander.handler.sendMessage(message);
}
}
}
}
为了方面使用，将BackgroundWorker进行封装如下
public static class StarCoreBackgroundWorker
{
private BackgroundWorker m_worker;
public StarCoreBackgroundWorker()
{
m_worker = new BackgroundWorker();
}
public void CancelAsync()
{
m_worker.CancelAsync();
}
public void RunAsync(DoWorkEventHandler DoWork, Object userState, ProgressChangedEventHandler ProgressChanged, RunWorkerCompletedEventHandler RunWorkerCompleted)
{
m_worker.DoWork = DoWork;
m_worker.WorkerSupportsCancellation = true;
m_worker.RunWorkerCompleted = RunWorkerCompleted;
if (ProgressChanged != null)
{
m_worker.ProgressChanged = ProgressChanged;
m_worker.WorkerReportsProgress = true;
}
m_worker.RunWorkerAsync(userState);
}
public void ReportProgress(int percentProgress, Object userState)
{
m_worker.ReportProgress(percentProgress, userState);
}
} 使用方法：
StarBackgroundWorker myworker = new StarBackgroundWorker();
myworker.RunAsync(
new DoWorkEventHandler() {
public void Invoke(Object sender1, DoWorkEventArgs e1) {
BackgroundWorker worker = sender1 as BackgroundWorker;
//线程的主体
}
},
null,
new ProgressChangedEventHandler() {
public void Invoke(Object sender1, ProgressChangedEventArgs e1) {
//--在界面线程中执行，可以刷新界面
}
},
new RunWorkerCompletedEventHandler() {
public void Invoke(Object sender, RunWorkerCompletedEventArgs e)
{
//--在界面线程中处理，线程运行结束后的处理
}
});3. ios中实现类似BackgroundWorker的功能
ios创建线程可以使用NSThread，在界面线程中运行调用performSelectorOnMainThread函数；也可以使用GCD相关的函数，对多线程进行封装，可以实现类似c#的BackgroundWorker功能
a. 实现BackgroundWorker功能
与android类似，在实现BackgroundWorker之前，参照c#的定义，同样需要实现一些相关的接口。有以下几个：
CancellationTokenSource, ProgressChangedEventArgs, DoWorkEventArgs，RunWorkerCompletedEventArgs，具体代码可参考附件
定义接口:
typedef void(^ProgressChangedEventHandler)(id,ProgressChangedEventArgs*);
typedef void(^RunWorkerCompletedEventHandler)(id,RunWorkerCompletedEventArgs*);
typedef void(^DoWorkEventHandler)(id,DoWorkEventArgs*);实现BackgroundWorker
上报状态:
-(void)ReportProgress:(uint)percentProgress userState:(id)userState
{
if (ProgressChanged != nil || ProgressChangedSelector != nil ){
dispatch_async(dispatch_get_main_queue(),^{
@try{
if( ProgressChangedSelector == nil )
ProgressChanged(self,[ProgressChangedEventArgs initProgressChangedEventArgs:percentProgress UserState:userState]);
else{
IMP imp = [SelectorController methodForSelector:ProgressChangedSelector];
void (*func)(id, SEL, id, ProgressChangedEventArgs* ) = (void *)imp;
func(SelectorController, ProgressChangedSelector, self, [ProgressChangedEventArgs initProgressChangedEventArgs:percentProgress UserState:userState]);
}
}
@catch(NSException* e)
{
}
});
}
}
异步执行
-(void)RunWorkerAsync:(id)userState
{
if (DoWork != nil || DoWorkSelector != nil)
{
@try {
DoWorkEventArgs* args = [DoWorkEventArgs initDoWorkEventArgs:userState];
dispatch_async(dispatch_get_global_queue(0, 0),^{
if( DoWork != nil )
DoWork(self,args);
else if(DoWorkSelector != nil ){
IMP imp = [SelectorController methodForSelector:DoWorkSelector];
void (*func)(id, SEL, id, DoWorkEventArgs* ) = (void *)imp;
func(SelectorController, DoWorkSelector, self,args);
}
dispatch_async(dispatch_get_main_queue(),^{
if (RunWorkerCompleted != nil)
RunWorkerCompleted(self,[RunWorkerCompletedEventArgs initRunWorkerCompletedEventArgs:args.Result Cancelled:args.Cancel]);
else if(RunWorkerCompletedSelector != nil){
IMP imp = [SelectorController methodForSelector:RunWorkerCompletedSelector];
void (*func)(id, SEL, id, RunWorkerCompletedEventArgs* ) = (void *)imp;
func(SelectorController, RunWorkerCompletedSelector, self,[RunWorkerCompletedEventArgs initRunWorkerCompletedEventArgs:args.Result Cancelled:args.Cancel]);
}
});
});
}
@catch(NSException* e)
{
dispatch_async(dispatch_get_main_queue(),^{
if (RunWorkerCompleted != nil)
RunWorkerCompleted(self,[RunWorkerCompletedEventArgs initRunWorkerCompletedEventArgs:e]);
else if( RunWorkerCompletedSelector != nil ){
IMP imp = [SelectorController methodForSelector:RunWorkerCompletedSelector];
void (*func)(id, SEL, id, RunWorkerCompletedEventArgs* ) = (void *)imp;
func(SelectorController, RunWorkerCompletedSelector, self,[RunWorkerCompletedEventArgs initRunWorkerCompletedEventArgs:e]);
}
});
}
}
}
b. 为了方面使用，将BackgroundWorker进行封装如下
-(void)RunAsync:(DoWorkEventHandler)DoWork userState:(id)userState ProgressChanged:(ProgressChangedEventHandler)ProgressChanged RunWorkerCompleted:(RunWorkerCompletedEventHandler)RunWorkerCompleted
{
m_worker.DoWork = DoWork;
m_worker.RunWorkerCompleted = RunWorkerCompleted;
if (ProgressChanged != nil)
{
m_worker.ProgressChanged = ProgressChanged;
}
[m_worker RunWorkerAsync:userState];
}
-(void)ReportProgress:(uint)percentProgress userState:(id)userState
{
[m_worker ReportProgress:percentProgress userState:userState];
}
使用方法：
StarBackgroundWorker* myworker = [StarBackgroundWorker initStarBackgroundWorker];
[myworker RunAsync:^(id sender1, DoWorkEventArgs *e) {
BackgroundWorker* worker = (BackgroundWorker*)sender1;
} userState:nil ProgressChanged:^(id sender1, ProgressChangedEventArgs *e) {
} RunWorkerCompleted:^(id sender1, RunWorkerCompletedEventArgs *e) {
}
}];4. 结束语
如果不考虑可移植性，可以直接使用android，ios，windows中定义的多线程方法开发应用，但由于不同平台采用的是不同语言，多线程实现接口和方式不同，会影响应用的逻辑结构，增加不同平台移植的工作量。基于线程执行过程，参考C#中的BackgroundWorker机制，在android和ios实现了类似的多线程机制，采用相同的框架结构，提供类似的接口，可以使多线程在不同平台具有相同的逻辑结构
上面的代码不完整，具体请参考附件
扫一扫
838
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
