Autoboxing, Enum, Generics, Varargs Methods - Coffee V Features Quick Overview

What is Autoboxing , Generics, Enum in addition to Varargs method inwards Java 5
Java five introduces Autoboxing, Generics, varargs in addition to Enum along amongst several other features in addition to improvement. It's been few years when Java programming linguistic communication was enhanced amongst these features but nonetheless Java programmer affair Autoboxing, Enum, Generics or Variable arguments equally an advanced characteristic in addition to afraid to larn them. They are really much utilisation of Java fundamentals but similar Abstraction, Inheritance, Encapsulation in addition to Polymorphism are utilisation of Object oriented programming concepts. It's of import to empathize what are these characteristic in addition to How to utilisation them, fifty-fifty if y'all don't utilisation them inwards your code, y'all may create got to last on individual else code which is written inwards Java five in addition to uses Generics Collection, Autoboxing quite frequently. In this Java five tutorial, nosotros volition come across the brief overview of Java five features similar Generics, Enum, Autoboxing in addition to unboxing in addition to variable arguments methods along amongst examples in addition to explanations.



What is Autoboxing inwards Java
First starts amongst Autoboxing characteristic of Java 5 which allows a programmer to forget nearly converting primitive to wrapper shape code. Autoboxing agency Java compiler volition automatically convert primitive to object wherever necessary.

For example, if y'all are writing a method which accepts an int declaration in addition to y'all are passing an Integer object, Unlike previous Java version,  Java compiler volition non throw any compile fourth dimension error, Instead, it volition convert Integer to int past times using unboxing inwards Java.

On the other hand, if method appear a Double Object equally an declaration in addition to y'all exceed double primitive hence Java volition convert primitive to a Double object using Autoboxing inwards Java. See What is Autoboxing inwards Java - Example corner cases  for to a greater extent than information in addition to detailed instance of how to utilisation autoboxing inwards Java.

One of the points which is worth noting spell using autoboxing inwards Java five code is non mixing primitive amongst an object spell comparison amongst equals objects, this may give y'all unpredictable results, come across What is the work spell using "==" amongst autoboxing inwards Java 5 for consummate details  on actual problem.




What is Generics inwards Java
Generics is closed to other high-value add-on inwards Java programming linguistic communication added on JDK 5. Generics provides compile fourth dimension type-safety in addition to reducing run a peril on ClassCastException in Java. By using Generics inwards Java, y'all tin notice type-safety related fault compile timer rather than acquire them at runtime. You tin likewise utilisation Generics wildcards inwards Java to write improve type-safe API methods. Generics industrial plant on the regulation of type-erasure, which erases all type information during compile time. for to a greater extent than details come across How Generics industrial plant inwards Java. If y'all are preparing for whatsoever Java five interview in addition to looking for closed to interview questions on Generics, hence this listing of Java Generics inquiry volition aid y'all to prepare better.

What is Enum inwards Java
Enum is a way to stand upwards for fixed laid of well-known values inwards Java e.g. publish of days inwards a week, states of water, publish of months inwards a calendar yr etc. After Generics, Enum is my minute favorite introduced inwards Java 5. Enum inwards Java is non similar its counterparts inwards C in addition to C++, where it but used to stand upwards for fixed publish of things, It is much to a greater extent than volatile tin dismiss produce lot to a greater extent than things which is non fifty-fifty possible inwards C or C++. Enum inwards Java is a Type similar whatsoever class or interface inwards Java. Enum likewise provides type-safety in addition to readability compare to pop Enum int pattern in addition to String enum pattern pop earlier Java 5.One of the pop utilisation of Enum is to create Thread-safe Singleton using Enum inwards Java. Enum tin override method inwards Java, Enum tin implement interface inwards Java. All Enum extends java.lang.Enum in addition to compile fourth dimension constant. See 10 Example of Enum inwards Java for to a greater extent than examples on how to utilisation Enum inwards Java.


What is variable declaration method inwards Java
As the cite advise variable declaration method are Java method which tin bring a variable publish of arguments e.g. y'all tin telephone telephone the method past times passing either 1 declaration or 2 arguments or fifty-fifty nix arguments. The mind method inwards Java five is retrofitted equally varargs method in addition to similar a shot its String[] declaration is converted to variable arguments. You tin implement varargs method fifty-fifty prior to Java five either past times using an anonymous array or using Collection classes e.g. List or Set. Variable declaration methods are likewise called equally varargs in addition to they are denoted past times 3 ...(dot) afterward in that place name. See What is varargs method inwards Java in addition to How to utilisation it for to a greater extent than details on variable arguments.

