Bu iş parçacığı birleştirme kodu ne anlama geliyor?

Bu kodda, iki birleşim ve kopma ne anlama geliyor? sona erene kadar durma t1.join()nedenleri ?t2t1

Thread t1 = new Thread(new EventThread("e1"));
t1.start();
Thread t2 = new Thread(new EventThread("e2"));
t2.start();
while (true) {
   try {
      t1.join();
      t2.join();
      break;
   } catch (InterruptedException e) {
      e.printStackTrace();
   }
}

Bu iş parçacığı birleştirme kodu ne anlama geliyor?

Dan alıntı Thread.join()yöntem javadocs :

join() Bu ipliğin ölmesini bekler.

Muhtemelen ana iş parçacığı olan örnek kodunuzu çalıştıran bir iş parçacığı vardır .

1. Ana iş parçacığı oluşturur ve başlatır t1ve t2konuları. İki iplik paralel olarak çalışmaya başlar.
2. Ana iş parçacığı t1.join(), t1iş parçacığının bitmesini beklemek için çağırır .
3. İş t1parçacığı tamamlanır ve t1.join()yöntem ana iş parçacığında döner. Çağrı yapılmadan t1önce bitmiş olabileceğini unutmayın; join()bu durumda join()çağrı hemen geri döner.
4. Ana iş parçacığı t2.join(), t2iş parçacığının bitmesini beklemek için çağırır .
5. İş t2parçacığı tamamlanır (veya iş parçacığı tamamlanmadan önce tamamlanmış olabilir t1) ve t2.join()yöntem ana iş parçacığında geri döner.

t1Ve t2iş parçacıklarının paralel çalıştığını anlamak önemlidir, ancak onları başlatan ana iş parçacığının devam etmeden önce bitirmelerini beklemeleri gerekir. Bu yaygın bir örüntü. Ayrıca t1ve / veya ana iş parçacığı onları t2çağırmadan önce bitirmiş olabilir join(). Eğer öyleyse o join()zaman beklemeyecek ama hemen geri dönecektir.

t1.join() t1 sona erene kadar t2'nin durmasına neden olur?

Hayır. Arayan ana iş parçacığı t1.join()çalışmayı durdurur ve t1iş parçacığının bitmesini bekler . İş t2parçacığı paralel olarak çalışıyor ve çağrıdan t1veya t1.join()çağrıdan etkilenmiyor .

Try / catch açısından, join()atar InterruptedExceptionçağırıyor ana iş parçacığı anlamına join()may kendisini başka bir iş parçacığı tarafından kesilebilir.

