JAVA: Perbedaan antara Thread.start() dan Thread.run() - Revision history

Unknown user: /* Multiple invocation/panggilan: */

2022-05-18T08:17:45Z

Multiple invocation/panggilan:

← Older revision		Revision as of 08:17, 18 May 2022
Line 135:		Line 135:
	\| Membuat thread baru dan method run() dijalankan pada thread yang baru dibuat. \|\| Tidak ada thread baru yang dibuat dan method run() dijalankan pada thread panggilan itu sendiri.		\| Membuat thread baru dan method run() dijalankan pada thread yang baru dibuat. \|\| Tidak ada thread baru yang dibuat dan method run() dijalankan pada thread panggilan itu sendiri.
	\|-		\|-
	\| Tidak dapat dipanggil lebih dari satu kali jika tidak, akan memunculkan java.lang.IllegalStateException \|\| ~~Beberapa permintaan dimungkinkan~~		\| Tidak dapat dipanggil lebih dari satu kali jika tidak, akan memunculkan java.lang.IllegalStateException \|\| Dimungkinkan di panggilan beberapa kali
	\|-		\|-
	\| Didefinisikan dalam Class java.lang.Thread. \|\| Didefinisikan dalam interface java.lang.Runnable dan harus diganti di Class implementasi.		\| Didefinisikan dalam Class java.lang.Thread. \|\| Didefinisikan dalam interface java.lang.Runnable dan harus diganti di Class implementasi.

Unknown user: /* Multiple invocation: */

2022-05-18T08:16:59Z

Multiple invocation:

← Older revision		Revision as of 08:16, 18 May 2022
Line 60:		Line 60:


	==Multiple invocation:==		==Multiple invocation/panggilan:==

	Dalam konsep multi-threading Java, perbedaan terpenting lainnya antara method start() dan run() adalah bahwa kita tidak dapat memanggil method start() dua kali jika tidak, metode ini akan mengeluarkan IllegalStateException sedangkan method run() dapat dipanggil beberapa kali sebagai itu hanya pemanggilan method biasa.		Dalam konsep multi-threading Java, perbedaan terpenting lainnya antara method start() dan run() adalah bahwa kita tidak dapat memanggil method start() dua kali jika tidak, metode ini akan mengeluarkan IllegalStateException sedangkan method run() dapat dipanggil beberapa kali sebagai itu hanya pemanggilan method biasa.
