Home ยป Tutorials ยป Page 5
Category:

Tutorials

OOP

Java Wrapper Classes Tutorial

written by 75ypsaw71

In Java, wrapper classes are used to represent primitive data types as objects. Every primitive data type in Java has a corresponding wrapper class in the java.lang package.

Wrapper classes allow primitives to be used as objects when necessary, such as when working with collections (like ArrayList) or generics.

Wrapper classes provide methods to perform operations on primitive types, such as parsing, conversion, and null handling, which cannot be done with the primitives directly.

In this tutorial, we'll explore Java's wrapper classes with several code examples to demonstrate how they are used and how they convert between primitive types and objects.

1. List of Java Wrapper Classes

Java provides the following wrapper classes for each primitive data type:

Primitive Type Wrapper Class
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

2. Why Use Wrapper Classes?

Wrapper classes are useful in many scenarios:

Collections: Java collections (like ArrayList) only work with objects, so primitive types need to be wrapped in their corresponding wrapper classes.
Type conversion: Wrapper classes provide utility methods for converting between different data types (e.g., parsing strings into numbers).
Null handling: Unlike primitive types, wrapper classes can store null values, which are useful in certain contexts.
Autoboxing and Unboxing: Java automatically converts between primitives and wrapper objects (autoboxing/unboxing), making the code easier to read and write.

3. Creating Wrapper Objects (Boxing)

Wrapper objects can be created in two ways:

Using the constructor of the wrapper class.
Using static factory methods (e.g., valueOf()).

Example: Creating Wrapper Objects

public class WrapperExample {
    public static void main(String[] args) {
        // Creating wrapper objects using constructor (Deprecated in newer versions)
        Integer intObj1 = new Integer(100);  // Deprecated in Java 9
        Double doubleObj1 = new Double(5.5); // Deprecated in Java 9

        // Creating wrapper objects using valueOf() (Preferred method)
        Integer intObj2 = Integer.valueOf(200);
        Double doubleObj2 = Double.valueOf(10.5);

        // Displaying the values
        System.out.println("intObj1: " + intObj1);
        System.out.println("doubleObj1: " + doubleObj1);
        System.out.println("intObj2: " + intObj2);
        System.out.println("doubleObj2: " + doubleObj2);
    }
}

Explanation:

You can create wrapper objects using the constructor (deprecated in newer versions) or the preferred valueOf() method.
Wrapper objects represent the corresponding primitive values.

Output:

intObj1: 100
doubleObj1: 5.5
intObj2: 200
doubleObj2: 10.5

4. Autoboxing and Unboxing

Autoboxing is the automatic conversion of a primitive type into its corresponding wrapper class object. Unboxing is the reverse process: converting a wrapper object back into a primitive type. Java automatically performs these conversions when needed, making the code more concise.

Example: Autoboxing and Unboxing

public class AutoboxingUnboxingExample {
    public static void main(String[] args) {
        // Autoboxing: converting a primitive to a wrapper object
        Integer intObj = 10;  // Equivalent to Integer.valueOf(10)

        // Unboxing: converting a wrapper object to a primitive
        int intValue = intObj;  // Equivalent to intObj.intValue()

        // Displaying the values
        System.out.println("Wrapper object (Integer): " + intObj);
        System.out.println("Primitive value (int): " + intValue);
    }
}

Explanation:

Java automatically converts int to Integer (autoboxing) and Integer to int (unboxing).
This feature makes code easier to read by reducing explicit conversions.

Output:

Wrapper object (Integer): 10
Primitive value (int): 10

5. Wrapper Class Methods

Each wrapper class provides several utility methods for manipulating and converting primitive values. Some common methods include:

parse(): Converts a String into a primitive type.
valueOf(): Converts a String or primitive into a wrapper object.
Value(): Converts the wrapper object to a primitive.

Example: Common Wrapper Class Methods

public class WrapperMethodsExample {
    public static void main(String[] args) {
        // Using parse methods to convert String to primitive types
        int intValue = Integer.parseInt("123");
        double doubleValue = Double.parseDouble("45.67");

        // Using valueOf() to create wrapper objects from strings
        Integer intObj = Integer.valueOf("100");
        Double doubleObj = Double.valueOf("99.99");

        // Converting wrapper objects to primitive types
        int primitiveInt = intObj.intValue();
        double primitiveDouble = doubleObj.doubleValue();

        // Displaying results
        System.out.println("Parsed int: " + intValue);
        System.out.println("Parsed double: " + doubleValue);
        System.out.println("Wrapper Integer object: " + intObj);
        System.out.println("Wrapper Double object: " + doubleObj);
        System.out.println("Primitive int from Integer object: " + primitiveInt);
        System.out.println("Primitive double from Double object: " + primitiveDouble);
    }
}

Explanation:

parseInt() and parseDouble() are used to convert String values to int and double primitives, respectively.
valueOf() is used to create wrapper objects from String values.
Value() methods are used to retrieve the primitive value from wrapper objects.

Output:

Parsed int: 123
Parsed double: 45.67
Wrapper Integer object: 100
Wrapper Double object: 99.99
Primitive int from Integer object: 100
Primitive double from Double object: 99.99

6. Wrapper Classes in Collections

Java collections (such as ArrayList, HashMap, etc.) cannot store primitive types directly. Instead, wrapper classes are used to store primitive values as objects in collections.

Example: Using Wrapper Classes in Collections

import java.util.ArrayList;

public class WrapperInCollectionsExample {
    public static void main(String[] args) {
        // Creating an ArrayList to store Integer objects (autoboxing will occur)
        ArrayList intList = new ArrayList<>();

        // Adding primitive int values (autoboxing to Integer objects)
        intList.add(10);  // Autoboxing converts int to Integer
        intList.add(20);
        intList.add(30);

        // Retrieving and using the values (unboxing to int)
        int sum = 0;
        for (Integer num : intList) {
            sum += num;  // Unboxing converts Integer to int
        }

        // Displaying the sum
        System.out.println("Sum: " + sum);
    }
}

Explanation:

The ArrayList stores Integer objects (not primitive int).
Autoboxing automatically converts the primitive int values into Integer objects when added to the list, and unboxing occurs when they are retrieved.

Output:

Sum: 60

7. Null Handling with Wrapper Classes

One key advantage of wrapper classes is their ability to store null values, unlike primitive types which cannot hold null. This is useful in scenarios where a value may not be present.

Example: Null Handling with Wrapper Classes

public class NullHandlingExample {
    public static void main(String[] args) {
        // Integer can hold null, but int cannot
        Integer nullableInt = null;

        // Trying to use int with null will cause NullPointerException
        try {
            int primitiveInt = nullableInt;  // Unboxing a null value will throw an exception
        } catch (NullPointerException e) {
            System.out.println("Caught NullPointerException when unboxing null Integer");
        }

        // Safe check for null before unboxing
        if (nullableInt != null) {
            int safeInt = nullableInt;  // Only unbox if not null
            System.out.println("Safe int value: " + safeInt);
        } else {
            System.out.println("No value present");
        }
    }
}

Explanation:

Wrapper classes can hold null values, unlike primitive types.
Unboxing a null value will cause a NullPointerException, so it's important to check for null before unboxing.

Output:

Caught NullPointerException when unboxing null Integer
No value present

8. Performance Considerations

While wrapper classes provide additional functionality, they come with some performance overhead compared to primitive types:

Memory Usage: Wrapper objects consume more memory than primitive types.
Autoboxing/Unboxing: Implicit conversions between primitives and wrapper objects can introduce performance costs.
Null Handling: Wrapper classes are nullable, which adds flexibility but also the risk of NullPointerException.
When performance is critical (e.g., in loops), consider using primitive types to avoid the overhead of autoboxing/unboxing.

Example: Performance Impact of Autoboxing

public class AutoboxingPerformanceExample {
    public static void main(String[] args) {
        long startTime, endTime;

        // Using primitive int
        startTime = System.nanoTime();
        int sum1 = 0;
        for (int i = 0; i < 1000000; i++) {
            sum1 += i;
        }
        endTime = System.nanoTime();
        System.out.println("Time with int: " + (endTime - startTime) + " ns");

        // Using wrapper Integer (autoboxing/unboxing)
        startTime = System.nanoTime();
        Integer sum2 = 0;
        for (int i = 0; i < 1000000; i++) {
            sum2 += i;  // Autoboxing/unboxing occurs
        }
        endTime = System.nanoTime();
        System.out.println("Time with Integer: " + (endTime - startTime) + " ns");
    }
}

Explanation:

The loop that uses int performs faster than the one that uses Integer because of the overhead of autoboxing/unboxing.

Sample Output:

Time with int: 116499 ns
Time with Integer: 3538675 ns

Conclusion

Java wrapper classes are a powerful tool that allows you to treat primitive data types as objects. They provide utility methods for parsing, converting, and manipulating primitive data, and are essential for working with Java collections and generics.

Key Points:

Wrapper Classes: Each primitive type has a corresponding wrapper class (int โ†’ Integer, char โ†’ Character, etc.).
Autoboxing and Unboxing: Java automatically converts between primitives and wrapper objects.
Utility Methods: Wrapper classes provide methods like valueOf(), parse(), and Value() for conversion and manipulation.
Null Handling: Unlike primitive types, wrapper classes can store null values.
Collections: Java collections can only hold objects, so wrapper classes are used to store primitive values.
Performance Considerations: While convenient, wrapper classes can introduce performance overhead due to memory usage and autoboxing/unboxing.

By understanding and using wrapper classes effectively, you can write more flexible and object-oriented code in Java.

0 comment
0 FacebookTwitterPinterestEmail
Advanced

Java Inter-thread Communication Tutorial

written by 75ypsaw71

In Java, inter-thread communication refers to the process where threads can communicate with each other, allowing them to coordinate their work.

It is often used in scenarios where one thread produces data and another thread consumes that data (producer-consumer problems).

Java provides built-in mechanisms to achieve inter-thread communication using methods like wait(), notify(), and notifyAll(), which work with synchronization to ensure safe communication between threads.

In this tutorial, we will explore these concepts with examples to demonstrate how threads communicate with each other in Java.

1. Key Methods for Inter-thread Communication

Java provides three key methods from the Object class that are essential for inter-thread communication:

wait(): Causes the current thread to wait until another thread calls notify() or notifyAll() on the same object.
notify(): Wakes up a single thread that is waiting on the object's monitor.
notifyAll(): Wakes up all the threads that are waiting on the object's monitor.
These methods are always used within a synchronized block or synchronized method to ensure that only one thread can access the shared resource at a time.

2. Understanding wait(), notify(), and notifyAll()

