Java Threads are the smallest unit of execution that can run concurrently within a Java program. They allow multiple tasks to run in parallel, thereby increasing the performance and efficiency of the program. Here is an example of how to use threads in Java.
Creating a Thread
There are two ways to create a thread in Java:
- Extending the Thread class
- Implementing the Runnable interface
Here is an example of creating a thread by extending the Thread class:
class MyThread extends Thread {
public void run() {
System.out.println("MyThread is running");
}
}
Here is an example of creating a thread by implementing the Runnable interface:
class MyRunnable implements Runnable {
public void run() {
System.out.println("MyRunnable is running");
}
}
Starting a Thread
Once you have created a thread, you need to start it using the start() method. The start() method calls the run() method of the thread and starts the execution of the thread.
Here is an example of starting a thread:
MyThread thread1 = new MyThread(); thread1.start(); MyRunnable runnable = new MyRunnable(); Thread thread2 = new Thread(runnable); thread2.start();
Joining Threads
If you want to wait for a thread to finish its execution before continuing with the main thread, you can use the join() method. The join() method waits for the thread to finish its execution before continuing with the main thread.
Here is an example of using the join() method:
MyThread thread1 = new MyThread();
thread1.start();
thread1.join();
System.out.println("Thread 1 has finished");
MyRunnable runnable = new MyRunnable();
Thread thread2 = new Thread(runnable);
thread2.start();
thread2.join();
System.out.println("Thread 2 has finished");
Thread Synchronization
Thread synchronization is used to prevent multiple threads from accessing the same resource at the same time. This is done to avoid race conditions and other synchronization issues.
Here is an example of using thread synchronization:
class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
class MyRunnable implements Runnable {
private Counter counter;
public MyRunnable(Counter counter) {
this.counter = counter;
}
public void run() {
for (int i = 0; i < 10000; i++) {
counter.increment();
}
}
}
Counter counter = new Counter();
MyRunnable runnable1 = new MyRunnable(counter);
MyRunnable runnable2 = new MyRunnable(counter);
Thread thread1 = new Thread(runnable1);
Thread thread2 = new Thread(runnable2);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println(counter.getCount());
In this example, we create a Counter class that has two synchronized methods: increment() and getCount(). We then create two MyRunnable objects and pass them the same Counter object. We then start two threads, each running one of the MyRunnable objects. Finally, we wait for both threads to finish and print out the value of the counter. Since the increment() method is synchronized, the two threads cannot access it at the same time, and the value of the counter is incremented correctly.
In Java, there are two ways to create threads:
- Extending the Thread class: This involves creating a class that extends the Thread class and overriding the run() method to define the behavior of the thread. The thread is started by calling the start() method on an instance of the thread class.
- Implementing the Runnable interface: This involves creating a class that implements the Runnable interface and implementing the run() method to define the behavior of the thread. The thread is started by passing an instance of the class to the constructor of a Thread object and calling the start() method on that thread object.
Some important concepts related to Java threads are:
- Synchronization: Synchronization is a mechanism that ensures that only one thread can access a shared resource at a time. This is achieved by using the synchronized keyword to mark a block of code that should only be executed by one thread at a time.
- Deadlock: Deadlock is a situation where two or more threads are blocked waiting for each other to release a resource. This can lead to a program becoming unresponsive and is often caused by incorrect use of synchronization.
- Thread pools: A thread pool is a group of pre-initialized threads that can be used to execute tasks concurrently. This can improve performance by reducing the overhead of creating and destroying threads.
- Thread safety: Thread safety is a property of code that ensures that it can be safely executed by multiple threads without causing errors or unexpected behavior. This is achieved by using synchronization and other techniques to manage access to shared resources.
- Interrupts: Interrupts are a mechanism for stopping a thread’s execution. This can be used to terminate a thread that has become unresponsive or to implement graceful shutdown of a program.
Here is an example of Java threads that demonstrate how to create threads and use synchronization:
class MyThread extends Thread {
private String name;
private Counter counter;
public MyThread(String name, Counter counter) {
this.name = name;
this.counter = counter;
}
public void run() {
System.out.println(name + " started.");
for (int i = 0; i < 5; i++) {
counter.increment();
System.out.println(name + ": " + counter.getCount());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
System.out.println(name + " interrupted.");
}
}
System.out.println(name + " finished.");
}
}
class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
public class Main {
public static void main(String[] args) {
Counter counter = new Counter();
MyThread thread1 = new MyThread("Thread 1", counter);
MyThread thread2 = new MyThread("Thread 2", counter);
thread1.start();
thread2.start();
}
}
In this example, we define a MyThread class that extends the Thread class and takes a Counter object as a parameter. The run() method of the thread increments the counter object and prints its value to the console. We also use the sleep() method to simulate some processing time.
The Counter class is used to demonstrate synchronization. The increment() and getCount() methods are marked as synchronized to ensure that only one thread can access them at a time.
In the Main class, we create two instances of MyThread and pass them the same Counter object. This way, both threads will increment the same counter, which will demonstrate synchronization. We start the threads using the start() method, which causes the run() method to be executed in a separate thread.
When we run this program, we should see output similar to the following:
Java threads are a powerful tool for concurrent programming, but they require careful management to avoid issues such as deadlocks and race conditions. Proper use of synchronization and other techniques can help ensure that threads execute correctly and safely in a multi-threaded environment.