while (true) {

Birleşimlerin bir whiledöngü içinde olması garip bir kalıptır. Tipik olarak InterruptedExceptionher durumda uygun bir şekilde işleyen ilk birleştirmeyi ve sonra ikinci birleştirmeyi yaparsınız . Onları bir döngüye sokmaya gerek yok.

Bu favori bir Java röportaj sorusudur.

Thread t1 = new Thread(new EventThread("e1"));
t1.start();
Thread e2 = new Thread(new EventThread("e2"));
t2.start();

while (true) {
    try {
        t1.join(); // 1
        t2.join(); // 2  These lines (1,2) are in in public static void main
        break;
    }
}

t1.join()yani, t1 " Önce bitirmek istiyorum" gibi bir şey söylüyor . Aynı durum t2. Ne olursa olsun kimin başlattığını t1veya t2(bu durumda iplik mainyöntemi), ana dek bekleyecek t1ve t2görevlerini bitirmek.

Ancak, önemli bir nokta not etmek, t1ve t2kendileri bakılmaksızın paralel olarak çalıştırmak çağrı dizisi katılabilir üzerinde t1ve t2. Beklemek zorunda olan main/daemoniş parçacığıdır .

join()bir iş parçacığının tamamlanmasını beklemek anlamına gelir. Bu bir engelleyici yöntemdir. Ana iş parçanız (bunu yapan join()) işini t1.join()bitirene kadar hatta bekler t1ve sonra da aynısını yapar t2.join().

Bir resim bin kelime değerinde bir olup.

    Main thread-->----->--->-->--block##########continue--->---->
                 \                 |               |
sub thread start()\                | join()        |
                   \               |               |
                    ---sub thread----->--->--->--finish    

Faydalı olmak dileğiyle, daha fazla ayrıntı için buraya tıklayın

TA çağrısı tB.join () çağrısının nedenleri, yalnızca tB'nin ölmesini beklemekle kalmaz veya tA kendi kendine kesilmez, aynı zamanda tB'deki son ifade ile tA iş parçacığında tB.join () öğesinden sonraki bir sonraki ifade arasında gerçekleşir.

Bir iş parçacığındaki tüm eylemler, başka bir iş parçacığı o iş parçasındaki bir join () öğesinden başarıyla geri dönmeden önce gerçekleşir.

Program demek

class App {
    // shared, not synchronized variable = bad practice
    static int sharedVar = 0;
    public static void main(String[] args) throws Exception {
        Thread threadB = new Thread(() -> {sharedVar = 1;});
        threadB.start();
        threadB.join();

        while (true) 
            System.out.print(sharedVar);
    }
}

Her zaman yazdır

>> 1111111111111111111111111 ...

Ama program

class App {
    // shared, not synchronized variable = bad practice
    static int sharedVar = 0;
    public static void main(String[] args) throws Exception {
        Thread threadB = new Thread(() -> {sharedVar = 1;});
        threadB.start();
        // threadB.join();  COMMENT JOIN

        while (true)
            System.out.print(sharedVar);
    }
}

Sadece yazdırabilir

>> 0000000000 ... 000000111111111111111111111111 ...

Fakat

>> 00000000000000000000000000000000000000000000 ... 

Her zaman sadece '0'.

Java Bellek Modeli, `` sharedVar '' ın yeni değerinin, ileti dizisinden önceki iş parçacığı olmadan ana iş parçacığına 'aktarılmasını gerektirmez (iş parçacığı başlatma, iş parçacığı birleşimi,' eşzamanlı 'anahtar sözcük kullanımı, AtomicXXX değişkenlerinin kullanımı, vb.).

Basitçe söylemek gerekirse:
t1.join()İade t1tamamlandıktan sonra döner .
İpliğin t1bitmesini beklemek dışında hiçbir şey yapmaz .
Doğal olarak, aşağıdaki kod t1.join()ancak iadelerden sonra yürütülecektir t1.join().

Katılanlar üzerindeki oracle dokümantasyon sayfasından

joinYöntem bir iplik bir tamamlanmasını beklemek sağlar.

T1, Threadiş parçacığı yürütülmekte olan bir nesne ise,

t1.join() : causes the current thread to pause execution until t1's thread terminates.

T2, Threadiş parçacığı yürütülmekte olan bir nesne ise,

t2.join(); causes the current thread to pause execution until t2's thread terminates.

joinAPI, java'nın önceki sürümlerinde tanıtılan düşük düzeyli API'dir. Eşzamanlılık cephesinde belirli bir süre (özellikle jdk 1.5 sürümünde) birçok şey değişti.

Aynısını java.util.concurrent API ile elde edebilirsiniz. Bazı örnekler

1. İnvokeAll özelliğini kullanmaExecutorService
2. CountDownLatch kullanma
3. ForkJoinPool veya newWorkStealingPool of kullanma Executors(java 8'den beri)

İlgili SE sorularına bakın:

tüm iş parçacığı java çalışmalarını bitirmek

Benim için Join () davranışı her zaman kafa karıştırıcıydı çünkü kimin kimin bekleyeceğini hatırlamaya çalışıyordum. Bunu bu şekilde hatırlamaya çalışmayın.

Altında, saf wait () ve notify () mekanizmasıdır.

Hepimiz biliyoruz ki, herhangi bir nesne (t1) üzerinde wait () öğesini çağırdığımızda, çağrı nesnesi (main) bekleme odasına (Engellenen durum) gönderilir.

Burada, ana iş parçacığı altında wait () olan join () çağırıyor. Böylece ana iş parçacığı bildirilene kadar bekleyecektir. Bildirim, çalışmasını bitirdiğinde t1 tarafından verilir (iş parçacığı tamamlama).

Bildirimi aldıktan sonra, ana bekleme odasından çıkar ve yürütme işlemine devam eder.

Umarım yardımcı olur!

package join;

public class ThreadJoinApp {

    Thread th = new Thread("Thread 1") {
        public void run() {
            System.out.println("Current thread execution - " + Thread.currentThread().getName());
            for (int i = 0; i < 10; i++) {
                System.out.println("Current thread execution - " + Thread.currentThread().getName() + " at index - " + i);
            }
        }
    };

    Thread th2 = new Thread("Thread 2") {
        public void run() {
            System.out.println("Current thread execution - " + Thread.currentThread().getName());

            //Thread 2 waits until the thread 1 successfully completes.
            try {
            th.join();
            } catch( InterruptedException ex) {
                System.out.println("Exception has been caught");
            }

            for (int i = 0; i < 10; i++) {
                System.out.println("Current thread execution - " + Thread.currentThread().getName() + " at index - " + i);
            }
        }
    };

    public static void main(String[] args) {
        ThreadJoinApp threadJoinApp = new ThreadJoinApp();
        threadJoinApp.th.start();
        threadJoinApp.th2.start();
    }

    //Happy coding -- Parthasarathy S
}

diyelim ki ana iş parçacığımız t1 ve t2 ipliklerini başlatıyor. Şimdi, t1.join () çağrıldığında, ana iplik t1 teli ölünceye kadar kendini askıya alır ve sonra kendini sürdürür. Benzer şekilde, t2.join () yürütüldüğünde, ana iplik t2 ipliği ölene ve devam edene kadar kendini yeniden askıya alır.

İşte böyle çalışır.

Ayrıca while döngüsü burada gerçekten gerekli değildi.