wait(): When a thread calls wait(), it releases the lock on the object and enters a waiting state until another thread calls notify() or notifyAll() on the same object.
notify(): Wakes up one waiting thread (chosen randomly) that is waiting on the object's monitor. If no threads are waiting, nothing happens.
notifyAll(): Wakes up all the threads waiting on the object's monitor. The threads will compete to acquire the lock once it is available.

3. Producer-Consumer Problem (Basic Example)

A classic use case for inter-thread communication is the producer-consumer problem, where one thread (producer) generates data and another thread (consumer) processes it.

The producer should wait if the shared resource (buffer) is full, and the consumer should wait if the buffer is empty.

Example: Producer-Consumer with wait() and notify()

class SharedResource {
    private int value;
    private boolean hasValue = false;  // To track if value is produced

    // Synchronized method for producing a value
    public synchronized void produce(int newValue) throws InterruptedException {
        // Wait if the value has already been produced
        while (hasValue) {
            wait();
        }
        this.value = newValue;
        System.out.println("Produced: " + newValue);
        hasValue = true;  // Mark that the value has been produced
        notify();  // Notify the consumer
    }

    // Synchronized method for consuming a value
    public synchronized void consume() throws InterruptedException {
        // Wait if there is no value to consume
        while (!hasValue) {
            wait();
        }
        System.out.println("Consumed: " + value);
        hasValue = false;  // Mark that the value has been consumed
        notify();  // Notify the producer
    }
}

public class ProducerConsumerExample {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();

        // Producer thread
        Thread producer = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) { resource.produce(i); Thread.sleep(100); // Simulate some work } } catch (InterruptedException e) { e.printStackTrace(); } }); // Consumer thread Thread consumer = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) {
                    resource.consume();
                    Thread.sleep(150);  // Simulate some work
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // Start both threads
        producer.start();
        consumer.start();
    }
}

Explanation:

The SharedResource class has two synchronized methods: produce() and consume().
The producer produces values (1 to 5), and the consumer consumes them.

If the producer has already produced a value, it waits until the consumer consumes it. Similarly, the consumer waits until the producer produces a new value.

Output:

Produced: 1
Consumed: 1
Produced: 2
Consumed: 2
Produced: 3
Consumed: 3
Produced: 4
Consumed: 4
Produced: 5
Consumed: 5

4. Using notifyAll()

In cases where multiple threads are waiting for a resource, notifyAll() can be used to wake up all the waiting threads. Once all threads are awakened, they will compete to acquire the lock and proceed with their work.

Example: Producer-Consumer with Multiple Consumers (notifyAll())

class SharedResourceMultiConsumer {
    private int value;
    private boolean hasValue = false;

    // Synchronized method for producing a value
    public synchronized void produce(int newValue) throws InterruptedException {
        while (hasValue) {
            wait();
        }
        this.value = newValue;
        System.out.println("Produced: " + newValue);
        hasValue = true;
        notifyAll();  // Notify all consumers
    }

    // Synchronized method for consuming a value
    public synchronized void consume(String consumerName) throws InterruptedException {
        while (!hasValue) {
            wait();
        }
        System.out.println(consumerName + " consumed: " + value);
        hasValue = false;
        notifyAll();  // Notify producer
    }
}

public class MultiConsumerExample {
    public static void main(String[] args) {
        SharedResourceMultiConsumer resource = new SharedResourceMultiConsumer();

        // Producer thread
        Thread producer = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) { resource.produce(i); Thread.sleep(100); } } catch (InterruptedException e) { e.printStackTrace(); } }); // Consumer threads Thread consumer1 = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) { resource.consume("Consumer 1"); } } catch (InterruptedException e) { e.printStackTrace(); } }); Thread consumer2 = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) {
                    resource.consume("Consumer 2");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // Start threads
        producer.start();
        consumer1.start();
        consumer2.start();
    }
}

Explanation:

notifyAll() is used to wake up all waiting consumers after a value is produced.
Once consumers are notified, they compete to acquire the lock and consume the value.

Sample Output (may vary):

Produced: 1
Consumer 1 consumed: 1
Produced: 2
Consumer 2 consumed: 2
Produced: 3
Consumer 1 consumed: 3
Produced: 4
Consumer 2 consumed: 4
Produced: 5
Consumer 1 consumed: 5

5. The wait() and notify() in the Context of Locks

The wait(), notify(), and notifyAll() methods are tightly coupled with synchronization in Java. They must always be called within a synchronized block, as the calling thread must own the lock on the object before invoking these methods.

Example: Incorrect Use of wait() without Synchronization

class IncorrectSharedResource {
    public void produce() throws InterruptedException {
        wait();  // This will throw IllegalMonitorStateException
    }

    public void consume() {
        notify();
    }
}

public class IncorrectUsageExample {
    public static void main(String[] args) {
        IncorrectSharedResource resource = new IncorrectSharedResource();

        Thread producer = new Thread(() -> {
            try {
                resource.produce();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumer = new Thread(resource::consume);

        producer.start();
        consumer.start();
    }
}

Explanation:

This code will throw IllegalMonitorStateException because wait() and notify() are being called outside a synchronized block.
You must always use these methods within a synchronized context to avoid such exceptions.

Correct Usage:

synchronized (this) {
    wait();  // Safe usage
}

6. Best Practices for Inter-thread Communication

Always use wait(), notify(), and notifyAll() inside synchronized blocks or synchronized methods.
Use notifyAll() when multiple threads are waiting on the same object to avoid starvation.
Avoid holding multiple locks while using wait() and notify() to reduce the chances of deadlocks.
Always use a while loop for the condition check in wait() to avoid spurious wakeups, which are rare but possible.

7. Real-World Scenario: Bounded Buffer (Producer-Consumer)

In real-world systems, thereโ€™s often a bounded buffer (like a queue) between the producer and consumer. The producer cannot add to the buffer if it is full, and the consumer cannot consume from the buffer if it is empty.

Example: Producer-Consumer with Bounded Buffer

import java.util.LinkedList;
import java.util.Queue;

class BoundedBuffer {
    private final Queue buffer = new LinkedList<>();
    private final int capacity;

    public BoundedBuffer(int capacity) {
        this.capacity = capacity;
    }

    // Produce a value
    public synchronized void produce(int value) throws InterruptedException {
        while (buffer.size() == capacity) {
            wait();  // Wait if buffer is full
        }
        buffer.add(value);
        System.out.println("Produced: " + value);
        notifyAll();  // Notify consumers that a new item is available
    }

    // Consume a value
    public synchronized int consume() throws InterruptedException {
        while (buffer.isEmpty()) {
            wait();  // Wait if buffer is empty
        }
        int value = buffer.poll();
        System.out.println("Consumed: " + value);
        notifyAll();  // Notify producers that a slot is available
        return value;
    }
}

public class BoundedBufferExample {
    public static void main(String[] args) {
        BoundedBuffer buffer = new BoundedBuffer(2);  // Buffer with capacity of 2

        // Producer thread
        Thread producer = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) { buffer.produce(i); Thread.sleep(100); // Simulate production delay } } catch (InterruptedException e) { e.printStackTrace(); } }); // Consumer thread Thread consumer = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) {
                    buffer.consume();
                    Thread.sleep(150);  // Simulate consumption delay
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // Start producer and consumer
        producer.start();
        consumer.start();
    }
}

Explanation:

The buffer has a capacity of 2.
The producer produces values into the buffer, and the consumer consumes values from the buffer.
If the buffer is full, the producer waits. If the buffer is empty, the consumer waits.

Output:

Produced: 1
Produced: 2
Consumed: 1
Produced: 3
Consumed: 2
Produced: 4
Consumed: 3
Produced: 5
Consumed: 4
Consumed: 5

Conclusion

Java provides powerful mechanisms for inter-thread communication through wait(), notify(), and notifyAll(). These methods help threads coordinate their execution when they share resources. Key points to remember:

wait() puts the thread into a waiting state until another thread calls notify() or notifyAll().
notify() wakes up a single waiting thread, while notifyAll() wakes up all waiting threads.
Always use these methods inside a synchronized block to ensure safe communication between threads.

By mastering these concepts, you can build robust and efficient multithreaded applications in Java.

0 comment
0 FacebookTwitterPinterestEmail
Advanced

Java Thread Deadlock Tutorial

written by 75ypsaw71

A deadlock in Java occurs when two or more threads are blocked forever, waiting for each other to release the resources they need. Deadlock happens when threads acquire locks in an inconsistent order and attempt to access resources in such a way that they block each other.

In this tutorial, we'll learn what deadlock is, how it can occur in multithreaded Java programs, and how to avoid it.

Weโ€™ll also provide several code examples to help you understand the problem and its solutions.

1. What is Deadlock?

A deadlock occurs in multithreaded applications when two or more threads are waiting indefinitely for a condition that can never be satisfied. Deadlocks arise when the following conditions are met:

Mutual Exclusion: At least two threads require exclusive access to resources.
Hold and Wait: Threads hold resources and wait for additional resources held by other threads.
No Preemption: Resources cannot be forcibly taken away from threads; they must be released voluntarily.
Circular Wait: A circular chain of threads exists where each thread holds a resource that the next thread in the chain needs.
These conditions lead to a situation where all threads involved are stuck, waiting for each other, and none can proceed.

2. Example of Deadlock

Below is an example of a deadlock scenario in Java where two threads (Thread-1 and Thread-2) are waiting for each other to release resources (resource1 and resource2).

Example:

public class DeadlockExample {
    // Resource 1 and Resource 2
    private final Object resource1 = new Object();
    private final Object resource2 = new Object();

    public static void main(String[] args) {
        DeadlockExample deadlock = new DeadlockExample();
        deadlock.startThreads();
    }

    public void startThreads() {
        // Thread 1
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1: Locked resource 1");

                try { Thread.sleep(100); } catch (InterruptedException e) {}

                System.out.println("Thread 1: Waiting for resource 2");
                synchronized (resource2) {
                    System.out.println("Thread 1: Locked resource 2");
                }
            }
        });

        // Thread 2
        Thread thread2 = new Thread(() -> {
            synchronized (resource2) {
                System.out.println("Thread 2: Locked resource 2");

                try { Thread.sleep(100); } catch (InterruptedException e) {}

                System.out.println("Thread 2: Waiting for resource 1");
                synchronized (resource1) {
                    System.out.println("Thread 2: Locked resource 1");
                }
            }
        });

        // Start both threads
        thread1.start();
        thread2.start();
    }
}

Explanation:

Thread 1 locks resource1 and then waits for resource2.
Thread 2 locks resource2 and then waits for resource1.
Neither thread can proceed because both are holding a resource the other needs, resulting in a deadlock.

Output:

