Menjalankan kode di utas utama dari utas lainnya

Dalam layanan android saya telah membuat utas untuk melakukan tugas latar belakang.

Saya memiliki situasi di mana utas perlu memposting tugas tertentu pada antrian pesan utas, misalnya a Runnable.

Apakah ada cara untuk mendapatkan Handlerutas utama dan memposting Message/ Runnableutasnya dari utas saya yang lain?

Terima kasih,

CATATAN: Jawaban ini telah mendapatkan begitu banyak perhatian, sehingga saya perlu memperbaruinya. Sejak jawaban asli diposting, komentar dari @dzeikei hampir mendapat perhatian sama seperti jawaban aslinya. Jadi, inilah 2 solusi yang mungkin:

1. Jika utas latar belakang Anda memiliki referensi ke Contextobjek:

Pastikan utas pekerja latar belakang Anda memiliki akses ke objek Konteks (bisa konteks Aplikasi atau konteks Layanan). Kemudian lakukan ini di utas latar belakang pekerja:

// 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. Jika utas latar belakang Anda tidak memiliki (atau membutuhkan) Contextobjek

(disarankan oleh @dikeikei):

// 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);

Sebagai komentator di bawah ini menunjuk dengan benar, ini bukan solusi umum untuk layanan, hanya untuk utas yang diluncurkan dari aktivitas Anda (layanan dapat berupa utas tersebut, tetapi tidak semuanya). Pada topik rumit komunikasi layanan-aktivitas, harap baca seluruh bagian Layanan pada dokumen resmi - ini rumit, jadi akan sangat membantu untuk memahami dasar-dasarnya: http://developer.android.com/guide/components/services.html #Notifikasi

Metode di bawah ini dapat berfungsi dalam kasus yang paling sederhana.

Jika saya mengerti Anda dengan benar, Anda memerlukan beberapa kode yang akan dieksekusi di utas GUI dari aplikasi (tidak dapat memikirkan hal lain yang disebut utas "utama"). Untuk ini ada metode di Activity:

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

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

Semoga ini yang Anda cari.

Ada cara sederhana lain, jika Anda tidak memiliki akses ke Konteks.

1). Buat penangan dari looper utama:

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

2). Menerapkan antarmuka Runnable:

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

3). Poskan Runnable Anda ke uiHandler:

uiHandler.post(runnable);

Itu saja ;-) Bersenang-senang dengan utas, tapi jangan lupa untuk menyinkronkannya.

Jika Anda menjalankan kode dalam utas, mis. Lakukan penundaan beberapa tindakan, maka Anda perlu memohon runOnUiThreaddari konteksnya. Misalnya, jika kode Anda berada di dalam MainActivitykelas maka gunakan ini:

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

Jika metode Anda dapat dipanggil baik dari utas utama (UI) atau dari utas lainnya Anda perlu pemeriksaan seperti:

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

}

Blok kode terkondensasi adalah sebagai berikut:

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

Ini tidak termasuk meneruskan referensi Kegiatan atau referensi Aplikasi.

Kotlin Equivalent:

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

Versi Kotlin

Saat Anda melakukan suatu kegiatan , maka gunakan

runOnUiThread {
    //code that runs in main
}

Ketika Anda memiliki konteks aktivitas , mContext kemudian gunakan

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

Ketika Anda berada di suatu tempat di mana tidak ada konteks yang tersedia , maka gunakan

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

Cara paling sederhana terutama jika Anda tidak memiliki konteks, jika Anda menggunakan RxAndroid yang dapat Anda lakukan:

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

Kode Kotlin yang lebih tepat menggunakan handler:

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

Salah satu metode yang dapat saya pikirkan adalah ini:

1) Biarkan UI mengikat ke layanan.
2) Paparkan metode seperti di bawah ini oleh Binderyang mendaftarkan Anda Handler:

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

3) Di utas UI, panggil metode di atas setelah mengikat ke layanan:

mBinder.registerHandler(new Handler());

4) Gunakan pawang di utas Layanan untuk mengirim tugas Anda:

mHandler.post(runnable);

HandlerThread adalah pilihan yang lebih baik untuk Thread java normal di Android.

1. Buat HandlerThread dan mulai saja
2. Buat Handler dengan Looper dari HandlerThread:requestHandler
3. postsebuah Runnabletugas direquestHandler

Komunikasi dengan UI Thread dari HandlerThread

1. Buat Handlerdengan Looperutas utama: responseHandlerdan ganti handleMessagemetode
2. Di dalam Runnabletugas Thread lain ( HandlerThreaddalam hal ini), panggilan sendMessagediresponseHandler
3. sendMessageDoa hasil ini handleMessagedi responseHandler.
4. Dapatkan atribut dari Messagedan proses, perbarui UI

Contoh : Pembaruan TextViewdengan data yang diterima dari layanan web. Karena layanan web harus dijalankan pada utas non-UI, dibuat HandlerThreaduntuk Operasi Jaringan. Setelah Anda mendapatkan konten dari layanan web, kirim pesan ke penangan utas utama Anda (Utas UI) dan ituHandler akan menangani pesan dan perbarui UI.

Kode sampel:

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);

Artikel yang berguna:

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

android-looper-handler-handlerthread-i

Saya tahu ini adalah pertanyaan lama, tetapi saya menemukan thread utama satu-liner yang saya gunakan di Kotlin dan Java. Ini mungkin bukan solusi terbaik untuk layanan, tetapi untuk memanggil sesuatu yang akan mengubah UI di dalam sebuah fragmen, ini sangat sederhana dan jelas.

Jawa (8):

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

Kotlin:

this.runOnUiThread {
     //your main thread code
}

Ikuti metode ini. Dengan menggunakan cara ini, Anda cukup memperbarui UI dari utas latar belakang. runOnUiThread bekerja pada utas utama (UI). Saya pikir cuplikan kode ini tidak terlalu rumit dan mudah, terutama untuk pemula.

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();

                   }
                });
            }
        });

dalam hal layanan

buat handler di oncreate

 handler = new Handler();

lalu gunakan seperti ini

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

untuk Kotlin, Anda dapat menggunakan Anko corountines :

memperbarui

doAsync {
   ...
}

usang

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

Jadi yang paling berguna adalah melakukan semacam:

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()
        }
    }
}

Dan kemudian:

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

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

Ini juga dapat bekerja di kelas layanan tanpa masalah.

Dengan Kotlin, persis seperti ini di dalam fungsi apa pun:

runOnUiThread {
   // Do work..
}