我的要求是有一个线程来维护 BlackBerry 设备和服务器之间的套接字连接并交换命令，类似于请求和响应。

我的问题是我需要让这个线程始终在后台运行并保持 UI 对用户可用。因此，当有来自服务器的命令时，该线程会解析它并更新 UI，而且如果有来自 BlackBerry 用户的操作，它会将其发送到服务器，然后由服务器处理它。

我使用 AsyncTask 在 Android 中开发了相同的应用程序，并且运行良好。但是在 BlackBerry 中，由于没有这样的类，我使用了 invokeLater()选项。服务器和 BB 设备之间的通信工作正常，但 UI 在 BlackBerry 上被卡住。

有人知道如何正确处理吗？

最佳答案

Vishal 走在正确的轨道上，但还需要多一点才能匹配 Android 的 AsyncTask。由于 BlackBerry 上的 Java 1.3 不提供枚举和泛型，因此您无法完美匹配 Android API。

但是，您可以这样做(未经测试……这只是您的起点):

import net.rim.device.api.ui.UiApplication;

public abstract class AsyncTask {

    public static final int FINISHED = 0;
    public static final int PENDING = 1;
    public static final int RUNNING = 2;

    private int _status = PENDING;
    private boolean _cancelled = false;
    private Thread _worker;

    /** subclasses MUST implement this method */
    public abstract Object doInBackground(Object[] params);

    protected void onPreExecute() {
        // default implementation does nothing
    }
    protected void onPostExecute(Object result) {
        // default implementation does nothing
    }
    protected void onProgressUpdate(Object[] values) {
        // default implementation does nothing
    }
    protected void onCancelled() {
        // default implementation does nothing
    }
    protected void onCancelled(Object result) {
        onCancelled();
    }

    public final int getStatus() {
        return _status;
    }

    public final boolean isCancelled() {
        return _cancelled;
    }

    public final boolean cancel(boolean mayInterruptIfRunning) {
        if (_status == FINISHED || _cancelled) {
            return false;
        } else {
            _cancelled = true;
            if (mayInterruptIfRunning && _status == RUNNING) {
                // NOTE: calling Thread.interrupt() usually doesn't work
                //   well, unless you don't care what state the background
                //   processing is left in.  I'm not 100% sure that this is how
                //   Android's AsyncTask implements cancel(true), but I 
                //   normally just cancel background tasks by letting the
                //   doInBackground() method check isCancelled() at multiple
                //   points in its processing.
                _worker.interrupt();
            }
            return true;
        }
    }

    protected final void publishProgress(final Object[] values) {
        // call back onProgressUpdate on the UI thread
        UiApplication.getUiApplication().invokeLater(new Runnable() {
            public void run() {
                onProgressUpdate(values);
            }
        });
    }

    private void completeTask(final Object result) {
        // transmit the result back to the UI thread
        UiApplication.getUiApplication().invokeLater(new Runnable() {
            public void run() {
                if (isCancelled()) {
                    onCancelled(result);
                } else {
                    onPostExecute(result);
                }
                // TODO: not sure if status should be FINISHED before or after onPostExecute()
                _status = FINISHED;
            }
        }); 
    }

    public AsyncTask execute(final Object[] params) throws IllegalStateException {
        if (getStatus() != PENDING) {
            throw new IllegalStateException("An AsyncTask can only be executed once!");
        } else {
            try {
                onPreExecute();

                _worker = new Thread(new Runnable() {
                    public void run() {
                        try {
                            // run background work on this worker thread
                            final Object result = doInBackground(params);
                            completeTask(result);
                        } catch (Exception e) {
                            // I believe if Thread.interrupt() is called, we'll arrive here
                            completeTask(null);
                        }
                    }
                });
                _status = RUNNING;
                _worker.start();
            } catch (Exception e) {
                // TODO: handle this exception
            }
        }

        return this;
    }

}

此外，重要的是要记住 Android 的 AsyncTask 的线程规则，它也适用于上述实现:

Threading rules There are a few threading rules that must be followed for this class to work properly:

• The AsyncTask class must be loaded on the UI thread. This is done automatically as of JELLY_BEAN.

• The task instance must be created on the UI thread.

• execute(Params...) must be invoked on the UI thread.

• Do not call onPreExecute(), onPostExecute(Result), doInBackground(Params...), onProgressUpdate(Progress...) manually.

• The task can be executed only once (an exception will be thrown if a second execution is attempted.)

关于java - 等同于 AsyncTask 的 BlackBerry 类？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/12982021/