Thread 1: Locked resource 1
Thread 2: Locked resource 2
Thread 1: Waiting for resource 2
Thread 2: Waiting for resource 1

At this point, both threads are stuck, and the program will not progress because they are each waiting for the other to release the resource.

3. How to Avoid Deadlock

There are several strategies to avoid deadlock in Java:

Lock Ordering: Always acquire locks in a consistent order.
Lock Timeout: Use timeout mechanisms while trying to acquire a lock.
Avoid Holding Locks While Waiting: Avoid holding multiple locks simultaneously.
Deadlock Detection: Implement a deadlock detection mechanism (complex but effective).

4. Solution: Avoiding Deadlock with Lock Ordering

By ensuring that all threads acquire locks in the same order, you can prevent circular wait conditions that lead to deadlocks.

Example:

Solving Deadlock by Lock Ordering

public class DeadlockSolution {
    // Resource 1 and Resource 2
    private final Object resource1 = new Object();
    private final Object resource2 = new Object();

    public static void main(String[] args) {
        DeadlockSolution solution = new DeadlockSolution();
        solution.startThreads();
    }

    public void startThreads() {
        // Thread 1
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1: Locked resource 1");

                try { Thread.sleep(100); } catch (InterruptedException e) {}

                System.out.println("Thread 1: Waiting for resource 2");
                synchronized (resource2) {
                    System.out.println("Thread 1: Locked resource 2");
                }
            }
        });

        // Thread 2 follows the same lock order
        Thread thread2 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 2: Locked resource 1");

                try { Thread.sleep(100); } catch (InterruptedException e) {}

                System.out.println("Thread 2: Waiting for resource 2");
                synchronized (resource2) {
                    System.out.println("Thread 2: Locked resource 2");
                }
            }
        });

        // Start both threads
        thread1.start();
        thread2.start();
    }
}

Explanation:

Both Thread 1 and Thread 2 now acquire resource1 first and then resource2, ensuring that all threads follow the same locking order.
This eliminates the risk of deadlock, as there is no circular wait condition.

Output:

Thread 1: Locked resource 1
Thread 2: Locked resource 1
Thread 1: Waiting for resource 2
Thread 1: Locked resource 2
Thread 2: Waiting for resource 2
Thread 2: Locked resource 2

In this case, Thread 1 acquires both resources and finishes, followed by Thread 2, avoiding deadlock.

5. Solution: Avoiding Deadlock with tryLock() and Timeout

The ReentrantLock class in Java provides a tryLock() method, which tries to acquire the lock and can fail if the lock is not available. This method also allows specifying a timeout to avoid long waits.

Example:

