JAVA: start() function di multithreading - Revision history

Onnowpurbo at 04:09, 15 May 2022

2022-05-15T04:09:57Z

Onnowpurbo at 04:03, 15 May 2022

2022-05-15T04:03:12Z

Onnowpurbo at 03:59, 15 May 2022

2022-05-15T03:59:28Z

Onnowpurbo at 03:54, 15 May 2022

2022-05-15T03:54:15Z

Onnowpurbo: Created page with "We have discussed that Java threads are typically created using one of the two methods : (1) Extending thread class. (2) Implementing Runnable In both the approaches, we overr..."

2022-05-09T04:44:02Z

Created page with "We have discussed that Java threads are typically created using one of the two methods : (1) Extending thread class. (2) Implementing Runnable In both the approaches, we overr..."

New page

We have discussed that Java threads are typically created using one of the two methods : (1) Extending thread class. (2) Implementing Runnable
In both the approaches, we override the run() function, but we start a thread by calling the start() function. So why don’t we directly call the overridden run() function? Why always the start function is called to execute a thread?
What happens when a function is called?
When a function is called the following operations take place:

The arguments are evaluated.
A new stack frame is pushed into the call stack.
Parameters are initialized.
Method body is executed.
Value is returned and current stack frame is popped from the call stack.
The purpose of start() is to create a separate call stack for the thread. A separate call stack is created by it, and then run() is called by JVM.
Let us see what happens if we don’t call start() and rather call run() directly. We have modified the first program discussed here.

// Java code to see that all threads are
// pushed on same stack if we use run()
// instead of start().
class ThreadTest extends Thread
{
public void run()
{
try
{
// Displaying the thread that is running
System.out.println ("Thread " +
Thread.currentThread().getId() +
" is running");

}
catch (Exception e)
{
// Throwing an exception
System.out.println ("Exception is caught");
}
}
}

// Main Class
public class Main
{
public static void main(String[] args)
{
int n = 8;
for (int i=0; i<n; i++)
{
ThreadTest object = new ThreadTest();

// start() is replaced with run() for
// seeing the purpose of start
object.run();
}
}
}
Output:

Thread 1 is running
Thread 1 is running
Thread 1 is running
Thread 1 is running
Thread 1 is running
Thread 1 is running
Thread 1 is running
Thread 1 is running
We can see from above output that we get same ids for all threads because we have directly called run(). The program that calls start() prints different ids (see this)

==Referensi==

* https://www.geeksforgeeks.org/start-function-multithreading-java/
* http://www.javatpoint.com/what-if-we-call-run()-method-directly
* http://www.leepoint.net/JavaBasics/methods/methods-25-calls.html

@@ Line 1: / Line 1: @@
-We have discussed that Java threads are typically created using one of the two methods :
+Kami telah membahas bahwa thread Java biasanya dibuat menggunakan salah satu dari dua (2) metode:
-* Extending thread class.
+* Extend thread class.
-* Implementing Runnable
+* Implement Runnable
-Kami telah membahas bahwa utas Java biasanya dibuat menggunakan salah satu dari dua metode:
+Dalam kedua pendekatan tersebut, kita override/menimpa fungsi run(), tetapi kita memulai sebuah thread dengan memanggil fungsi start(). Jadi mengapa kita tidak langsung memanggil fungsi run() yang ditimpa? Mengapa selalu fungsi start dipanggil untuk mengeksekusi thread?
 Apa yang terjadi jika suatu fungsi dipanggil?
 Ketika suatu fungsi dipanggil, operasi berikut terjadi:
 * Argumen dievaluasi.
-* Bingkai tumpukan baru didorong ke tumpukan panggilan.
+* frame stack baru didorong ke stack panggilan.
 * Parameter diinisialisasi.
-* Tubuh metode dieksekusi.
+* Tubuh method dieksekusi.
-* Nilai dikembalikan dan bingkai tumpukan saat ini muncul dari tumpukan panggilan.
+* Nilai dikembalikan dan frame stack saat ini di pop dari call stack.
-Let us see what happens if we don’t call start() and rather call run() directly. We have modified the first program discussed here.
+Tujuan dari start() adalah untuk membuat call stack terpisah untuk thread. Call Stack terpisah dibuat olehnya, dan kemudian run() dipanggil oleh JVM.
 Mari kita lihat apa yang terjadi jika kita tidak memanggil start() dan memanggil run() secara langsung. Kami telah memodifikasi program pertama yang dibahas di sini.
