JAVA: Multithreading - Revision history

Unknown user: /* Create Thread dengan cara meng-extend Thread class */

2022-05-12T00:26:05Z

Create Thread dengan cara meng-extend Thread class

← Older revision		Revision as of 00:26, 12 May 2022
Line 8:		Line 8:
	==Create Thread dengan cara meng-extend Thread class==		==Create Thread dengan cara meng-extend Thread class==

	~~Kami~~ membuat Class yang memperluas Class java.lang.Thread. Class ini override method run() yang tersedia di Class Thread. Sebuah Thread memulai kehidupannya di dalam method run(). Kita membuat object Class baru dan memanggil metode start() untuk memulai eksekusi Thread. Start() memanggil metode run() pada object Thread.		Kita membuat Class yang memperluas Class java.lang.Thread. Class ini override method run() yang tersedia di Class Thread. Sebuah Thread memulai kehidupannya di dalam method run(). Kita membuat object Class baru dan memanggil metode start() untuk memulai eksekusi Thread. Start() memanggil metode run() pada object Thread.


	// Java code for thread creation by extending		// Java code for thread creation by extending
Line 51:		Line 50:
	Thread 18 is running		Thread 18 is running
	Thread 17 is running		Thread 17 is running


	==Creat Thread dengan cara meng-implementasi Runnable Interface==		==Creat Thread dengan cara meng-implementasi Runnable Interface==

Unknown user: /* Creat Thread dengan cara meng-implementasi Runnable Interface */

2022-05-11T23:53:49Z

Creat Thread dengan cara meng-implementasi Runnable Interface

← Older revision		Revision as of 23:53, 11 May 2022
Line 56:		Line 56:

	Kita membuat Class baru yang mengimplementasikan java.lang.Runnable interface dan override method run(). Kemudian kita membuat instance objek Thread dan memanggil method start() pada object ini.		Kita membuat Class baru yang mengimplementasikan java.lang.Runnable interface dan override method run(). Kemudian kita membuat instance objek Thread dan memanggil method start() pada object ini.


	// Java code for thread creation by implementing		// Java code for thread creation by implementing

Unknown user at 23:53, 11 May 2022

2022-05-11T23:53:35Z

← Older revision		Revision as of 23:53, 11 May 2022
Line 1:		Line 1:
	Multithreading ~~is a~~ Java ~~feature that allows concurrent execution of two or more parts of a~~ program ~~for maximum utilization of~~ CPU. ~~Each part of such~~ program ~~is called a~~ thread. So, ~~threads are light-weight processes within a process~~.		Multithreading adalah fitur Java yang memungkinkan eksekusi bersamaan dari dua atau lebih bagian program untuk pemanfaatan CPU secara maksimal. Setiap bagian dari program tersebut disebut thread. Jadi, thread adalah proses ringan dalam suatu proses.

	~~Threads can be created by using two mechanisms~~ :		Thread dapat dibuat dengan menggunakan dua mekanisme:
			* Memperluas Thread class
			* Implementing Runnable Interface

	* Extending the Thread class
	* Implementing the Runnable Interface

			==Create Thread dengan cara meng-extend Thread class==

	Multithreading adalah fitur Java yang memungkinkan eksekusi bersamaan dari dua atau lebih bagian program untuk pemanfaatan CPU secara maksimal. Setiap bagian dari program tersebut disebut thread. Jadi, utas adalah proses ringan dalam suatu proses.		Kami membuat Class yang memperluas Class java.lang.Thread. Class ini override method run() yang tersedia di Class Thread. Sebuah Thread memulai kehidupannya di dalam method run(). Kita membuat object Class baru dan memanggil metode start() untuk memulai eksekusi Thread. Start() memanggil metode run() pada object Thread.

	~~Utas dapat dibuat dengan menggunakan dua mekanisme:~~

	* Memperluas kelas Thread
	* Menerapkan Antarmuka Runnable




	~~==Thread creation by extending the Thread class==~~

	We create a class that extends the java.lang.Thread class. This class overrides the run() method available in the Thread class. A thread begins its life inside run() method. We create an object of our new class and call start() method to start the execution of a thread. Start() invokes the run() method on the Thread object.


	Kami membuat ~~kelas~~ yang memperluas ~~kelas~~ java.lang.Thread. ~~Kelas~~ ini ~~menimpa metode~~ run() yang tersedia di ~~kelas~~ Thread. Sebuah ~~utas~~ memulai kehidupannya di dalam ~~metode~~ run(). ~~Kami~~ membuat ~~objek kelas~~ baru ~~kami~~ dan memanggil metode start() untuk memulai eksekusi ~~utas~~. Start() memanggil metode run() pada ~~objek~~ Thread.


