Kapan Anda memanggil thread.run () java sebagai ganti thread.start ()?

Kapan Anda akan menelepon Java, thread.run()bukan thread.start()?

Anda mungkin ingin memanggil run () dalam pengujian unit tertentu yang hanya berkaitan dengan fungsionalitas dan bukan dengan konkurensi.

Tidak pernah. Memanggil run () secara langsung hanya menjalankan kode secara sinkron (di utas yang sama), seperti panggilan metode normal.

Diambil dari FAQ utas Java Gaya Kode :

T: Apa perbedaan antara metode start () dan run () thread?

J: Metode start () dan run () yang terpisah di kelas Thread menyediakan dua cara untuk membuat program berulir. Metode start () memulai eksekusi utas baru dan memanggil metode run (). Metode start () segera kembali dan utas baru biasanya berlanjut hingga metode run () kembali.

Metode run () kelas Thread tidak melakukan apa pun, jadi sub-kelas harus mengganti metode dengan kode untuk dieksekusi di thread kedua. Jika Thread dibuat dengan argumen Runnable, metode run () thread akan mengeksekusi metode run () dari objek Runnable di thread baru.

Bergantung pada sifat program berulir Anda, memanggil metode Thread run () secara langsung dapat memberikan keluaran yang sama seperti memanggil melalui metode start (), tetapi dalam kasus terakhir, kode tersebut sebenarnya dieksekusi di utas baru.

Menjalankan thread.run()tidak membuat yang baru Threaddi mana kode Anda dieksekusi. Itu hanya mengeksekusi kode di Thread saat ini dari manathread.run() kode tersebut dipanggil.

Eksekusi thread.start()membuat utas level OS baru tempat run()metode dipanggil.

Intinya:

Pemrograman Berulir Tunggal → Memanggil run()metode secara langsung

Pemrograman Multi Threaded → Memanggil start()metode

Selain itu, seperti yang disebutkan orang lain, 'pengujian' tampaknya menjadi satu-satunya kasus yang disarankan di mana Anda dapat memanggil run()langsung dari kode Anda.

Ini telah disinggung, tetapi hanya untuk memperjelas: membuat objek Thread baru hanya untuk memanggil metode run () itu tidak perlu mahal dan harus menjadi bendera merah utama. Ini akan menjadi desain yang jauh lebih baik, lebih dipisahkan untuk membuat impl Runnable dan baik (a) menyebutnya itu metode run () secara langsung kalau itu perilaku yang diinginkan, atau (b) membangun Thread baru dengan yang Runnable dan mulai Thread tersebut.

Lebih baik lagi, untuk lebih banyak pemisahan, lihat Executorantarmuka dan kerangka kerja di JDK 5 dan yang lebih baru. Ini memungkinkan Anda, secara singkat, untuk memisahkan eksekusi tugas (contoh Runnable) dari bagaimana itu dijalankan (implementasi Executor, yang mungkin mengeksekusi Runnable di Thread saat ini, di Thread baru, menggunakan Thread yang ada dari kumpulan, dan apa tidak).

Panggilan thread.start(), itu pada gilirannya akan menelepon thread.run(). Tidak dapat memikirkan kasus ketika Anda ingin melewati thread.start()dan langsung pergithread.run()

Pemisahan start()dan run()metode di kelas Thread menyediakan dua cara untuk membuat program berulir. The start()metode dimulai eksekusi thread baru dan memanggil run()metode. The start()Metode segera kembali dan thread baru biasanya berlanjut sampai run()kembali metode.

Metode kelas Thread run()tidak melakukan apa-apa, jadi sub-kelas harus mengganti metode dengan kode yang akan dijalankan di thread kedua. Jika Thread dibuat dengan argumen Runnable, metode thread akan run()mengeksekusi run()metode objek Runnable di thread baru.

Bergantung pada sifat program berulir Anda, memanggil run()metode Thread secara langsung dapat memberikan keluaran yang sama seperti pemanggilan melalui start()metode, tetapi dalam kasus terakhir, kode tersebut sebenarnya dieksekusi di thread baru.

referensi

Jika Pertanyaannya adalah - "mengapa metode mulai thread dipanggil alih-alih metode jalankan secara langsung" maka saya telah menjawab dengan contoh kode di bawah ini. Harapan yang menjelaskan. Pada Contoh di bawah ini:

/*
By calling t1.start(), 
we are getting the main calling thread returned immediately 
after the t1.start() called and is ready to proceed for other 
operations.And the thread t1 starts executing the run method of the object r. 
Hence the the output will be:

      I am the main thread , i created thread t1 and had it execute run method, which is currently looping from 0 to 1000000

      I am done executing run method of testThread

*/


/* If we call t1.run() instead of t1.start(), (just replace t1.start() with t1.run() in the code for testing)
 its like a regular method call and the main thread will not return until the run method completes, 
 hence the output will be:

         I am done executing run method of testThread

         I am the main thread , i created thread t1 and had it execute run method, which is currently looping for i to 1000000

*/


class testThread implements Runnable{

 public void run()
 {
     for(int i=0;i<1000000;i++){} //a simple delay block to clarify.

     System.out.println("I am done executing run method of testThread");

 }  
}

public class mainClass{

   public static void main(String [] args)
    {
          testThread r = new testThread();
          Thread t1 = new Thread(r);
          t1.start();  /* Question is: can we call instead t1.run() */  
          System.out.println("I am the main thread , i created thread t1 and had it execute run method, which is currently looping for i to 1000000");

    }
}

Saat Anda ingin menjalankannya secara sinkron. Memanggil metode run tidak akan benar-benar memberi Anda multi-threading. Metode start membuat thread baru yang memanggil metode run.

Jika Anda ingin mengeksekusi konten run () seperti yang Anda lakukan dengan metode lain. Bukan untuk memulai utas, tentu saja.

Dengan asumsi bahwa Anda mengetahui penggunaan metode start dan run yaitu sinkron vs. asinkron; metode run dapat digunakan hanya untuk menguji fungsionalitas.

Ditambah dalam beberapa keadaan, kelas utas yang sama dapat digunakan di dua tempat berbeda dengan persyaratan fungsionalitas sinkronisasi dan asinkron dengan memiliki dua objek berbeda dengan metode jalankan satu dan metode mulai lainnya yang dipanggil.

Setidaknya di JVM 1.6., Ada sedikit pemeriksaan dan menjalankan yang disebut secara native:

 public synchronized void start() {
        /**
     * This method is not invoked for the main method thread or "system"
     * group threads created/set up by the VM. Any new functionality added 
     * to this method in the future may have to also be added to the VM.
     *
     * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);
        start0();
        if (stopBeforeStart) {
        stop0(throwableFromStop);
    }
    }

    private native void start0();

Sekadar catatan untuk komentar bagus di atas: terkadang Anda menulis kode multi-utas yang menggunakan metode "mulai" untuk menjalankan utas yang berbeda. Anda akan merasa lebih mudah jika menggunakan "run" (daripada "start) untuk debugging karena ini membuat kode berjalan secara sinkron dan debugging jadi lebih mudah.

public class TestClass implements Runnable {
    public static void main(String[] args) {
        TestClass tc = new TestClass();

        Thread t1 = new Thread(tc);
        System.out.println("Before Starting Thread " + Thread.currentThread().hashCode());
        t1.start();
        System.out.println("After Starting Thread " + Thread.currentThread().hashCode());
    }

    @Override
    public void run() {
        System.out.println("TestClass Run method is  Running with thread " + Thread.currentThread().hashCode());        
    }
}