Запуск кода в основном потоке из другого потока

ПРИМЕЧАНИЕ. Этот ответ привлек столько внимания, что мне нужно его обновить. Поскольку исходный ответ был опубликован, комментарий от @dzeikei привлек почти такое же внимание, как и исходный ответ. Итак, вот 2 возможных решения:

1. Если в фоновом потоке есть ссылка на объект Context:

Убедитесь, что ваши фоновые рабочие потоки имеют доступ к объекту Context (может быть контекстом приложения или контекстом службы). Затем просто сделайте это в фоновом рабочем потоке:

// Get a handler that can be used to post to the main thread
Handler mainHandler = new Handler(context.getMainLooper());

Runnable myRunnable = new Runnable() {
    @Override 
    public void run() {....} // This is your code
};
mainHandler.post(myRunnable);

2. Если в фоновом потоке нет объекта Context (или он ему не нужен)

(предложено @dzeikei):

// Get a handler that can be used to post to the main thread
Handler mainHandler = new Handler(Looper.getMainLooper());

Runnable myRunnable = new Runnable() {
    @Override 
    public void run() {....} // This is your code
};
mainHandler.post(myRunnable);

Как правильно указал нижеприведенный комментатор, это не общее решение для сервисов, а только для потоков, запускаемых из вашей активности (сервис может быть таким потоком, но не все из них). По сложной теме коммуникации между сервисами и действиями, пожалуйста, прочтите весь раздел «Сервисы» в официальном документе - это сложно, поэтому было бы неплохо понять основы: http://developer.android.com/guide/components/services.html#Notifications

Приведенный ниже метод может работать в простейших случаях:

Если я правильно вас понял, вам нужен какой-то код для выполнения в потоке графического интерфейса приложения (не могу думать ни о чем другом, называемом основным потоком). Для этого есть метод на Activity:

someActivity.runOnUiThread(new Runnable() {
        @Override
        public void run() {
           //Your code to run in GUI thread here
        }//public void run() {
});

Док: http://developer.android.com/reference/android/app/Activity.html#runOnUiThread%28java.lang.Runnable%29.

Надеюсь, это то, что вы ищете.

Версии Kotlin

Когда вы занимаетесь деятельностью, используйте

runOnUiThread {
    //code that runs in main
}

Когда у вас есть контекст активности, тогда используйте mContext

mContext.runOnUiThread {
    //code that runs in main
}

Когда вы находитесь в месте, где контекст недоступен, используйте

Handler(Looper.getMainLooper()).post {  
    //code that runs in main
}

Есть еще один простой способ, если у вас нет доступа к Context.

1). Создайте обработчик из основного петлителя:

Handler uiHandler = new Handler(Looper.getMainLooper());

2). Реализуйте интерфейс Runnable:

Runnable runnable = new Runnable() { // your code here }

3). Разместите свой Runnable в uiHandler:

uiHandler.post(runnable);

Вот и все ;-) Развлекайтесь с потоками, но не забывайте их синхронизировать.

Если вы запускаете код в потоке, например отложите какое-то действие, тогда вам нужно вызвать runOnUiThread из контекста. Например, если ваш код находится внутри класса MainActivity, используйте это:

MainActivity.this.runOnUiThread(new Runnable() {
    @Override
    public void run() {
        myAction();
    }
});

Если ваш метод может быть вызван либо из основного (поток пользовательского интерфейса), либо из других потоков, вам нужна проверка, например:

public void myMethod() {
   if( Looper.myLooper() == Looper.getMainLooper() ) {
       myAction();
   }
   else {

}

Блок сжатого кода выглядит следующим образом:

   new Handler(Looper.getMainLooper()).post(new Runnable() {
       @Override
       public void run() {
           // things to do on the main thread
       }
   });

При этом не требуется передавать ссылку на действие или ссылку на приложение.

Котлин эквивалент:

    Handler(Looper.getMainLooper()).post(Runnable {
        // things to do on the main thread
    })

Самый простой способ, особенно если у вас нет контекста, если вы используете RxAndroid, вы можете:

AndroidSchedulers.mainThread().scheduleDirect {
    runCodeHere()
}

Более точный код Kotlin с использованием обработчика:

Handler(Looper.getMainLooper()).post {  
 // your codes here run on main Thread
 }

Один из методов, который я могу придумать, таков:

1) Дайте возможность пользовательскому интерфейсу привязаться к службе.
2) Откройте метод, подобный приведенному ниже, с помощью Binder, который регистрирует ваш Handler:

public void registerHandler(Handler handler) {
    mHandler = handler;
}

3) В потоке пользовательского интерфейса вызовите указанный выше метод после привязки к службе:

mBinder.registerHandler(new Handler());