Line 66:		Line 52:
	Thread 17 is running		Thread 17 is running

	~~==Thread creation by implementing the Runnable Interface==~~

	~~We create a new class which implements java.lang.Runnable interface and override run() method. Then we instantiate a Thread object and call start() method on this object.~~

	~~Kami membuat kelas baru yang mengimplementasikan antarmuka java.lang.~~Runnable ~~dan menimpa metode run(). Kemudian kita membuat instance objek Thread dan memanggil metode start() pada objek ini.~~		==Creat Thread dengan cara meng-implementasi Runnable Interface==

			Kita membuat Class baru yang mengimplementasikan java.lang.Runnable interface dan override method run(). Kemudian kita membuat instance objek Thread dan memanggil method start() pada object ini.


Line 117:		Line 101:
	==Thread Class vs Runnable Interface==		==Thread Class vs Runnable Interface==

	* If we extend the Thread class, our class cannot extend any other class because Java doesn’t support multiple inheritance. But, if we implement the Runnable interface, our class can still extend other base classes.		* Jika kita meng-extend class Thread, class kita tidak dapat meng-extend class lain karena Java tidak mendukung multiple inheritance. Namun, jika kita mengimplementasikan Runnable interface, Class kita masih dapat memperluas Class dasar lainnya.
	* We can achieve basic functionality of a thread by extending Thread class because it provides some inbuilt methods like yield(), interrupt() etc. that are not available in Runnable interface.		* Kita dapat mencapai fungsionalitas dasar sebuah thread dengan memperluas Class Thread karena ia menyediakan beberapa inbuilt method seperti yield(), interupsi() dll. yang tidak tersedia di Runnable interface.
	* Using runnable will give you an object that can be shared amongst multiple threads.		* Menggunakan runnable akan memberi object yang dapat dibagikan di antara banyak Thread.


	* Jika kita meng-extend class Thread, class kita tidak dapat meng-extend class lain karena Java tidak mendukung multiple inheritance. Namun, jika kita mengimplementasikan ~~antarmuka~~ Runnable, ~~kelas~~ kita masih dapat memperluas ~~kelas~~ dasar lainnya.
	* Kita dapat mencapai fungsionalitas dasar sebuah thread dengan memperluas ~~kelas~~ Thread karena ia menyediakan beberapa ~~metode bawaan~~ seperti ~~hasil~~(), interupsi() dll. yang tidak tersedia di ~~antarmuka~~ Runnable.
	* Menggunakan runnable akan memberi ~~Anda objek~~ yang dapat dibagikan di antara banyak ~~utas~~.

Unknown user at 09:34, 11 May 2022

2022-05-11T09:34:30Z

← Older revision		Revision as of 09:34, 11 May 2022
Line 5:		Line 5:
	* Extending the Thread class		* Extending the Thread class
	* Implementing the Runnable Interface		* Implementing the Runnable Interface


			Multithreading adalah fitur Java yang memungkinkan eksekusi bersamaan dari dua atau lebih bagian program untuk pemanfaatan CPU secara maksimal. Setiap bagian dari program tersebut disebut thread. Jadi, utas adalah proses ringan dalam suatu proses.

			Utas dapat dibuat dengan menggunakan dua mekanisme:

			* Memperluas kelas Thread
			* Menerapkan Antarmuka Runnable




	==Thread creation by extending the Thread class==		==Thread creation by extending the Thread class==

	We create a class that extends the java.lang.Thread class. This class overrides the run() method available in the Thread class. A thread begins its life inside run() method. We create an object of our new class and call start() method to start the execution of a thread. Start() invokes the run() method on the Thread object.		We create a class that extends the java.lang.Thread class. This class overrides the run() method available in the Thread class. A thread begins its life inside run() method. We create an object of our new class and call start() method to start the execution of a thread. Start() invokes the run() method on the Thread object.


			Kami membuat kelas yang memperluas kelas java.lang.Thread. Kelas ini menimpa metode run() yang tersedia di kelas Thread. Sebuah utas memulai kehidupannya di dalam metode run(). Kami membuat objek kelas baru kami dan memanggil metode start() untuk memulai eksekusi utas. Start() memanggil metode run() pada objek Thread.


	// Java code for thread creation by extending		// Java code for thread creation by extending