Line 133:		Line 133:
	! start() !! run()		! start() !! run()
	\|-		\|-
	\| ~~Creates a new~~ thread ~~and the~~ run() ~~method is executed on the newly created~~ thread. \|\| ~~No new~~ thread ~~is created and the~~ run() ~~method is executed on the calling~~ thread ~~itself~~.		\| Membuat thread baru dan method run() dijalankan pada thread yang baru dibuat. \|\| Tidak ada thread baru yang dibuat dan method run() dijalankan pada thread panggilan itu sendiri.
	\|-		\|-
	\| ~~Can’t be invoked more than one time otherwise throws~~ java.lang.IllegalStateException \|\| ~~Multiple invocation is possible~~		\| Tidak dapat dipanggil lebih dari satu kali jika tidak, akan memunculkan java.lang.IllegalStateException \|\| Beberapa permintaan dimungkinkan
	\|-		\|-
	\| ~~Defined in~~ java.lang.Thread ~~class~~. \|\| ~~Defined in~~ java.lang.Runnable ~~interface and must be overriden in the implementing class~~.		\| Didefinisikan dalam Class java.lang.Thread. \|\| Didefinisikan dalam interface java.lang.Runnable dan harus diganti di Class implementasi.
	\|}		\|}







	~~{\| kelas="dapat dibaca"~~
	~~\|+ Ringkasan~~
	\|-
	~~! Mulailah() !! Lari()~~
	\|-
	~~\| Membuat utas baru dan metode run() dijalankan pada utas yang baru dibuat. \|\| Tidak ada utas baru yang dibuat dan metode run() dijalankan pada utas panggilan itu sendiri.~~
	\|-
	~~\| Tidak dapat dipanggil lebih dari satu kali jika tidak, akan memunculkan java.lang.IllegalStateException \|\| Beberapa permintaan dimungkinkan~~
	\|-
	~~\| Didefinisikan dalam kelas java.lang.Thread. \|\| Didefinisikan dalam antarmuka java.lang.Runnable dan harus diganti di kelas implementasi.~~
	\|\|

	==Referensi==		==Referensi==

	* https://www.geeksforgeeks.org/difference-between-thread-start-and-thread-run-in-java/		* https://www.geeksforgeeks.org/difference-between-thread-start-and-thread-run-in-java/

Unknown user: /* Multiple invocation: */

2022-05-18T02:57:21Z

Multiple invocation:

← Older revision		Revision as of 02:57, 18 May 2022
Line 62:		Line 62:
	==Multiple invocation:==		==Multiple invocation:==

	In Java’s multi-threading concept, another most important difference between start() and run() method is that we can’t call the start() method twice otherwise it will throw an IllegalStateException whereas run() method can be called multiple times as it is just a normal method calling.		Dalam konsep multi-threading Java, perbedaan terpenting lainnya antara method start() dan run() adalah bahwa kita tidak dapat memanggil method start() dua kali jika tidak, metode ini akan mengeluarkan IllegalStateException sedangkan method run() dapat dipanggil beberapa kali sebagai itu hanya pemanggilan method biasa.

	~~Let us understand it with an example:~~

	Dalam konsep multi-threading Java, perbedaan terpenting lainnya antara ~~metode~~ start() dan run() adalah bahwa kita tidak dapat memanggil ~~metode~~ start() dua kali jika tidak, metode ini akan mengeluarkan IllegalStateException sedangkan ~~metode~~ run() dapat dipanggil beberapa kali sebagai itu hanya pemanggilan ~~metode~~ biasa.

	Mari kita pahami dengan sebuah contoh:		Mari kita pahami dengan sebuah contoh:
Line 99:		Line 95:
	at GeeksforGeeks.main(File.java:11)		at GeeksforGeeks.main(File.java:11)

	~~As we can see in the above example, calling start() method again raises java.lang.IllegalThreadStateException.~~		Seperti yang dapat kita lihat pada contoh di atas, memanggil method start() kembali memunculkan java.lang.IllegalThreadStateException.

	~~Now, let us try to call run() method twice:~~

	Seperti yang dapat kita lihat pada contoh di atas, memanggil ~~metode~~ start() kembali memunculkan java.lang.IllegalThreadStateException.

	Sekarang, mari kita coba memanggil metode run() dua kali:		Sekarang, mari kita coba memanggil metode run() dua kali:
Line 133:		Line 125:
	run() method called		run() method called

	~~As we can see in the above example~~, ~~calling run()~~ method ~~twice doesn’t raise any exception and it is executed twice as expected but on the main thread itself.~~		Seperti yang dapat kita lihat pada contoh di atas, memanggil method run() dua kali tidak menimbulkan exception apa pun dan dijalankan dua kali seperti yang diharapkan tetapi pada main thread itu sendiri.


	~~As we can see in the above example, calling~~ run() ~~method twice doesn’t raise any~~ exception ~~and it is executed twice as expected but on the~~ main thread ~~itself~~.


Line 168:		Line 157:
	\| Didefinisikan dalam kelas java.lang.Thread. \|\| Didefinisikan dalam antarmuka java.lang.Runnable dan harus diganti di kelas implementasi.		\| Didefinisikan dalam kelas java.lang.Thread. \|\| Didefinisikan dalam antarmuka java.lang.Runnable dan harus diganti di kelas implementasi.
	\|\|		\|\|




	==Referensi==		==Referensi==

	* https://www.geeksforgeeks.org/difference-between-thread-start-and-thread-run-in-java/		* https://www.geeksforgeeks.org/difference-between-thread-start-and-thread-run-in-java/

Unknown user at 02:54, 18 May 2022

2022-05-18T02:54:31Z

← Older revision		Revision as of 02:54, 18 May 2022
Line 1:		Line 1:
	~~In Java’s~~ multi-threading ~~concept~~, start() ~~and~~ run() ~~are the two most important methods~~. ~~Below are some of the differences between the~~ Thread.start() ~~and~~ Thread.run() ~~methods~~:		Dalam konsep multi-threading Java, start() dan run() adalah dua method yang paling penting. Berikut adalah beberapa perbedaan antara metode Thread.start() dan Thread.run():

	~~Dalam konsep multi-threading Java, start() dan run() adalah dua metode yang paling penting. Berikut adalah beberapa perbedaan antara metode Thread.start() dan Thread.run():~~

			==Pembuatan New Thread:==

	~~==New Thread creation:==~~		Ketika sebuah program memanggil method start(), sebuah thread baru dibuat dan kemudian method run() dijalankan. Tetapi jika kita secara langsung memanggil method run() maka tidak ada thread baru yang akan dibuat dan method run() akan dieksekusi sebagai pemanggilan method normal pada thread panggilan saat ini itu sendiri dan tidak ada multi-threading yang akan terjadi.

	When a program calls the start() method, a new thread is created and then the run() method is executed. But if we directly call the run() method then no new thread will be created and run() method will be executed as a normal method call on the current calling thread itself and no multi-threading will take place.
	~~Let us understand it with an example:~~

	Ketika sebuah program memanggil metode start(), sebuah thread baru dibuat dan kemudian metode run() dijalankan. Tetapi jika kita secara langsung memanggil metode run() maka tidak ada utas baru yang akan dibuat dan metode run() akan dieksekusi sebagai pemanggilan metode normal pada utas panggilan saat ini itu sendiri dan tidak ada multi-threading yang akan terjadi.
	Mari kita pahami dengan sebuah contoh:		Mari kita pahami dengan sebuah contoh:

Line 34:		Line 30:
	run() method called		run() method called

	As we can see in the above example, when we call the start() method of our thread class instance, a new thread is created with default name Thread-0 and then run() method is called and everything inside it is executed on the newly created thread.		Seperti yang dapat kita lihat pada contoh di atas, ketika kita memanggil method start() dari instance class thread kita, thread baru dibuat dengan nama default Thread-0 dan kemudian method run() dipanggil dan semua yang ada di dalamnya dieksekusi pada thread yang baru dibuat.

	~~Now, let us try to call run() method directly instead of start() method:~~
	Seperti yang dapat kita lihat pada contoh di atas, ketika kita memanggil ~~metode~~ start() dari instance ~~kelas utas~~ kita, ~~utas~~ baru dibuat dengan nama default Thread-0 dan kemudian ~~metode~~ run() dipanggil dan semua yang ada di dalamnya dieksekusi pada ~~utas~~ yang baru dibuat.

	~~Sekarang, mari kita coba memanggil metode run() secara langsung alih-alih metode start():~~

			Sekarang, mari kita coba memanggil method run() secara langsung bukan method start():


Line 65:		Line 57:
	run() method called		run() method called

	As we can see in the above example, when we called the run() method of our MyThread class, no new thread is created and the run() method is executed on the current thread i.e. main thread. Hence, no multi-threading took place. The run() method is called as a normal function call.		Seperti yang dapat kita lihat pada contoh di atas, ketika kita memanggil method run() dari class MyThread kita, tidak ada thread baru yang dibuat dan method run() dijalankan pada thread saat ini, yaitu main thread. Oleh karena itu, tidak ada multi-threading yang terjadi. Metode run() dipanggil sebagai pemanggilan fungsi normal.

	Seperti yang dapat kita lihat pada contoh di atas, ketika kita memanggil ~~metode~~ run() dari ~~kelas~~ MyThread kita, tidak ada ~~utas~~ baru yang dibuat dan ~~metode~~ run() dijalankan pada ~~utas~~ saat ini, yaitu ~~utas utama~~. Oleh karena itu, tidak ada multi-threading yang terjadi. Metode run() dipanggil sebagai pemanggilan fungsi normal.

Unknown user at 06:12, 16 May 2022

2022-05-16T06:12:49Z

@@ Line 1: / Line 1: @@
 In Java’s multi-threading concept, start() and run() are the two most important methods. Below are some of the differences between the Thread.start() and Thread.run() methods:
 ==New Thread creation:==
@@ Line 5: / Line 8: @@
 When a program calls the start() method, a new thread is created and then the run() method is executed. But if we directly call the run() method then no new thread will be created and run() method will be executed as a normal method call on the current calling thread itself and no multi-threading will take place.
 Let us understand it with an example:
   class MyThread extends Thread {
@@ Line 30: / Line 37: @@
 Now, let us try to call run() method directly instead of start() method:
   class MyThread extends Thread {
@@ Line 54: / Line 66: @@
 As we can see in the above example, when we called the run() method of our MyThread class, no new thread is created and the run() method is executed on the current thread i.e. main thread. Hence, no multi-threading took place. The run() method is called as a normal function call.
 ==Multiple invocation:==
@@ Line 60: / Line 75: @@
 Let us understand it with an example:
   class MyThread extends Thread {
@@ Line 91: / Line 112: @@
 Now, let us try to call run() method twice:
@@ Line 116: / Line 142: @@
   Current thread name: main
   run() method called
 As we can see in the above example, calling run() method twice doesn’t raise any exception and it is executed twice as expected but on the main thread itself.
@@ Line 131: / Line 160: @@
 | Defined in java.lang.Thread class. || Defined in java.lang.Runnable interface and must be overriden in the implementing class.
 |}
 ==Referensi==
 * https://www.geeksforgeeks.org/difference-between-thread-start-and-thread-run-in-java/

Unknown user: /* Multiple invocation: */

2022-05-16T06:07:00Z

Multiple invocation:

@@ Line 119: / Line 119: @@
 As we can see in the above example, calling run() method twice doesn’t raise any exception and it is executed twice as expected but on the main thread itself.
 ==Referensi==
 * https://www.geeksforgeeks.org/difference-between-thread-start-and-thread-run-in-java/

Unknown user at 06:01, 16 May 2022

2022-05-16T06:01:29Z

Show changes

Unknown user: Created page with "In Java’s multi-threading concept, start() and run() are the two most important methods. Below are some of the differences between the Thread.start() and Thread.run() method..."

2022-05-15T04:24:20Z

Created page with "In Java’s multi-threading concept, start() and run() are the two most important methods. Below are some of the differences between the Thread.start() and Thread.run() method..."

New page

In Java’s multi-threading concept, start() and run() are the two most important methods. Below are some of the differences between the Thread.start() and Thread.run() methods:

New Thread creation: When a program calls the start() method, a new thread is created and then the run() method is executed. But if we directly call the run() method then no new thread will be created and run() method will be executed as a normal method call on the current calling thread itself and no multi-threading will take place.
Let us understand it with an example:

class MyThread extends Thread {
public void run()
{
System.out.println("Current thread name: "
+ Thread.currentThread().getName());
System.out.println("run() method called");
}
}

class GeeksforGeeks {
public static void main(String[] args)
{
MyThread t = new MyThread();
t.start();
}
}
Output:
Current thread name: Thread-0
run() method called
As we can see in the above example, when we call the start() method of our thread class instance, a new thread is created with default name Thread-0 and then run() method is called and everything inside it is executed on the newly created thread.
Now, let us try to call run() method directly instead of start() method:

class MyThread extends Thread {
public void run()
{
System.out.println("Current thread name: "
+ Thread.currentThread().getName());

System.out.println("run() method called");
}
}

class GeeksforGeeks {
public static void main(String[] args)
{
MyThread t = new MyThread();
t.run();
}
}
Output:
Current thread name: main
run() method called
As we can see in the above example, when we called the run() method of our MyThread class, no new thread is created and the run() method is executed on the current thread i.e. main thread. Hence, no multi-threading took place. The run() method is called as a normal function call.

Multiple invocation: In Java’s multi-threading concept, another most important difference between start() and run() method is that we can’t call the start() method twice otherwise it will throw an IllegalStateException whereas run() method can be called multiple times as it is just a normal method calling.
Let us understand it with an example:

class MyThread extends Thread {
public void run()
{
System.out.println("Current thread name: "
+ Thread.currentThread().getName());

System.out.println("run() method called");
}
}

class GeeksforGeeks {
public static void main(String[] args)
{
MyThread t = new MyThread();
t.start();
t.start();
}
}
Output:

Current thread name: Thread-0
run() method called
Exception in thread "main" java.lang.IllegalThreadStateException
at java.lang.Thread.start(Thread.java:708)
at GeeksforGeeks.main(File.java:11)
As we can see in the above example, calling start() method again raises java.lang.IllegalThreadStateException.
Now, let us try to call run() method twice:

class MyThread extends Thread {
public void run()
{
System.out.println("Current thread name: "
+ Thread.currentThread().getName());
System.out.println("run() method called");
}
}

class GeeksforGeeks {
public static void main(String[] args)
{
MyThread t = new MyThread();
t.run();
t.run();
}
}
Output:
Current thread name: main
run() method called
Current thread name: main
run() method called
As we can see in the above example, calling run() method twice doesn’t raise any exception and it is executed twice as expected but on the main thread itself.

Summary
start() run()
Creates a new thread and the run() method is executed on the newly created thread. No new thread is created and the run() method is executed on the calling thread itself.
Can’t be invoked more than one time otherwise throws java.lang.IllegalStateException Multiple invocation is possible
Defined in java.lang.Thread class. Defined in java.lang.Runnable interface and must be overriden in the implementing class.

==Referensi==

* https://www.geeksforgeeks.org/difference-between-thread-start-and-thread-run-in-java/