4) Используйте обработчик в ветке Сервиса, чтобы опубликовать свою задачу:

mHandler.post(runnable);

HandlerThread - лучший вариант для обычных потоков Java в Android.

1. Создайте HandlerThread и запустите его.
2. Создайте Handler с помощью Looper из HandlerThread: requestHandler
3. post Runnable задача на requestHandler

Связь с потоком пользовательского интерфейса от HandlerThread

1. Создайте Handler с Looper для основного потока: responseHandler и переопределите метод handleMessage
2. Внутри Runnable задачи другого потока (в данном случае HandlerThread) вызовите sendMessage на responseHandler
3. Этот sendMessage результат вызова handleMessage в responseHandler.
4. Получить атрибуты из Message и обработать его, обновить пользовательский интерфейс

Пример: обновите TextView данными, полученными от веб-службы. Поскольку веб-сервис должен вызываться в потоке, отличном от UI, он создан HandlerThread для работы в сети. Получив контент из веб-службы, отправьте сообщение обработчику основного потока (потока пользовательского интерфейса), и этот Handler обработает сообщение и обновит пользовательский интерфейс.

Образец кода:

HandlerThread handlerThread = new HandlerThread("NetworkOperation");
handlerThread.start();
Handler requestHandler = new Handler(handlerThread.getLooper());

final Handler responseHandler = new Handler(Looper.getMainLooper()) {
    @Override
    public void handleMessage(Message msg) {
        txtView.setText((String) msg.obj);
    }
};

Runnable myRunnable = new Runnable() {
    @Override
    public void run() {
        try {
            Log.d("Runnable", "Before IO call");
            URL page = new URL("http://www.your_web_site.com/fetchData.jsp");
            StringBuffer text = new StringBuffer();
            HttpURLConnection conn = (HttpURLConnection) page.openConnection();
            conn.connect();
            InputStreamReader in = new InputStreamReader((InputStream) conn.getContent());
            BufferedReader buff = new BufferedReader(in);
            String line;
            while ((line = buff.readLine()) != null) {
                text.append(line + "\n");
            }
            Log.d("Runnable", "After IO call:"+ text.toString());
            Message msg = new Message();
            msg.obj = text.toString();
            responseHandler.sendMessage(msg);


        } catch (Exception err) {
            err.printStackTrace();
        }
    }
};
requestHandler.post(myRunnable);

Полезные статьи:

handlerthreads-and-why-you-should-be-using-them-in-your-android-apps

android-looper-handler-handlerthread-i

Я знаю, что это старый вопрос, но я наткнулся на однострочник основного потока, который я использую как в Kotlin, так и в Java. Возможно, это не лучшее решение для службы, но для вызова чего-то, что изменит пользовательский интерфейс внутри фрагмента, это чрезвычайно просто и очевидно.

Java (8):

 getActivity().runOnUiThread(()->{
      //your main thread code
 });

Котлин:

this.runOnUiThread {
     //your main thread code
}

Так что удобнее всего делать что-то вроде:

import android.os.AsyncTask
import android.os.Handler
import android.os.Looper

object Dispatch {
    fun asyncOnBackground(call: ()->Unit) {
        AsyncTask.execute {
            call()
        }
    }

    fun asyncOnMain(call: ()->Unit) {
        Handler(Looper.getMainLooper()).post {
            call()
        }
    }
}

И после:

Dispatch.asyncOnBackground {
    val value = ...// super processing
    Dispatch.asyncOnMain { completion(value)}
}

Следуйте этому методу. Таким образом вы можете просто обновить пользовательский интерфейс из фонового потока. runOnUiThread работает в основном (UI) потоке. Я думаю, что этот фрагмент кода менее сложен и прост, особенно для новичков.

AsyncTask.execute(new Runnable() {
            @Override
            public void run() {

            //code you want to run on the background
            someCode();

           //the code you want to run on main thread
 MainActivity.this.runOnUiThread(new Runnable() {

                    public void run() {

/*the code you want to run after the background operation otherwise they will executed earlier and give you an error*/
                        executeAfterOperation();

                   }
                });
            }
        });

в случае услуги

создать обработчик в oncreate

 handler = new Handler();

тогда используйте это так

 private void runOnUiThread(Runnable runnable) {
        handler.post(runnable);
    }

для Kotlin вы можете использовать Anko corountines:

обновить

doAsync {
   ...
}

не рекомендуется

async(UI) {
    // Code run on UI thread
    // Use ref() instead of this@MyActivity
}

public void mainWork() {
    new Handler(Looper.getMainLooper()).post(new Runnable() {
        @Override
        public void run() {
            //Add Your Code Here
        }
    });
}

Это также может без проблем работать в классе обслуживания.

В Kotlin это внутри любой функции:

runOnUiThread {
   // Do work..
}