@@ Line 93: / Line 70: @@
   Thread 1 is running
-We can see from above output that we get same ids for all threads because we have directly called run(). The program that calls start() prints different ids (see this)
+Kita dapat melihat dari output di atas bahwa kita mendapatkan id yang sama untuk semua thread karena kita telah memanggil run() secara langsung. Program yang memanggil start() mencetak id yang berbeda

@@ Line 2: / Line 2: @@
 * Extending thread class.
 * Implementing Runnable
 In both the approaches, we override the run() function, but we start a thread by calling the start() function. So why don’t we directly call the overridden run() function? Why always the start function is called to execute a thread?
 What happens when a function is called?
@@ Line 12: / Line 21: @@
 * Method body is executed.
 * Value is returned and current stack frame is popped from the call stack.
 Apa yang terjadi jika suatu fungsi dipanggil?
@@ Line 34: / Line 29: @@
 * Tubuh metode dieksekusi.
 * Nilai dikembalikan dan bingkai tumpukan saat ini muncul dari tumpukan panggilan.
 Tujuan dari start() adalah untuk membuat tumpukan panggilan terpisah untuk utas. Tumpukan panggilan terpisah dibuat olehnya, dan kemudian run() dipanggil oleh JVM.
 Mari kita lihat apa yang terjadi jika kita tidak memanggil start() dan memanggil run() secara langsung. Kami telah memodifikasi program pertama yang dibahas di sini.
@@ Line 93: / Line 94: @@
 We can see from above output that we get same ids for all threads because we have directly called run(). The program that calls start() prints different ids (see this)
 Kita dapat melihat dari output di atas bahwa kita mendapatkan id yang sama untuk semua utas karena kita telah memanggil run() secara langsung. Program yang memanggil start() mencetak id yang berbeda (lihat ini)

← Older revision		Revision as of 03:59, 15 May 2022
Line 17:		Line 17:
	Let us see what happens if we don’t call start() and rather call run() directly. We have modified the first program discussed here.		Let us see what happens if we don’t call start() and rather call run() directly. We have modified the first program discussed here.

		+
		+
		+
		+
		+	Kami telah membahas bahwa utas Java biasanya dibuat menggunakan salah satu dari dua metode:
		+	* Memperluas kelas benang.
		+	* Menerapkan Runnable
		+
		+	Dalam kedua pendekatan tersebut, kita menimpa fungsi run(), tetapi kita memulai sebuah thread dengan memanggil fungsi start(). Jadi mengapa kita tidak langsung memanggil fungsi run() yang ditimpa? Mengapa selalu fungsi start dipanggil untuk mengeksekusi utas?
		+
		+	Apa yang terjadi jika suatu fungsi dipanggil?
		+	Ketika suatu fungsi dipanggil, operasi berikut terjadi:
		+	* Argumen dievaluasi.
		+	* Bingkai tumpukan baru didorong ke tumpukan panggilan.
		+	* Parameter diinisialisasi.
		+	* Tubuh metode dieksekusi.
		+	* Nilai dikembalikan dan bingkai tumpukan saat ini muncul dari tumpukan panggilan.
		+
		+	Tujuan dari start() adalah untuk membuat tumpukan panggilan terpisah untuk utas. Tumpukan panggilan terpisah dibuat olehnya, dan kemudian run() dipanggil oleh JVM.
		+
		+	Mari kita lihat apa yang terjadi jika kita tidak memanggil start() dan memanggil run() secara langsung. Kami telah memodifikasi program pertama yang dibahas di sini.
		+
		+

	// Java code to see that all threads are		// Java code to see that all threads are
Line 72:		Line 95:


		+	Kita dapat melihat dari output di atas bahwa kita mendapatkan id yang sama untuk semua utas karena kita telah memanggil run() secara langsung. Program yang memanggil start() mencetak id yang berbeda (lihat ini)