Solving Deadlock with tryLock()

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TryLockSolution {
    private final Lock lock1 = new ReentrantLock();
    private final Lock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        TryLockSolution solution = new TryLockSolution();
        solution.startThreads();
    }

    public void startThreads() {
        // Thread 1
        Thread thread1 = new Thread(() -> {
            try {
                if (lock1.tryLock()) {
                    System.out.println("Thread 1: Locked lock1");
                    try {
                        Thread.sleep(100);
                        if (lock2.tryLock()) {
                            System.out.println("Thread 1: Locked lock2");
                            lock2.unlock();
                        }
                    } finally {
                        lock1.unlock();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // Thread 2
        Thread thread2 = new Thread(() -> {
            try {
                if (lock2.tryLock()) {
                    System.out.println("Thread 2: Locked lock2");
                    try {
                        Thread.sleep(100);
                        if (lock1.tryLock()) {
                            System.out.println("Thread 2: Locked lock1");
                            lock1.unlock();
                        }
                    } finally {
                        lock2.unlock();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // Start both threads
        thread1.start();
        thread2.start();
    }
}

Explanation:

The tryLock() method is used to attempt to acquire the locks without waiting indefinitely.
If a lock is not acquired, the thread proceeds without getting blocked forever, preventing deadlock.

Output (may vary):

Thread 1: Locked lock1
Thread 2: Locked lock2

In this case, one thread may fail to acquire both locks, but the deadlock is avoided, and the program can still proceed.

6. Deadlock Detection

While deadlock detection is more complex to implement, you can monitor thread states or use third-party tools to detect deadlocks at runtime. Java provides ThreadMXBean in the java.lang.management package to detect deadlocked threads.

Example:

Deadlock Detection Using ThreadMXBean

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;

public class DeadlockDetection {

    public static void main(String[] args) {
        DeadlockExample deadlock = new DeadlockExample();
        deadlock.startThreads();

        // Detect deadlock
        ThreadMXBean bean = ManagementFactory.getThreadMXBean();
        while (true) {
            long[] threadIds = bean.findDeadlockedThreads();
            if (threadIds != null) {
                System.out.println("Deadlock detected!");
                break;
            }
        }
    }
}

Explanation:

The ThreadMXBean provides a method findDeadlockedThreads() to check if there are any deadlocked threads.
This code continually monitors for deadlocks and prints a message when a deadlock is detected.

Output (if deadlock occurs):

Deadlock detected!

7. Summary of Deadlock Prevention Techniques

Here are a few strategies to prevent deadlocks in Java:

Lock Ordering: Always acquire locks in a fixed order.
TryLock: Use the tryLock() method from ReentrantLock to attempt acquiring locks with a timeout.
Minimize Lock Scope: Hold locks for the shortest time possible to reduce the chance of deadlock.
Avoid Nested Locks: Avoid acquiring multiple locks if possible.
Deadlock Detection: Use tools or implement detection mechanisms like ThreadMXBean to identify deadlocks in the system.

Conclusion

In this tutorial, we explored the concept of thread deadlock in Java, how it can occur, and different strategies for avoiding it. We covered:

What is a deadlock, and how it happens in a multithreaded program.
A simple example of deadlock where two threads wait for each other to release resources.
Techniques to avoid deadlocks using:
Lock ordering to acquire locks in a consistent order.
tryLock() with timeouts to prevent threads from waiting indefinitely.
Using ThreadMXBean for deadlock detection.

By understanding these strategies, you can prevent deadlocks in your Java applications and build more robust, concurrent systems.

0 comment
0 FacebookTwitterPinterestEmail
OOP

Java Static Binding Tutorial

written by 75ypsaw71

Static Binding (also known as early binding) refers to the process in which the method or variable to be executed is determined at compile time. In Java, static binding occurs for methods and variables that are resolved at compile time, such as static methods, private methods, and final methods. Static binding is the opposite of dynamic binding (late binding), which occurs at runtime.

In this tutorial, we will explore static binding with code examples and cover how it works in Java.

1. What is Static Binding?

In static binding, the compiler determines which method or variable to call at compile time, based on the type of reference rather than the actual object. This is typically applied to:

Static methods: Because they are associated with the class, not instances.
Private methods: Because they cannot be overridden.
Final methods: Since they cannot be overridden.
Member variables: Which are resolved based on the reference type, not the object type.

2. Static vs Dynamic Binding

Static Binding: Method or variable is determined at compile time based on the reference type.
Dynamic Binding: Method is determined at runtime based on the actual object.

3. Static Binding with Static Methods

Static methods are resolved at compile time because they belong to the class, not to a specific instance of the class. Therefore, method calls involving static methods use static binding.

Example of Static Binding with Static Methods:

class Parent {
    // Static method in the parent class
    public static void display() {
        System.out.println("Static method in Parent class");
    }
}

class Child extends Parent {
    // Static method in the child class
    public static void display() {
        System.out.println("Static method in Child class");
    }
}

public class StaticBindingExample {
    public static void main(String[] args) {
        Parent parent = new Parent();
        Parent child = new Child();

        // Static methods are bound at compile time, based on reference type
        parent.display();  // 
        Static method in Parent class
        child.display();   // 
        Static method in Parent class (not Child class)
    }
}

Explanation:

Static methods are bound based on the reference type (Parent), so both calls invoke the Parent class's display() method, even though the child reference points to a Child object.

Output:

Static method in Parent class
Static method in Parent class

4. Static Binding with Private Methods

Private methods are not inherited and cannot be overridden, so they are also resolved at compile time using static binding.

Example of Static Binding with Private Methods:

class Parent {
    // Private method in Parent class
    private void display() {
        System.out.println("Private method in Parent class");
    }

    public void callDisplay() {
        display();  // Calls Parent's private method
    }
}

class Child extends Parent {
    // This method is not overriding the Parent's method, it's a separate method
    private void display() {
        System.out.println("Private method in Child class");
    }
}

public class StaticBindingPrivateMethodExample {
    public static void main(String[] args) {
        Parent parent = new Parent();
        Parent child = new Child();

        // Private methods are resolved at compile time, based on reference type
        parent.callDisplay();  // 
        Private method in Parent class
        child.callDisplay();   // 
        Private method in Parent class
    }
}

Explanation:

The display() method is private in both Parent and Child. However, the callDisplay() method always calls the Parent class's private method because private methods are statically bound at compile time.

Output:

Private method in Parent class
Private method in Parent class

5. Static Binding with Final Methods

Final methods cannot be overridden, so method calls to final methods are resolved at compile time, using static binding.

Example of Static Binding with Final Methods:

class Parent {
    // Final method in Parent class
    public final void show() {
        System.out.println("Final method in Parent class");
    }
}

class Child extends Parent {
    // This method cannot override the Parent class's final method
    public void display() {
        System.out.println("Display method in Child class");
    }
}

public class StaticBindingFinalMethodExample {
    public static void main(String[] args) {
        Parent parent = new Parent();
        Parent child = new Child();

        // Final methods are bound at compile time, based on reference type
        parent.show();  // 
        Final method in Parent class
        child.show();   // 
        Final method in Parent class
    }
}

Explanation:

The show() method in the Parent class is final, so it cannot be overridden in the Child class. The method is resolved at compile time.

Output:

Final method in Parent class
Final method in Parent class

6. Static Binding with Variables

Variables (both static and non-static) are resolved based on the reference type, not the object type. This means variable references are statically bound at compile time.

Example of Static Binding with Variables:

class Parent {
    // Static variable
    public static String staticVar = "Static variable in Parent";
    
    // Instance variable
    public String instanceVar = "Instance variable in Parent";
}

class Child extends Parent {
    // Static variable
    public static String staticVar = "Static variable in Child";
    
    // Instance variable
    public String instanceVar = "Instance variable in Child";
}

public class StaticBindingVariablesExample {
    public static void main(String[] args) {
        Parent parent = new Parent();
        Parent child = new Child();

        // Static and instance variables are bound at compile time based on reference type
        System.out.println(parent.staticVar);  // 
        Static variable in Parent
        System.out.println(child.staticVar);   // 
        Static variable in Parent

        System.out.println(parent.instanceVar);  // 
        Instance variable in Parent
        System.out.println(child.instanceVar);   // 
        Instance variable in Parent
    }
}

Explanation:

Both staticVar and instanceVar are resolved based on the reference type (Parent), so even though child is pointing to a Child object, it still resolves to the variables in Parent.

Output:

Static variable in Parent
Static variable in Parent
Instance variable in Parent
Instance variable in Parent

7. Static Binding with Method Overloading

Method overloading in Java is resolved at compile time, meaning overloaded methods are statically bound.

Example of Static Binding with Method Overloading:

class Calculator {
    // Method to add two integers
    public int add(int a, int b) {
        return a + b;
    }

    // Overloaded method to add three integers
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

public class StaticBindingOverloadingExample {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();

        // Method overloading is resolved at compile time (static binding)
        int result1 = calculator.add(10, 20);            // Calls method with 2 parameters
        int result2 = calculator.add(10, 20, 30);        // Calls method with 3 parameters

        System.out.println("Result1: " + result1);  // 
        30
        System.out.println("Result2: " + result2);  // 
        60
    }
}

Explanation:

Method overloading is an example of static binding where the method to be executed is determined at compile time based on the method signature (parameter types and count).

Output:

Result1: 30
Result2: 60

8. Static Binding with Static Blocks

Static blocks in Java are also resolved using static binding since they are executed at class loading time.

Example of Static Binding with Static Blocks:

class StaticBlockExample {
    // Static block
    static {
        System.out.println("Static block is executed");
    }

    public static void display() {
        System.out.println("Static method is executed");
    }
}

public class StaticBindingBlockExample {
    public static void main(String[] args) {
        // Static block and method are bound at compile time
        StaticBlockExample.display();  // 
        Static block is executed (executed first), then Static method is executed
    }
}

Explanation:

Static blocks and static methods are both bound at compile time and executed when the class is loaded or when the method is invoked.

Output:

Static block is executed
Static method is executed

Conclusion

Static Binding in Java refers to the compile-time resolution of methods, variables, and static blocks. Static binding is applied to:

Static methods: Since they belong to the class rather than an object, they are resolved at compile time.
Private methods: As they cannot be overridden, they are bound to the class at compile time.
Final methods: These methods cannot be overridden, so they are resolved at compile time.
Variables: Both static and instance variables are resolved based on the reference type rather than the object type.

In contrast to dynamic binding, static binding ensures that method or variable calls are determined at compile time, providing predictability in how methods and variables are resolved. Understanding static binding helps in writing more predictable and efficient code, particularly when working with inheritance, method overriding, and polymorphism.

0 comment
0 FacebookTwitterPinterestEmail
OOP

Java Dynamic Binding Tutorial

written by 75ypsaw71

Dynamic Binding (also known as late binding or runtime polymorphism) refers to the process in which the method to be executed is determined at runtime rather than at compile time.

In Java, dynamic binding happens when you use method overriding, allowing a subclass to provide a specific implementation of a method that is already defined in its superclass.

Java uses dynamic binding to resolve overridden methods during runtime, enabling powerful polymorphic behavior. This feature plays a crucial role in achieving runtime polymorphism.

In this tutorial, we will explore dynamic binding, how it works with inheritance and polymorphism, and demonstrate it through multiple examples.

1. What is Dynamic Binding in Java?

Dynamic binding is the process by which the Java Virtual Machine (JVM) determines at runtime which version of an overridden method to call. This is different from static binding (or early binding), where the method call is resolved at compile time.

Key Points:

In dynamic binding, the method call is resolved at runtime based on the actual object (not the reference type) that invokes the method.
Only instance methods (non-static) are resolved through dynamic binding.
Dynamic binding enables runtime polymorphism where a superclass reference variable can refer to a subclass object and invoke the subclass's overridden method.

2. Static vs Dynamic Binding

Static Binding: The method call is resolved at compile time. It occurs in cases of method overloading, static methods, and private methods.
Dynamic Binding: The method call is resolved at runtime, based on the object being referred to. This happens with method overriding.

Example of Static Binding:

public class StaticBindingExample {
    public static void printMessage() {
        System.out.println("Static binding: Compile-time resolution");
    }

    public static void main(String[] args) {
        StaticBindingExample.printMessage();  // Resolved at compile-time
    }
}

Explanation:

The method printMessage() is static, so it is resolved at compile time (static binding).

Output:

Static binding: Compile-time resolution

3. Dynamic Binding with Method Overriding

Dynamic binding occurs with method overriding. When a method in a subclass overrides a method in the superclass, the decision about which method to execute is made at runtime based on the actual object.

Example of Dynamic Binding with Overriding:

class Animal {
    // Overridden method
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    // Overriding method
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

public class DynamicBindingExample {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();  // Animal reference, Animal object
        Animal myDog = new Dog();        // Animal reference, Dog object

        // Method call determined by the object type at runtime (Dynamic binding)
        myAnimal.sound();  // 
        Animal makes a sound
        myDog.sound();   		// 
        Dog barks
    }
}

Explanation:

The sound() method is overridden in the Dog class.
When myDog.sound() is called, it dynamically resolves to the Dog class's implementation, even though the reference type is Animal.

Output:

Animal makes a sound
Dog barks

4. Dynamic Binding with Polymorphism

Polymorphism allows one interface to be used for a general class of actions. In the context of dynamic binding, polymorphism refers to the ability of a superclass reference to refer to objects of subclass types, enabling dynamic method dispatch.

Example of Dynamic Binding with Polymorphism:

class Shape {
    public void draw() {
        System.out.println("Drawing a generic shape");
    }
}

class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

class Square extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a square");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        // Superclass reference pointing to different subclass objects
        Shape shape1 = new Circle();
        Shape shape2 = new Square();

        // Runtime polymorphism (Dynamic binding)
        shape1.draw();  // 
        Drawing a circle
        shape2.draw();  // 
        Drawing a square
    }
}

Explanation:

The draw() method is overridden in both Circle and Square subclasses.
The type of object (Circle or Square) is resolved at runtime, and the appropriate draw() method is called, demonstrating dynamic binding and polymorphism.

Output:

Drawing a circle
Drawing a square

5. Dynamic Binding and Casting

Sometimes, a superclass reference may be cast to a subclass reference. Casting does not change the actual object, so dynamic binding still occurs based on the actual object type.

Example of Dynamic Binding with Casting:

class Vehicle {
    public void start() {
        System.out.println("Starting a vehicle");
    }
}

class Car extends Vehicle {
    @Override
    public void start() {
        System.out.println("Starting a car");
    }

    public void accelerate() {
        System.out.println("Car is accelerating");
    }
}

public class CastingExample {
    public static void main(String[] args) {
        Vehicle vehicle = new Car();  // Vehicle reference, Car object

        // Dynamic binding for overridden method
        vehicle.start();  // 
        Starting a car

        // Downcasting to access subclass-specific method
        Car car = (Car) vehicle;
        car.accelerate();  // 
        Car is accelerating
    }
}

Explanation:

The start() method is overridden in Car, and dynamic binding occurs when the vehicle.start() method is called.
The reference vehicle is cast to Car, allowing the use of subclass-specific methods like accelerate().

Output:

Starting a car
Car is accelerating

6. Dynamic Binding with Abstract Classes

Dynamic binding also works with abstract classes. When a method in an abstract class is implemented in a subclass, the method call is dynamically bound to the subclass implementation at runtime.

Example of Dynamic Binding with Abstract Classes:

abstract class Animal {
    // Abstract method
    public abstract void sound();
}

class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Cat meows");
    }
}

class Cow extends Animal {
    @Override
    public void sound() {
        System.out.println("Cow moos");
    }
}

public class AbstractDynamicBindingExample {
    public static void main(String[] args) {
        Animal cat = new Cat();  // Animal reference, Cat object
        Animal cow = new Cow();  // Animal reference, Cow object

        // Dynamic binding for abstract method
        cat.sound();  // 
        Cat meows
        cow.sound();  // 
        Cow moos
    }
}

Explanation:

The sound() method is abstract in the Animal class.
The actual method call is determined at runtime based on the type of object (Cat or Cow), demonstrating dynamic binding with abstract classes.

Output:

Cat meows
Cow moos

7. Dynamic Binding with Interfaces

Dynamic binding works similarly with interfaces. When a method in an interface is implemented by a class, dynamic binding determines which implementation to call based on the actual object type.

Example of Dynamic Binding with Interfaces:

interface Payment {
    void pay();
}

class CreditCardPayment implements Payment {
    @Override
    public void pay() {
        System.out.println("Paying with credit card");
    }
}

class PaypalPayment implements Payment {
    @Override
    public void pay() {
        System.out.println("Paying with PayPal");
    }
}

public class InterfaceDynamicBindingExample {
    public static void main(String[] args) {
        Payment payment1 = new CreditCardPayment();  // Payment reference, CreditCardPayment object
        Payment payment2 = new PaypalPayment();      // Payment reference, PaypalPayment object

        // Dynamic binding for interface method
        payment1.pay();  // 
        Paying with credit card
        payment2.pay();  // 
        Paying with PayPal
    }
}

Explanation:

The Payment interface defines the pay() method.
The actual method implementation is determined at runtime based on the type of object (CreditCardPayment or PaypalPayment), demonstrating dynamic binding with interfaces.

Output:

Paying with credit card
Paying with PayPal

8. Dynamic Binding vs. Static Binding

While static binding (or early binding) occurs at compile time, dynamic binding happens at runtime. Methods like static methods, final methods, and private methods are resolved using static binding.

Example:

Static vs. Dynamic Binding

class StaticBindingExample {
    // Static method (Static Binding)
    public static void staticMethod() {
        System.out.println("Static binding: Compile-time resolution");
    }

    // Non-static method (Dynamic Binding)
    public void dynamicMethod() {
        System.out.println("Dynamic binding: Runtime resolution");
    }
}

public class BindingComparisonExample {
    public static void main(String[] args) {
        StaticBindingExample example = new StaticBindingExample();

        // Static binding (resolved at compile-time)
        example.staticMethod();

        // Dynamic binding (resolved at runtime)
        example.dynamicMethod();
    }
}

Explanation:

The staticMethod() is statically bound and resolved at compile time.
The dynamicMethod() is dynamically bound and resolved at runtime.

Output:

Static binding: Compile-time resolution
Dynamic binding: Runtime resolution

Conclusion

Dynamic Binding is a powerful concept in Java that allows for flexibility and reusability through runtime polymorphism. With dynamic binding, the JVM decides at runtime which method to execute based on the actual object type, not the reference type.

In this tutorial, we covered:

Static vs. Dynamic Binding.
Dynamic binding with method overriding.
How dynamic binding enables polymorphism.
How to use dynamic binding with casting, abstract classes, and interfaces.

By understanding dynamic binding, you can write flexible and extensible Java applications that leverage polymorphism and method overriding for more dynamic and runtime-specific behaviors.

0 comment
0 FacebookTwitterPinterestEmail
OOP

Java Method Overloading Tutorial

written by 75ypsaw71

Method overloading in Java allows a class to have more than one method with the same name, but with different parameter lists (either in the number of parameters or the type of parameters).

Overloaded methods provide flexibility and readability in your code by allowing the same method name to perform different actions based on the inputs.

In this tutorial, weโ€™ll explore method overloading with detailed explanations and code examples.

Key Rules for Method Overloading:

Different Number of Parameters: You can overload a method by changing the number of parameters.
Different Type of Parameters: You can overload a method by changing the type of parameters.
Order of Parameters: You can overload methods by changing the order of the parameters (if types differ).
Return Type Does Not Matter: Overloading is based on method signatures (method name + parameter list). Return type alone cannot be used to differentiate overloaded methods.

1. Method Overloading with Different Number of Parameters

You can overload a method by changing the number of parameters in the method signature.

Example:

Overloading with Different Parameter Count

public class Calculator {

    // Overloaded method with two parameters
    public int add(int a, int b) {
        return a + b;
    }

    // Overloaded method with three parameters
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        
        // Calling overloaded methods
        int result1 = calculator.add(10, 20);           // Calls method with 2 parameters
        int result2 = calculator.add(10, 20, 30);       // Calls method with 3 parameters
        
        System.out.println("Result1: " + result1);  //

Output:

 30
        System.out.println("Result2: " + result2);  //

Output:

 60
    }
}

Explanation:

The add() method is overloaded with two versions:
One method accepts two parameters.
Another method accepts three parameters.
The appropriate version is called based on the number of arguments provided.

Output:

Result1: 30
Result2: 60

2. Method Overloading with Different Parameter Types

You can overload a method by changing the types of parameters in the method signature.

Example:

Overloading with Different Parameter Types

public class Calculator {

    // Method to add two integers
    public int add(int a, int b) {
        return a + b;
    }

    // Method to add two doubles
    public double add(double a, double b) {
        return a + b;
    }

    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        
        // Calling overloaded methods with different parameter types
        int result1 = calculator.add(10, 20);              // Calls method with int parameters
        double result2 = calculator.add(10.5, 20.5);       // Calls method with double parameters
        
        System.out.println("Result1: " + result1);  //

Output:

 30
        System.out.println("Result2: " + result2);  //

Output:

 31.0
    }
}

Explanation:

The add() method is overloaded to work with both int and double parameters.
The version of add() that matches the argument types is invoked.

Output:

Result1: 30
Result2: 31.0

3. Method Overloading by Changing the Order of Parameters

You can overload methods by changing the order of parameters, provided they have different types.

Example:

Overloading by Changing the Order of Parameters

public class Display {

    // Method to display a string and an integer
    public void show(String text, int number) {
        System.out.println("String: " + text + ", Integer: " + number);
    }

    // Overloaded method with the order of parameters changed
    public void show(int number, String text) {
        System.out.println("Integer: " + number + ", String: " + text);
    }

    public static void main(String[] args) {
        Display display = new Display();
        
        // Calling overloaded methods with different parameter order
        display.show("Hello", 100);   // Calls method with (String, int)
        display.show(200, "World");   // Calls method with (int, String)
    }
}

Explanation:

The show() method is overloaded by changing the order of the parameters.
One method takes a String followed by an int, while the other takes an int followed by a String.

Output:

String: Hello, Integer: 100
Integer: 200, String: World

4. Method Overloading with Type Promotion

Java allows automatic type promotion when you pass a smaller data type to an overloaded method. For example, a byte can be automatically promoted to an int if no matching method with byte is found.

Example:

Overloading with Type Promotion

public class TypePromotionExample {

    // Method with int parameter
    public void show(int a) {
        System.out.println("int: " + a);
    }

    // Method with double parameter
    public void show(double a) {
        System.out.println("double: " + a);
    }

    public static void main(String[] args) {
        TypePromotionExample obj = new TypePromotionExample();
        
        // Passing a byte (which will be promoted to int)
        byte b = 10;
        obj.show(b);  //

Output:

 int: 10
        
        // Passing a float (which will call the double method)
        float f = 20.5f;
        obj.show(f);  //

Output:

 double: 20.5
    }
}

Explanation:

When a byte is passed, it is automatically promoted to int because thereโ€™s no show(byte) method.
When a float is passed, it is automatically promoted to double because thereโ€™s no show(float) method.

Output:

int: 10
double: 20.5

5. Overloading with Varargs (Variable Arguments)

You can overload a method that takes a variable number of arguments using varargs. Varargs are represented by three dots (…), and they allow you to pass multiple values to a method.

Example:

Overloading with Varargs

public class VarargsExample {

    // Method with variable number of int arguments
    public void show(int... numbers) {
        System.out.println("Varargs method with int arguments");
        for (int number : numbers) {
            System.out.print(number + " ");
        }
        System.out.println();
    }

    // Overloaded method with variable number of double arguments
    public void show(double... numbers) {
        System.out.println("Varargs method with double arguments");
        for (double number : numbers) {
            System.out.print(number + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        VarargsExample obj = new VarargsExample();
        
        // Calling overloaded methods with varargs
        obj.show(1, 2, 3, 4, 5);          // Calls method with int varargs
        obj.show(1.1, 2.2, 3.3);          // Calls method with double varargs
    }
}

Explanation:

The show() method is overloaded to handle both int… and double… arguments using varargs.
The appropriate version is called based on the argument types.

Output:

Varargs method with int arguments
1 2 3 4 5 
Varargs method with double arguments
1.1 2.2 3.3

6. Ambiguity in Method Overloading

Sometimes, method overloading can cause ambiguity if the compiler cannot determine which method to call. This usually happens when two methods can accept the same parameters due to type promotion.

Example:

Ambiguity in Overloading

public class AmbiguityExample {

    // Method with float parameter
    public void show(float a) {
        System.out.println("float: " + a);
    }

    // Method with double parameter
    public void show(double a) {
        System.out.println("double: " + a);
    }

    public static void main(String[] args) {
        AmbiguityExample obj = new AmbiguityExample();
        
        // Uncommenting the below line will cause ambiguity
        // obj.show(10);  // Compiler error: Ambiguous method call
    }
}

Explanation:

Both show(float) and show(double) methods could be called when passing 10 (an int), leading to ambiguity because int can be promoted to both float and double.
The compiler throws an error as it cannot decide which method to use.

Error Message:

Error: reference to show is ambiguous

7. Return Type Does Not Affect Overloading

The return type alone cannot differentiate overloaded methods. Methods must differ in parameter lists, not just return types.

Example:

Return Type Does Not Cause Overloading

public class InvalidOverloadingExample {

    // Method with int parameter and int return type
    public int show(int a) {
        return a;
    }

    // Invalid overloading: Only return type differs
    // public double show(int a) {
    //     return a;
    // }

    public static void main(String[] args) {
        InvalidOverloadingExample obj = new InvalidOverloadingExample();
        
        // Method overloading based on return type will cause an error
        // System.out.println(obj.show(10));
    }
}

Explanation:

Two methods cannot differ only by return type. The commented-out method will cause a compilation error if uncommented, as return type does not contribute to method overloading.

Conclusion

Method Overloading allows you to define multiple methods with the same name but with different parameter lists. It makes your code more readable and flexible by allowing you to perform similar operations with varying inputs. The key points to remember about method overloading in Java are:

Overloading is based on the number, type, and order of parameters.
Return type alone cannot distinguish overloaded methods.
You can overload methods using variable arguments (varargs).
Type promotion can sometimes lead to ambiguous method calls, causing compilation errors.

By understanding how method overloading works and using it effectively, you can make your Java programs more versatile and maintainable.

0 comment
0 FacebookTwitterPinterestEmail
Advanced

Java Thread Priority Tutorial

written by 75ypsaw71

In Java, each thread has a priority that helps the Thread Scheduler decide the order in which threads are executed. Thread priority is an integer value that ranges from 1 to 10, with the following constants defined in the Thread class:

Thread.MIN_PRIORITY = 1 (Lowest priority)
Thread.NORM_PRIORITY = 5 (Default priority)
Thread.MAX_PRIORITY = 10 (Highest priority)

Threads with higher priority are more likely to be executed before threads with lower priority, but thread priority is only a hint to the JVM and actual execution order is platform-dependent. Therefore, thread scheduling behavior might vary across different operating systems.

In this tutorial, we will explore how to set and use thread priorities in Java with several examples.

1. Understanding Thread Priority

By default, when a thread is created, it inherits the priority of the thread that created it. The priority can be changed using the setPriority() method, and you can retrieve a thread's priority using the getPriority() method.

Syntax for Setting and Getting Thread Priority

// Set thread priority
thread.setPriority(int priority);  // Priority between 1 and 10

// Get thread priority
int priority = thread.getPriority();

2. Creating a Thread with Priority

Hereโ€™s a basic example of setting thread priority in Java.

Example:

Setting and Getting Thread Priority

public class ThreadPriorityExample {
    public static void main(String[] args) {
        // Creating a thread with normal priority
        Thread thread1 = new Thread(() -> {
            System.out.println("Thread 1 Priority: " + Thread.currentThread().getPriority());
        });

        // Creating a thread with maximum priority
        Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 Priority: " + Thread.currentThread().getPriority());
        });

        // Setting priorities
        thread1.setPriority(Thread.NORM_PRIORITY); // 5 (Normal priority)
        thread2.setPriority(Thread.MAX_PRIORITY);  // 10 (Maximum priority)

        // Start both threads
        thread1.start();
        thread2.start();
    }
}

Explanation:

thread1 is set to normal priority (5), and thread2 is set to maximum priority (10).
getPriority() returns the priority of each thread, which is printed to the console.

Output:

Thread 1 Priority: 5
Thread 2 Priority: 10

3. Thread Priority with Multiple Threads

In this example, we create multiple threads with different priorities and observe the execution order.

Example:

Running Threads with Different Priorities

public class MultiThreadPriorityExample {
    public static void main(String[] args) {
        // Creating thread 1 (Low Priority)
        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) { System.out.println("Low Priority Thread (1): " + i); } }); // Creating thread 2 (Normal Priority) Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) { System.out.println("Normal Priority Thread (5): " + i); } }); // Creating thread 3 (High Priority) Thread thread3 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("High Priority Thread (10): " + i);
            }
        });

        // Setting thread priorities
        thread1.setPriority(Thread.MIN_PRIORITY);  // 1
        thread2.setPriority(Thread.NORM_PRIORITY); // 5
        thread3.setPriority(Thread.MAX_PRIORITY);  // 10

        // Start all threads
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