These were a quick overview of closed to of my favorite Java five feature. I create got included Autoboxing, Varargs, Enum, in addition to Generics exclusively but in that place are many to a greater extent than features inwards Java five which is worth looking e.g. static imports, regular appear in addition to Java Concurrency API which introduces closed to actually prissy utility similar CountDownLatch and CyclicBarrier, explore them to larn to a greater extent than nearly Java five advantages.

Further Learning
Complete Java Masterclass
Java Fundamentals: The Java Language
Java In-Depth: Become a Complete Java Engineer!

Producer Consumer Occupation Amongst Facial Expression Together With Notify - Thread Example

Producer Consumer Problem is a classical concurrency occupation as well as inwards fact it is i of the concurrency blueprint pattern. In in conclusion article nosotros convey seen solving Producer Consumer occupation inwards Java using blocking Queue exactly i of my reader emailed me as well as requested code illustration as well as explanation of solving Producer Consumer occupation inwards Java  with wait as well as notify method every bit well, Since its oft asked every bit i of the meridian coding enquiry inwards Java. In this Java tutorial, I convey set the code illustration of await notify version of before producer consumer concurrency blueprint pattern. You tin run across this is much longer code amongst explicit treatment blocking weather condition similar when shared queue is total as well as when queue is empty. Since nosotros convey replaced BlockingQueue amongst Vector nosotros demand to implement blocking using wait as well as notify as well as that's why nosotros convey introduced produce(int i) as well as consume() method. If yous run across I convey kept consumer thread footling dull past times allowing it to slumber for fifty Milli instant to give an chance to producer to fill upwardly the queue, which helps to empathize that Producer thread is every bit good waiting when Queue is full.

Java computer program to solve Producer Consumer Problem inwards Java

Here is consummate Java computer program to solve producer consumer occupation inwards Java programming language. In this computer program nosotros convey used await as well as notify method from java.lang.Object degree instead of using BlockingQueue for catamenia control.

import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Java computer program to solve Producer Consumer occupation using await as well as notify
 * method inwards Java. Producer Consumer is every bit good a pop concurrency blueprint pattern.
 *
 * @author Javin Paul
 */
public class ProducerConsumerSolution {

    public static void main(String args[]) {
        Vector sharedQueue = new Vector();
        int size = 4;
        Thread prodThread = new Thread(new Producer(sharedQueue, size), "Producer");
        Thread consThread = new Thread(new Consumer(sharedQueue, size), "Consumer");
        prodThread.start();
        consThread.start();
    }
}

class Producer implements Runnable {

    private final Vector sharedQueue;
    private final int SIZE;

    public Producer(Vector sharedQueue, int size) {
        this.sharedQueue = sharedQueue;
        this.SIZE = size;
    }

    @Override
    public void run() {
        for (int i = 0; i < 7; i++) {
            System.out.println("Produced: " + i);
            try {
                produce(i);
            } catch (InterruptedException ex) {
                Logger.getLogger(Producer.class.getName()).log(Level.SEVERE, null, ex);
            }

        }
    }

    private void produce(int i) throws InterruptedException {

        //wait if queue is full
        while (sharedQueue.size() == SIZE) {
            synchronized (sharedQueue) {
                System.out.println("Queue is total " + Thread.currentThread().getName()

                                    + " is waiting , size: " + sharedQueue.size());

                sharedQueue.wait();
            }
        }

        //producing chemical gene as well as notify consumers
        synchronized (sharedQueue) {
            sharedQueue.add(i);
            sharedQueue.notifyAll();
        }
    }
}

class Consumer implements Runnable {

    private final Vector sharedQueue;
    private final int SIZE;

    public Consumer(Vector sharedQueue, int size) {
        this.sharedQueue = sharedQueue;
        this.SIZE = size;
    }

    @Override
    public void run() {
        while (true) {
            try {
                System.out.println("Consumed: " + consume());
                Thread.sleep(50);
            } catch (InterruptedException ex) {
                Logger.getLogger(Consumer.class.getName()).log(Level.SEVERE, null, ex);
            }

        }
    }

    private int consume() throws InterruptedException {
        //wait if queue is empty
        while (sharedQueue.isEmpty()) {
            synchronized (sharedQueue) {
                System.out.println("Queue is empty " + Thread.currentThread().getName()

                                    + " is waiting , size: " + sharedQueue.size());

                sharedQueue.wait();
            }
        }

        //Otherwise eat chemical gene as well as notify waiting producer
        synchronized (sharedQueue) {
            sharedQueue.notifyAll();
            return (Integer) sharedQueue.remove(0);
        }
    }
}

Output:
Produced: 0
Queue is empty Consumer is waiting , size: 0
Produced: 1
Consumed: 0
Produced: 2
Produced: 3
Produced: 4
Produced: 5
Queue is total Producer is waiting , size: 4
Consumed: 1
Produced: 6
Queue is total Producer is waiting , size: 4
Consumed: 2
Consumed: 3
Consumed: 4
Consumed: 5
Consumed: 6
Queue is empty Consumer is waiting , size: 0