Line 54:		Line 69:

	We create a new class which implements java.lang.Runnable interface and override run() method. Then we instantiate a Thread object and call start() method on this object.		We create a new class which implements java.lang.Runnable interface and override run() method. Then we instantiate a Thread object and call start() method on this object.

			Kami membuat kelas baru yang mengimplementasikan antarmuka java.lang.Runnable dan menimpa metode run(). Kemudian kita membuat instance objek Thread dan memanggil metode start() pada objek ini.



	// Java code for thread creation by implementing		// Java code for thread creation by implementing
Line 101:		Line 120:
	* We can achieve basic functionality of a thread by extending Thread class because it provides some inbuilt methods like yield(), interrupt() etc. that are not available in Runnable interface.		* We can achieve basic functionality of a thread by extending Thread class because it provides some inbuilt methods like yield(), interrupt() etc. that are not available in Runnable interface.
	* Using runnable will give you an object that can be shared amongst multiple threads.		* Using runnable will give you an object that can be shared amongst multiple threads.


			* Jika kita meng-extend class Thread, class kita tidak dapat meng-extend class lain karena Java tidak mendukung multiple inheritance. Namun, jika kita mengimplementasikan antarmuka Runnable, kelas kita masih dapat memperluas kelas dasar lainnya.
			* Kita dapat mencapai fungsionalitas dasar sebuah thread dengan memperluas kelas Thread karena ia menyediakan beberapa metode bawaan seperti hasil(), interupsi() dll. yang tidak tersedia di antarmuka Runnable.
			* Menggunakan runnable akan memberi Anda objek yang dapat dibagikan di antara banyak utas.

Unknown user at 09:26, 11 May 2022

2022-05-11T09:26:56Z

Show changes

Unknown user: Created page with "Multithreading is a Java feature that allows concurrent execution of two or more parts of a program for maximum utilization of CPU. Each part of such program is called a threa..."

2022-05-09T04:21:24Z

Created page with "Multithreading is a Java feature that allows concurrent execution of two or more parts of a program for maximum utilization of CPU. Each part of such program is called a threa..."

New page

Multithreading is a Java feature that allows concurrent execution of two or more parts of a program for maximum utilization of CPU. Each part of such program is called a thread. So, threads are light-weight processes within a process.

Threads can be created by using two mechanisms :

Extending the Thread class
Implementing the Runnable Interface
Thread creation by extending the Thread class
We create a class that extends the java.lang.Thread class. This class overrides the run() method available in the Thread class. A thread begins its life inside run() method. We create an object of our new class and call start() method to start the execution of a thread. Start() invokes the run() method on the Thread object.

// Java code for thread creation by extending
// the Thread class
class MultithreadingDemo 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 Multithread {
public static void main(String[] args)
{
int n = 8; // Number of threads
for (int i = 0; i < n; i++) {
MultithreadingDemo object
= new MultithreadingDemo();
object.start();
}
}
}
Output
Thread 15 is running
Thread 14 is running
Thread 16 is running
Thread 12 is running
Thread 11 is running
Thread 13 is running
Thread 18 is running
Thread 17 is running
Thread creation by implementing the Runnable Interface
We create a new class which implements java.lang.Runnable interface and override run() method. Then we instantiate a Thread object and call start() method on this object.

// Java code for thread creation by implementing
// the Runnable Interface
class MultithreadingDemo implements Runnable {
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
class Multithread {
public static void main(String[] args)
{
int n = 8; // Number of threads
for (int i = 0; i < n; i++) {
Thread object
= new Thread(new MultithreadingDemo());
object.start();
}
}
}
Output
Thread 13 is running
Thread 11 is running
Thread 12 is running
Thread 15 is running
Thread 14 is running
Thread 18 is running
Thread 17 is running
Thread 16 is running
Thread Class vs Runnable Interface

If we extend the Thread class, our class cannot extend any other class because Java doesn’t support multiple inheritance. But, if we implement the Runnable interface, our class can still extend other base classes.
We can achieve basic functionality of a thread by extending Thread class because it provides some inbuilt methods like yield(), interrupt() etc. that are not available in Runnable interface.
Using runnable will give you an object that can be shared amongst multiple threads.

==Referensi==

* https://www.geeksforgeeks.org/multithreading-in-java/