Explanation:

Thread 1 has the lowest priority (Thread.MIN_PRIORITY = 1).
Thread 2 has the default priority (Thread.NORM_PRIORITY = 5).
Thread 3 has the highest priority (Thread.MAX_PRIORITY = 10).
The order in which the threads are executed may differ depending on the underlying operating system and JVM implementation.

Sample Output (may vary):

High Priority Thread (10): 1
High Priority Thread (10): 2
High Priority Thread (10): 3
High Priority Thread (10): 4
High Priority Thread (10): 5
Normal Priority Thread (5): 1
Normal Priority Thread (5): 2
Normal Priority Thread (5): 3
Normal Priority Thread (5): 4
Normal Priority Thread (5): 5
Low Priority Thread (1): 1
Low Priority Thread (1): 2
Low Priority Thread (1): 3
Low Priority Thread (1): 4
Low Priority Thread (1): 5

Note: Higher-priority threads (thread3) are more likely to run first, but this is not guaranteed since thread scheduling depends on the JVM and operating system.

4. Effect of Thread Priority in Multithreaded Programs

Thread priorities can influence the thread scheduling, but priorities are platform-dependent and do not guarantee strict control over the thread execution order. In this example, we create more threads and observe how priorities might affect the execution.

Example:

Thread Priority with Multiple Threads Running Simultaneously