That’s all on How to solve producer consumer occupation inwards Java using await as well as notify method. I notwithstanding intend that using BlockingQueue to implement producer consumer blueprint pattern is much ameliorate because of its simplicity as well as concise code. At the same fourth dimension this occupation is an fantabulous practise to empathize concept of await as well as notify method inwards Java.

Further Learning
Multithreading as well as Parallel Computing inwards Java
Difference betwixt await as well as slumber method inwards Java

Difference betwixt Runnable as well as Thread inwards Java

Difference betwixt Thread as well as Process inwards Java

Top v Thread Interview enquiry inwards Java amongst answers

Difference betwixt CyclicBarrier as well as CountDownLatch inwards Java

Difference Betwixt Synchronized Block Too Method Inwards Coffee Thread

Synchronized block in addition to synchronized methods are ii ways to role synchronized keyword inwards Java in addition to implement usual exclusion on critical department of code. Since Java is mainly used to write multi-threading programs,  which introduce diverse kinds of thread related issues similar thread-safety, deadlock in addition to race conditions, which plagues into code mainly because of pathetic agreement of synchronization machinery provided past times Java programming language. Java provides inbuilt synchronized in addition to volatile keyword to accomplish synchronization inwards Java. Main difference betwixt synchronized method in addition to synchronized block is pick of lock on which critical department is locked. Synchronized method depending upon whether its a static method or non static locks on either class degree lock or object lock. Class degree lock is i for each class in addition to represented past times class literal e.g. Stirng.class. Object degree lock is provided past times electrical flow object e.g. this instance, You should never mix static in addition to non static synchronized method inwards Java.. On the other manus synchronized block locks on monitor evaluated past times appear provided every bit parameter to synchronized block. In adjacent department nosotros volition run across an instance of both synchronized method in addition to synchronized block to empathise this deviation better.

Difference betwixt synchronized method vs block inwards Java

Java coding practices.

1) One meaning deviation betwixt synchronized method in addition to block is that, Synchronized block by in addition to large reduce compass of lock. As compass of lock is inversely proportional to performance, its ever ameliorate to lock alone critical department of code. One of the best instance of using synchronized block is double checked locking inwards Singleton pattern where instead of locking whole getInstance() method nosotros alone lock critical department of code which is used to do Singleton instance. This improves surgical operation drastically because locking is alone required i or ii times.

2) Synchronized block render granular command over lock, every bit you lot tin plow over notice role arbitrary whatever lock to render usual exclusion to critical department code. On the other manus synchronized method ever lock either on electrical flow object represented past times this keyword  or class degree lock, if its static synchronized method.

3) Synchronized block tin plow over notice throw throw java.lang.NullPointerException if appear provided to block every bit parameter evaluates to null, which is non the instance amongst synchronized methods.

4) In instance of synchronized method, lock is acquired past times thread when it instruct into method in addition to released when it leaves method, either ordinarily or past times throwing Exception. On the other manus inwards instance of synchronized block, thread acquires lock when they instruct into synchronized block in addition to unloosen when they instruct out synchronized block.

Synchronized method vs synchronized block Example inwards Java

Here is an instance of  sample class which shows on which object synchronized method in addition to block are locked in addition to how to role them :

/**
  * Java class to demonstrate role of synchronization method in addition to block inwards Java
  */
public class SycnronizationExample{
 
 
    public synchronized void lockedByThis(){
        System.out.println(" This synchronized method is locked past times current" instance of object i.e. this");
    }
 
    public static synchronized void lockedByClassLock(){
        System.out.println("This static synchronized method is locked past times class degree lock of this class i.e. SychronizationExample.class");

    }
 
    public void lockedBySynchronizedBlock(){
        System.err.println("This business is executed without locking");
     
        Object obj = String.class; //class degree lock of Stirng class
     
        synchronized(obj){
            System.out.println("synchronized block, locked past times lock represented using obj variable");
        }
    }
     
}

That's all on difference betwixt synchronized method in addition to block inwards Java. Favoring synchronized block over method is i of the Java best practices to follow every bit it reduces compass of lock in addition to improves performance. On the other manus using synchronized method are rather slowly simply it too creates bugs when you lot mix non static in addition to static synchronized methods, every bit both of them are locked on dissimilar monitors in addition to if you lot role them to synchronize access of shared resource, it volition virtually probable break.

Further Learning
Multithreading in addition to Parallel Computing inwards Java
Difference betwixt Runnable in addition to Thread inwards Java

Difference betwixt CyclicBarrier in addition to CountDownLatch inwards Java

Top v Java Thread Interview questions amongst Answers

Difference betwixt Thread in addition to Process inwards Java

How to solve Producer consumer work using await and  notify inwards Java