iPhone - Utas utama Grand Central Dispatch

Saya telah menggunakan dengan sukses, pengiriman grand central di aplikasi saya, tetapi saya bertanya-tanya apa keuntungan sebenarnya dari menggunakan sesuatu seperti ini:

dispatch_async(dispatch_get_main_queue(), ^{ ... do stuff

atau bahkan

dispatch_sync(dispatch_get_main_queue(), ^{ ... do stuff

Maksud saya, dalam kedua kasus Anda menembakkan blok yang akan dieksekusi pada utas utama, tepat di mana aplikasi berjalan dan ini tidak akan membantu mengurangi beban. Dalam kasus pertama, Anda tidak memiliki kontrol saat blok akan berjalan. Saya telah melihat kasus blok dieksekusi setengah detik setelah Anda memecat mereka. Kasus kedua, mirip dengan

[self doStuff];

Baik?

Aku ingin tahu apa yang kalian pikirkan.

Pengiriman blok ke antrian utama biasanya dilakukan dari antrian latar belakang untuk memberi sinyal bahwa beberapa pemrosesan latar belakang telah selesai misalnya

- (void)doCalculation
{
    //you can use any string instead "com.mycompany.myqueue"
    dispatch_queue_t backgroundQueue = dispatch_queue_create("com.mycompany.myqueue", 0);

    dispatch_async(backgroundQueue, ^{
        int result = <some really long calculation that takes seconds to complete>;

        dispatch_async(dispatch_get_main_queue(), ^{
            [self updateMyUIWithResult:result];
        });    
    });
}

Dalam hal ini, kami melakukan perhitungan panjang pada antrian latar belakang dan perlu memperbarui UI kami ketika perhitungan selesai. Memperbarui UI biasanya harus dilakukan dari antrian utama sehingga kami 'memberi sinyal' kembali ke antrian utama menggunakan dispatch_async bersarang kedua.

Mungkin ada contoh lain di mana Anda mungkin ingin mengirim kembali ke antrian utama tetapi umumnya dilakukan dengan cara ini yaitu bersarang dari dalam blok yang dikirim ke antrian latar belakang.

• pemrosesan latar belakang selesai -> perbarui UI
• potongan data diproses pada antrian latar belakang -> sinyal antrian utama untuk memulai potongan berikutnya
• data jaringan yang masuk pada antrian latar belakang -> sinyal antrian utama bahwa pesan telah tiba
• dll

Mengenai mengapa Anda mungkin ingin mengirim ke antrian utama dari antrian utama ... Yah, Anda biasanya tidak akan berpikir bahwa Anda mungkin melakukannya untuk menjadwalkan beberapa pekerjaan yang akan dilakukan di putaran run loop berikutnya.

Mengirim blok ke antrian utama dari can utama bermanfaat. Ini memberi antrian utama peluang untuk menangani blok lain yang telah di-antri sehingga Anda tidak hanya memblokir segala sesuatu yang lain dari eksekusi.

Misalnya, Anda dapat menulis server ulir tunggal yang pada dasarnya menangani banyak koneksi bersamaan. Selama tidak ada blok individual dalam antrian yang terlalu lama server tetap responsif terhadap permintaan baru.

Jika program Anda tidak melakukan apa pun kecuali menghabiskan seluruh hidupnya untuk merespons berbagai peristiwa, maka ini bisa sangat wajar. Anda cukup mengatur handler acara Anda untuk berjalan di antrian utama dan kemudian memanggil dispatch_main (), dan Anda mungkin tidak perlu khawatir tentang keamanan utas sama sekali.

Semoga saya memahami pertanyaan Anda dengan benar karena Anda bertanya-tanya tentang perbedaan antara dispatch_async dan dispatch_sync?

dispatch_async

akan mengirimkan blok ke antrian secara tidak sinkron. Berarti itu akan mengirim blok ke antrian dan tidak menunggu untuk kembali sebelum melanjutkan eksekusi kode yang tersisa dalam metode Anda.

dispatch_sync

akan mengirim blok ke antrian secara serempak. Ini akan mencegah eksekusi kode yang tersisa dalam metode sampai blok selesai dieksekusi.

Saya sebagian besar menggunakan dispatch_asyncantrian latar belakang untuk mulai bekerja dari antrian utama dan memanfaatkan setiap core tambahan yang mungkin dimiliki perangkat. Kemudiandispatch_async ke utas utama jika saya perlu memperbarui UI.

Semoga berhasil

Satu tempat yang bermanfaat adalah untuk aktivitas UI, seperti mengatur pemintal sebelum operasi yang panjang:

- (void) handleDoSomethingButton{

    [mySpinner startAnimating];

    (do something lengthy)
    [mySpinner stopAnimating];
}

tidak akan berfungsi, karena Anda memblokir utas selama hal panjang Anda dan tidak membiarkan UIKit benar-benar memulai pemintal.

- (void) handleDoSomethingButton{
     [mySpinner startAnimating];

     dispatch_async (dispatch_get_main_queue(), ^{
          (do something lengthy)
          [mySpinner stopAnimating];
    });
}

akan mengembalikan kontrol ke run loop, yang akan menjadwalkan pembaruan UI, memulai pemintal, kemudian akan mendapatkan hal berikutnya dari antrian pengiriman, yang merupakan pemrosesan aktual Anda. Ketika pemrosesan Anda selesai, animasi berhenti dipanggil, dan Anda kembali ke loop dijalankan, di mana UI kemudian diperbarui dengan berhenti.

Swift 3, 4 & 5

Menjalankan kode di utas utama

DispatchQueue.main.async {
    // Your code here
}

Async berarti asinkron dan Anda harus sering menggunakannya. Anda seharusnya tidak pernah memanggil sinkronisasi pada utas utama karena itu akan mengunci UI Anda sampai tugas selesai. Anda di sini adalah cara yang lebih baik untuk melakukan ini di Swift:

runThisInMainThread { () -> Void in
    // Run your code like this:
    self.doStuff()
}

func runThisInMainThread(block: dispatch_block_t) {
    dispatch_async(dispatch_get_main_queue(), block)
}

Termasuk dalam fungsi standar dalam repo saya, lihat: https://github.com/goktugyil/EZSwiftExtensions