public class ComplexThreadPriorityExample {
    public static void main(String[] args) {
        // Creating 5 threads with different priorities
        for (int i = 1; i <= 5; i++) { final int threadNumber = i; Thread thread = new Thread(() -> {
                for (int j = 1; j <= 3; j++) {
                    System.out.println("Thread " + threadNumber + " is running. Iteration: " + j);
                }
            });

            // Set thread priority based on threadNumber
            if (threadNumber == 1) {
                thread.setPriority(Thread.MIN_PRIORITY); // Lowest priority
            } else if (threadNumber == 5) {
                thread.setPriority(Thread.MAX_PRIORITY); // Highest priority
            } else {
                thread.setPriority(Thread.NORM_PRIORITY); // Normal priority
            }

            // Start the thread
            thread.start();
        }
    }
}

Explanation:

We create 5 threads, each with different priorities: thread 1 gets the lowest priority, thread 5 gets the highest priority, and the others get normal priority.
Output can vary based on the platform and JVM, but higher-priority threads are more likely to run first.

Sample Output (may vary):

Thread 5 is running. Iteration: 1
Thread 5 is running. Iteration: 2
Thread 5 is running. Iteration: 3
Thread 2 is running. Iteration: 1
Thread 2 is running. Iteration: 2
Thread 2 is running. Iteration: 3
Thread 3 is running. Iteration: 1
Thread 3 is running. Iteration: 2
Thread 3 is running. Iteration: 3
Thread 4 is running. Iteration: 1
Thread 4 is running. Iteration: 2
Thread 4 is running. Iteration: 3
Thread 1 is running. Iteration: 1
Thread 1 is running. Iteration: 2
Thread 1 is running. Iteration: 3

5. Limitations of Thread Priority

While thread priority can influence the order in which threads are executed, it is important to understand its limitations:

Platform-Dependent: Thread priorities are only hints to the JVM. Different operating systems may handle thread priorities differently, so behavior may vary across platforms.
No Strict Guarantees: Even with different priorities, the execution order of threads is not guaranteed. Other factors, such as the number of available CPUs and system load, can affect thread scheduling.
Too Many High-Priority Threads: If too many threads have the highest priority, it can lead to starvation of lower-priority threads.

Example:

Overloading the Scheduler with High-Priority Threads

public class StarvationExample {
    public static void main(String[] args) {
        // High-priority threads
        for (int i = 1; i <= 3; i++) { Thread highPriorityThread = new Thread(() -> {
                for (int j = 1; j <= 5; j++) { System.out.println(Thread.currentThread().getName() + " (High Priority) is running."); } }); highPriorityThread.setPriority(Thread.MAX_PRIORITY); highPriorityThread.setName("High-Priority Thread " + i); highPriorityThread.start(); } // Low-priority thread Thread lowPriorityThread = new Thread(() -> {
            for (int j = 1; j <= 5; j++) {
                System.out.println(Thread.currentThread().getName() + " (Low Priority) is running.");
            }
        });
        lowPriorityThread.setPriority(Thread.MIN_PRIORITY);
        lowPriorityThread.setName("Low-Priority Thread");
        lowPriorityThread.start();
    }
}

Explanation:

Three high-priority threads are created alongside one low-priority thread.
The low-priority thread might not get enough CPU time due to the dominance of high-priority threads, leading to thread starvation.

Sample Output (may vary):

High-Priority Thread 1 (High Priority) is running.
High-Priority Thread 2 (High Priority) is running.
High-Priority Thread 3 (High Priority) is running.
...
(Low-priority thread may get very little or no CPU time, depending on the system load and JVM)

6. Best Practices with Thread Priority

Use Default Priority When Possible: Unless necessary, stick to the default priority (NORM_PRIORITY = 5) to avoid unexpected behavior across different systems.
Avoid Overusing High Priority: Overloading the scheduler with many high-priority threads can cause lower-priority threads to starve, resulting in poor performance and responsiveness.
Test on Different Platforms: Since thread scheduling behavior can vary between platforms, test your multithreaded application on different operating systems to ensure consistent behavior.
Handle Concurrency Properly: Use proper synchronization mechanisms (such as wait(), notify(), and notifyAll() or Lock objects) instead of relying solely on thread priority to manage execution order.

Conclusion

Thread priority in Java gives you a way to suggest the relative importance of different threads to the JVM's thread scheduler. However, thread priority does not guarantee strict control over thread execution order, and it is heavily dependent on the underlying operating system.

In this tutorial, we covered:

How to set and get thread priority.
How thread priority can influence the order of execution in multithreaded programs.
The limitations of thread priority and how it can lead to issues like thread starvation.
Best practices when using thread priority to ensure reliable and maintainable multithreaded applications.

By understanding thread priority and the underlying system behavior, you can write more efficient and responsive multithreaded applications in Java.

0 comment
0 FacebookTwitterPinterestEmail
Advanced

Java Thread Scheduler Tutorial

written by 75ypsaw71

In Java, Thread Scheduler is part of the JVM (Java Virtual Machine) responsible for determining which thread runs at any given time. The Thread Scheduler uses thread priorities and the underlying operating system's scheduling mechanisms to decide how threads are managed and executed.

While Java does not provide direct control over the Thread Scheduler, you can influence how threads behave using thread priorities and other concurrency control mechanisms. It's important to note that the actual scheduling behavior is platform-dependent, meaning different operating systems may handle thread scheduling differently.

In this tutorial, we will explore how Java threads work with the Thread Scheduler, how to use thread priorities, and how to manage thread behavior with code examples.

1. Introduction to Thread Scheduling

Java provides a preemptive scheduling model where each thread competes for CPU time based on thread priority. The thread scheduler decides which thread runs at any given time, and threads may be:

Running: Currently executing.
Runnable: Ready to run, waiting for CPU time.
Blocked/Waiting: Paused, waiting for a resource or event.
Java threads can be preempted (interrupted by higher-priority threads), or they may yield (voluntarily give up the CPU).

2. Setting Thread Priority

Each thread in Java has a priority value between 1 and 10, where:

Thread.MIN_PRIORITY = 1 (lowest priority)
Thread.NORM_PRIORITY = 5 (default priority)
Thread.MAX_PRIORITY = 10 (highest priority)
Higher-priority threads are more likely to be chosen by the scheduler to run first. However, thread priorities are just hints to the scheduler, and actual behavior can vary based on the operating system.

Example of Setting Thread Priority:

public class ThreadPriorityExample {
    public static void main(String[] args) {
        // Creating two threads with different priorities
        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) { System.out.println("Thread 1 (Priority: " + Thread.currentThread().getPriority() + ") - Count: " + i); } }); Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Thread 2 (Priority: " + Thread.currentThread().getPriority() + ") - Count: " + i);
            }
        });

        // Setting thread priorities
        thread1.setPriority(Thread.MIN_PRIORITY);  // Lowest priority (1)
        thread2.setPriority(Thread.MAX_PRIORITY);  // Highest priority (10)

        // Starting the threads
        thread1.start();
        thread2.start();
    }
}

Explanation:

thread1 is set to the lowest priority using setPriority(Thread.MIN_PRIORITY).
thread2 is set to the highest priority using setPriority(Thread.MAX_PRIORITY).
The output may show that thread2 is more likely to finish before thread1, but this behavior can vary depending on the system.

Output (may vary based on OS and JVM):

Thread 2 (Priority: 10) - Count: 1
Thread 2 (Priority: 10) - Count: 2
Thread 2 (Priority: 10) - Count: 3
Thread 2 (Priority: 10) - Count: 4
Thread 2 (Priority: 10) - Count: 5
Thread 1 (Priority: 1) - Count: 1
Thread 1 (Priority: 1) - Count: 2
Thread 1 (Priority: 1) - Count: 3
Thread 1 (Priority: 1) - Count: 4
Thread 1 (Priority: 1) - Count: 5

3. The yield() Method

The Thread.yield() method is a hint to the scheduler that the current thread is willing to yield (pause) and allow other threads to execute. This is useful for creating more cooperative multithreading but does not guarantee any specific behavior.

Example of Using yield():

public class YieldExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) { System.out.println("Thread 1 (yielding)"); Thread.yield(); // Yielding to allow other threads to execute } }); Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Thread 2 (running)");
            }
        });

        // Starting both threads
        thread1.start();
        thread2.start();
    }
}

Explanation:

Thread.yield() allows thread1 to suggest that other threads (e.g., thread2) run.
thread1 will give up the CPU, but there is no guarantee that thread2 will immediately runโ€”it depends on the scheduler.

Output (may vary):

Thread 1 (yielding)
Thread 2 (running)
Thread 1 (yielding)
Thread 2 (running)
Thread 2 (running)
Thread 2 (running)
Thread 2 (running)
Thread 1 (yielding)

4. The sleep() Method

The Thread.sleep() method pauses the execution of the current thread for a specified period (in milliseconds). During this time, the thread is in a sleeping state and does not consume CPU resources.

Example of Using sleep():

public class SleepExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Thread is running: Count " + i);
                try {
                    Thread.sleep(1000);  // Sleep for 1 second
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // Starting the thread
        thread.start();
    }
}

Explanation:

The Thread.sleep(1000) pauses the thread for 1 second between iterations.
The InterruptedException must be handled in case the thread is interrupted while sleeping.

Output (1-second delay between each print):

Thread is running: Count 1
Thread is running: Count 2
Thread is running: Count 3
Thread is running: Count 4
Thread is running: Count 5

5. The join() Method

The join() method allows one thread to wait for another thread to complete before continuing its execution. This is useful when you need to ensure that a certain thread finishes before others.

Example of Using join():

public class JoinExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 3; i++) { System.out.println("Thread 1 running..."); try { Thread.sleep(500); // Sleep for 0.5 second } catch (InterruptedException e) { e.printStackTrace(); } } }); Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 waiting for thread 1 to finish...");
            try {
                thread1.join();  // Wait for thread1 to finish
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 started after thread 1.");
        });

        // Start thread1 and thread2
        thread1.start();
        thread2.start();
    }
}

Explanation:

thread2 will wait for thread1 to finish before it proceeds, thanks to the join() method.

Output:

Thread 2 waiting for thread 1 to finish...
Thread 1 running...
Thread 1 running...
Thread 1 running...
Thread 2 started after thread 1.

6. Thread State

Java threads have different states, and these states represent the lifecycle of a thread:

NEW: A thread that has not yet started.
RUNNABLE: A thread that is ready to run or currently running.
BLOCKED: A thread that is blocked and waiting to acquire a lock.
WAITING: A thread that is waiting indefinitely for another thread to perform an action.
TIMED_WAITING: A thread that is waiting for a specified time.
TERMINATED: A thread that has finished execution.

Example of Checking Thread State:

public class ThreadStateExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Thread is running");
        });

        // Checking thread state before starting
        System.out.println("Thread state: " + thread.getState());  // NEW

        // Start the thread
        thread.start();

        // Checking thread state after starting
        System.out.println("Thread state: " + thread.getState());  // RUNNABLE (may vary)

        // Sleep to ensure the thread finishes
        try {
            Thread.sleep(100);  // Wait for the thread to finish
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Checking thread state after execution
        System.out.println("Thread state: " + thread.getState());  // TERMINATED
    }
}

Explanation:

You can check the state of a thread using the getState() method.

Output (may vary depending on thread execution):

Thread state: NEW
Thread state: RUNNABLE
Thread is running
Thread state: TERMINATED

7. Thread Yielding vs. Sleeping

While both yield() and sleep() affect the thread's execution, there are key differences:

yield(): Suggests the thread scheduler give other threads a chance to run, but the current thread may continue running if no other thread is ready.
sleep(): Pauses the current thread for a specified time and guarantees that the thread will not run during that period.

8. Thread Scheduler Behavior (Platform Dependency)

The Java Thread Scheduler relies on the underlying operating system's scheduling algorithm, which can differ between platforms (e.g., Windows, Linux, macOS). Therefore, thread priority and other scheduling behaviors can vary.

Windows: Typically uses a time-slicing mechanism where each thread is given a time slot (quantum) to execute.
Linux: Uses fair scheduling and prioritizes based on various factors, including thread priorities and resource needs.
While Java provides APIs to influence thread behavior, the exact scheduling is not guaranteed and depends on the JVM and OS.

Conclusion

Java's Thread Scheduler determines the execution order of threads in a concurrent environment, but it offers limited direct control over how threads are scheduled. Key concepts include:

Thread Priority: You can suggest the relative importance of a thread using priorities, but behavior is platform-dependent.
yield(): A way to suggest that the current thread allows others to run.
sleep(): Pauses a thread for a specific time period, relinquishing the CPU.
join(): Ensures one thread waits for another thread to finish before continuing.
Thread States: Understanding the lifecycle of a thread is critical to managing concurrency.

By leveraging these tools, you can effectively manage thread execution and influence the behavior of the JVM's thread scheduler, although the final decisions are made by the underlying operating system.

0 comment
0 FacebookTwitterPinterestEmail
Basics

Java Enums Tutorial

written by 75ypsaw71

In Java, Enum (short for Enumeration) is a special data type that represents a fixed set of constants. Enums provide a way to define a collection of related constants in a more readable, structured, and type-safe manner.

Enums can have fields, methods, and constructors, making them more powerful than regular constants.

This tutorial covers how to use enums in Java with several code examples to help you understand how to define and use them effectively.

1. Defining a Simple Enum

To define an enum in Java, use the enum keyword, followed by the enum name and a list of constants.

Example:

public enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}

Explanation:

Day is an enum with seven constants: SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, and SATURDAY.
Enums are implicitly public, static, and final.

2. Using Enums in a Switch Statement

Enums can be used in switch statements just like primitive types such as int or char. This provides a clean and type-safe way to handle a set of related constants.

Example:

public class EnumSwitchExample {
    public enum Day {
        SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
    }

    public static void main(String[] args) {
        Day today = Day.WEDNESDAY;

        switch (today) {
            case MONDAY:
                System.out.println("Start of the work week!");
                break;
            case WEDNESDAY:
                System.out.println("Midweek.");
                break;
            case FRIDAY:
                System.out.println("End of the work week.");
                break;
            case SUNDAY:
            case SATURDAY:
                System.out.println("Weekend!");
                break;
            default:
                System.out.println("Weekday.");
        }
    }
}

Explanation:

Day enum is used in the switch statement to print different messages based on the day.

Output:
Midweek. (because the current day is WEDNESDAY).

3. Enum with Fields, Methods, and Constructors

Enums can have fields, methods, and constructors to store additional data and behavior. This makes enums more flexible and useful in real-world applications.

Example:

public enum Planet {
    MERCURY(3.303e+23, 2.4397e6),
    VENUS(4.869e+24, 6.0518e6),
    EARTH(5.976e+24, 6.37814e6),
    MARS(6.421e+23, 3.3972e6);

    // Fields
    private final double mass;   // In kilograms
    private final double radius; // In meters

    // Constructor
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }

    // Method to calculate the surface gravity
    public double surfaceGravity() {
        double G = 6.67300E-11;  // Universal gravitational constant (m^3 kg^-1 s^-2)
        return G * mass / (radius * radius);
    }

    public double getMass() {
        return mass;
    }

    public double getRadius() {
        return radius;
    }
}

public class PlanetExample {
    public static void main(String[] args) {
        for (Planet planet : Planet.values()) {
            System.out.println("Planet: " + planet + ", Surface Gravity: " + planet.surfaceGravity());
        }
    }
}

Explanation:

The Planet enum contains constants with associated mass and radius values.
The surfaceGravity() method calculates and returns the surface gravity of each planet.
The values() method returns all enum constants in an array for iteration.

Output:

Planet: MERCURY, Surface Gravity: 3.7030267229659395
Planet: VENUS, Surface Gravity: 8.871391908774457
Planet: EARTH, Surface Gravity: 9.802652743337129
Planet: MARS, Surface Gravity: 3.7126290961053403

4. Enum with Overridden Methods

Enums can override methods, and you can give each constant its own implementation of the method. This is useful when you want each constant to behave differently.

Example:

public enum Operation {
    PLUS {
        public double apply(double x, double y) {
            return x + y;
        }
    },
    MINUS {
        public double apply(double x, double y) {
            return x - y;
        }
    },
    MULTIPLY {
        public double apply(double x, double y) {
            return x * y;
        }
    },
    DIVIDE {
        public double apply(double x, double y) {
            return x / y;
        }
    };

    // Abstract method
    public abstract double apply(double x, double y);
}

public class OperationExample {
    public static void main(String[] args) {
        double x = 10.0;
        double y = 5.0;

        for (Operation op : Operation.values()) {
            System.out.println(x + " " + op + " " + y + " = " + op.apply(x, y));
        }
    }
}

Explanation:

Each constant in the Operation enum overrides the apply() method to perform its specific operation.
PLUS, MINUS, MULTIPLY, and DIVIDE provide their own implementations for apply().

Output:

10.0 PLUS 5.0 = 15.0
10.0 MINUS 5.0 = 5.0
10.0 MULTIPLY 5.0 = 50.0
10.0 DIVIDE 5.0 = 2.0

5. Enum Methods

Java enums come with several built-in methods that provide additional functionality:

values(): Returns an array of all enum constants.
valueOf(String name): Returns the enum constant with the specified name.
ordinal(): Returns the position of the enum constant in its declaration (index starting from 0).
name(): Returns the name of the enum constant as a String.

Example:

public enum Color {
    RED, GREEN, BLUE
}

public class EnumMethodsExample {
    public static void main(String[] args) {
        // Using values() method
        for (Color color : Color.values()) {
            System.out.println(color + " is at index " + color.ordinal());
        }

        // Using valueOf() method
        Color selectedColor = Color.valueOf("RED");
        System.out.println("Selected color: " + selectedColor);
    }
}

Explanation:

The values() method returns an array of all constants in the Color enum.
The ordinal() method returns the position of each enum constant.
The valueOf() method retrieves the enum constant by name.

Output:

RED is at index 0
GREEN is at index 1
BLUE is at index 2
Selected color: RED

6. Enum with Interfaces

Enums can implement interfaces, which allows you to define common behavior for all enum constants.

Example:

interface Printable {
    void print();
}

public enum Shape implements Printable {
    CIRCLE {
        public void print() {
            System.out.println("This is a circle.");
        }
    },
    SQUARE {
        public void print() {
            System.out.println("This is a square.");
        }
    },
    TRIANGLE {
        public void print() {
            System.out.println("This is a triangle.");
        }
    }
}

public class InterfaceInEnumExample {
    public static void main(String[] args) {
        for (Shape shape : Shape.values()) {
            shape.print();  // Calling the method implemented in the enum
        }
    }
}

Explanation:

The Shape enum implements the Printable interface, requiring each enum constant to provide its own implementation of the print() method.

Output:

This is a circle.
This is a square.
This is a triangle.

7. Enum with Custom Methods

Enums can have custom methods just like regular classes. These methods can be used to add functionality specific to the enum constants.

Example:

public enum TrafficLight {
    RED(30), GREEN(60), YELLOW(5);

    // Field to store duration of each light
    private final int duration;

    // Constructor to initialize the duration
    TrafficLight(int duration) {
        this.duration = duration;
    }

    // Custom method to get the duration
    public int getDuration() {
        return duration;
    }

    // Method to display the traffic light
    public void displayLight() {
        System.out.println(this.name() + " light for " + duration + " seconds.");
    }
}

public class TrafficLightExample {
    public static void main(String[] args) {
        for (TrafficLight light : TrafficLight.values()) {
            light.displayLight();  // Calling custom method for each enum constant
        }
    }
}

Explanation:

Each traffic light has a duration, passed to the constructor when the enum is initialized.
The displayLight() method provides a custom message for each traffic light.

Output:

RED light for 30 seconds.
GREEN light for 60 seconds.
YELLOW light for 5 seconds.

8. Enum Comparison

Enum constants can be compared using == and equals(), since they are singleton instances.

Example:

public class EnumComparisonExample {
    public enum Size {
        SMALL, MEDIUM, LARGE
    }

    public static void main(String[] args) {
        Size size1 = Size.MEDIUM;
        Size size2 = Size.MEDIUM;
        Size size3 = Size.LARGE;

        // Comparing enums using ==
        System.out.println(size1 == size2);  // true
        System.out.println(size1 == size3);  // false

        // Comparing enums using equals()
        System.out.println(size1.equals(size2));  // true
        System.out.println(size1.equals(size3));  // false
    }
}

Explanation:

Enums are compared using == because they are effectively singletons, meaning each constant is a single instance.

Output:

true
false
true
false

Conclusion

Java enums are more than just collections of constants. They are full-featured objects that can have fields, methods, and even constructors.

They are often used for defining a fixed set of constants, but their ability to implement interfaces, have methods, and work with switch statements makes them powerful tools for building robust and readable code.

In this tutorial, we covered:

Basic enum definition and usage.
Using enums in switch statements.
Enums with fields, methods, and constructors.
Overriding methods in enums.
Built-in enum methods (values(), valueOf(), ordinal()).
Enum comparison and enums implementing interfaces.

With this knowledge, you can leverage enums to make your Java applications more efficient and type-safe.

0 comment
0 FacebookTwitterPinterestEmail
Advanced

Java Singleton Design Pattern Tutorial

written by 75ypsaw71

A Singleton class in Java is a class that allows only one instance of itself to be created throughout the lifetime of the application.

The Singleton design pattern is useful when you need exactly one object to coordinate actions across the system, such as managing a database connection, logging, or controlling access to shared resources.

In this tutorial, we will explore different ways to implement a Singleton class in Java, with various code examples demonstrating the best practices.

Key Features of a Singleton Class:

Private Constructor: The constructor is made private to prevent direct instantiation from outside the class.
Static Instance: The class holds a static instance of itself.
Global Access: A public static method provides a global point of access to the instance.

1. Eager Initialization Singleton

In eager initialization, the instance of the Singleton class is created at the time of class loading. This is the simplest method to create a Singleton, but it may lead to resource wastage if the instance is never used.

Example:

public class EagerSingleton {
    // Static instance of the Singleton class, created eagerly
    private static final EagerSingleton INSTANCE = new EagerSingleton();

    // Private constructor to prevent instantiation
    private EagerSingleton() {
        System.out.println("EagerSingleton instance created");
    }

    // Public method to provide access to the instance
    public static EagerSingleton getInstance() {
        return INSTANCE;
    }
}

public class Main {
    public static void main(String[] args) {
        // Accessing the Singleton instance
        EagerSingleton singleton = EagerSingleton.getInstance();
    }
}

Explanation:

The INSTANCE is created at class loading time.
The getInstance() method provides global access to the Singleton instance.

Output:

EagerSingleton instance created (printed only once).

2. Lazy Initialization Singleton

In lazy initialization, the instance is created only when it is needed, i.e., when getInstance() is called for the first time. This can save resources if the instance is never used.

Example:

public class LazySingleton {
    // Static instance of the Singleton class, not initialized initially
    private static LazySingleton instance;

    // Private constructor to prevent instantiation
    private LazySingleton() {
        System.out.println("LazySingleton instance created");
    }

    // Public method to provide access to the instance, creating it lazily
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        // Accessing the Singleton instance
        LazySingleton singleton = LazySingleton.getInstance();
    }
}

Explanation:

The instance is created lazily when getInstance() is first called.
The instance is created only if instance == null.

Output:
LazySingleton instance created.

3. Thread-Safe Singleton (Synchronized)

To make the Singleton thread-safe, we can synchronize the getInstance() method so that only one thread can execute it at a time. This prevents race conditions in multithreaded environments.

Example:

public class ThreadSafeSingleton {
    // Static instance of the Singleton class, not initialized initially
    private static ThreadSafeSingleton instance;

    // Private constructor to prevent instantiation
    private ThreadSafeSingleton() {
        System.out.println("ThreadSafeSingleton instance created");
    }

    // Synchronized method to ensure thread safety
    public static synchronized ThreadSafeSingleton getInstance() {
        if (instance == null) {
            instance = new ThreadSafeSingleton();
        }
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        // Accessing the Singleton instance
        ThreadSafeSingleton singleton = ThreadSafeSingleton.getInstance();
    }
}

Explanation:

The synchronized keyword ensures that only one thread can create the instance.
This prevents multiple threads from creating multiple instances.

Output:
ThreadSafeSingleton instance created.

4. Double-Checked Locking Singleton

The double-checked locking technique reduces the overhead of synchronization by only synchronizing the block of code that creates the instance, rather than the entire method. This is more efficient than synchronizing the entire method.

Example:

public class DoubleCheckedLockingSingleton {
    // Static instance of the Singleton class, using volatile to ensure visibility across threads
    private static volatile DoubleCheckedLockingSingleton instance;

    // Private constructor to prevent instantiation
    private DoubleCheckedLockingSingleton() {
        System.out.println("DoubleCheckedLockingSingleton instance created");
    }

    // Double-checked locking for thread-safe and efficient Singleton
    public static DoubleCheckedLockingSingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckedLockingSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckedLockingSingleton();
                }
            }
        }
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        // Accessing the Singleton instance
        DoubleCheckedLockingSingleton singleton = DoubleCheckedLockingSingleton.getInstance();
    }
}

Explanation:

The volatile keyword ensures that the instance variable is read from the main memory, not from the thread's local cache.
The first if check prevents unnecessary synchronization, and the second if ensures that the instance is only created once.

Output:
DoubleCheckedLockingSingleton instance created.

5. Bill Pugh Singleton (Inner Static Helper Class)

This method is considered one of the best ways to implement a Singleton in Java. It takes advantage of Java's class loading mechanism to ensure that the Singleton is created only when needed, without the need for synchronization.

Example:

public class BillPughSingleton {
    // Private constructor to prevent instantiation
    private BillPughSingleton() {
        System.out.println("BillPughSingleton instance created");
    }

    // Inner static helper class responsible for holding the Singleton instance
    private static class SingletonHelper {
        // The Singleton instance is created when this class is loaded
        private static final BillPughSingleton INSTANCE = new BillPughSingleton();
    }

    // Public method to provide access to the Singleton instance
    public static BillPughSingleton getInstance() {
        return SingletonHelper.INSTANCE;
    }
}

public class Main {
    public static void main(String[] args) {
        // Accessing the Singleton instance
        BillPughSingleton singleton = BillPughSingleton.getInstance();
    }
}

Explanation:

The SingletonHelper class is not loaded until getInstance() is called, ensuring lazy initialization.
This approach is thread-safe without requiring synchronization.

Output:
BillPughSingleton instance created.

6. Enum Singleton

Using an enum to implement a Singleton is the most robust way, as it provides thread safety, serialization safety, and guarantees that only one instance will be created.

Example:

public enum EnumSingleton {
    INSTANCE;  // The single instance

    public void doSomething() {
        System.out.println("Enum Singleton is working!");
    }
}

public class Main {
    public static void main(String[] args) {
        // Accessing the Singleton instance
        EnumSingleton singleton = EnumSingleton.INSTANCE;
        singleton.doSomething();
    }
}

Explanation:

The INSTANCE is the single instance of EnumSingleton.
Enum-based Singleton ensures that only one instance is created, even in multithreaded environments or when dealing with serialization.

Output:
Enum Singleton is working!.

7. Singleton with Reflection Safe

One of the drawbacks of using traditional Singleton methods is that reflection can break the Singleton pattern by allowing multiple instances to be created. To prevent this, you can add a check in the constructor.

Example:

public class ReflectionSafeSingleton {
    // Static instance of the Singleton class
    private static ReflectionSafeSingleton instance;

    // Private constructor to prevent instantiation
    private ReflectionSafeSingleton() {
        // Prevent reflection from breaking Singleton
        if (instance != null) {
            throw new RuntimeException("Cannot create instance using reflection");
        }
        System.out.println("ReflectionSafeSingleton instance created");
    }

    // Public method to provide access to the instance
    public static ReflectionSafeSingleton getInstance() {
        if (instance == null) {
            instance = new ReflectionSafeSingleton();
        }
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        // Accessing the Singleton instance
        ReflectionSafeSingleton singleton = ReflectionSafeSingleton.getInstance();
    }
}

Explanation:

The constructor checks if an instance already exists, and if it does, it throws an exception to prevent reflection-based instantiation.

Output:
ReflectionSafeSingleton instance created.

8. Singleton with Serialization Protection

When a Singleton class implements Serializable, it can create new instances during deserialization. To prevent this, override the readResolve() method to return the same instance.

Example:

import java.io.Serializable;

public class SerializedSingleton implements Serializable {
    private static final long serialVersionUID = 1L;

    // Static instance of the Singleton class
    private static final SerializedSingleton INSTANCE = new SerializedSingleton();

    // Private constructor to prevent instantiation
    private SerializedSingleton() {
        System.out.println("SerializedSingleton instance created");
    }

    // Public method to provide access to the instance
    public static SerializedSingleton getInstance() {
        return INSTANCE;
    }

    // readResolve method to prevent creating a new instance during deserialization
    protected Object readResolve() {
        return getInstance();
    }
}

public class Main {
    public static void main(String[] args) {
        // Accessing the Singleton instance
        SerializedSingleton singleton = SerializedSingleton.getInstance();
    }
}

Explanation:

The readResolve() method ensures that the same instance is returned during deserialization.

Output:
SerializedSingleton instance created.

Conclusion

The Singleton design pattern ensures that only one instance of a class is created and provides global access to that instance. In Java, there are several ways to implement the Singleton pattern:

Eager Initialization: The instance is created when the class is loaded.
Lazy Initialization: The instance is created when it is first accessed.
Thread-Safe Singleton: The synchronized keyword ensures only one thread creates the instance.
Double-Checked Locking: Minimizes the cost of synchronization with a double check.
Bill Pugh Singleton: Inner static class provides a lazy-loaded thread-safe Singleton.
Enum Singleton: The most robust and straightforward implementation.
Reflection and Serialization Safe: Methods to protect against breaking the Singleton pattern with reflection or serialization.

By choosing the appropriate method for your application's needs, you can implement Singleton classes effectively in Java.

0 comment
0 FacebookTwitterPinterestEmail
Newer Posts
Older Posts