Core Java

Network Programming – java.net Package

July 27, 2017 By j2eereference Leave a Comment

Java.net package is composed of (i) classes, (ii) exceptions, and (iii) interfaces that offer a commanding infrastructure for Java networking.

URL

Uniform Resource Locator (URL) signifies a source on the WWW (World Wide Web). A URL can be split up into protocol (http, https, etc), host (authority), port, path (filename), reference and query.

Methods

The URL class offers:

Methods for obtaining specific parts (protocol, port, etc) of the provided URL.
Methods for deciding whether 2 URL element references have the identical content.
Also openConnection( ) method delivers a URLConnection that offers a link to the distant content.

URLCONNECTION

The URLConnection class recovers the parts stated by URL elements.

Methods

The getContent( ) method is similar to URL class method.
URLConnection class also offers methods for obtaining header field estimate. Ex: (i) getContentType( ), (ii) guessContentTypeFromStream( ).
Methods getInputStream ( ) that reads information and getOutputStream ( ) for output are offered.
Other methods handle the fixing or recovering operations of variables.

Socket

A Socket class is the Java depiction of a TCP link. When a Socket is developed, a link is created to a particular destination.

Constructors

Socket constructors support 2 arguments:

Host name and
Port value.

Methods

Methods (i) getInputStream( ), (ii) getOutputStream( ), deliver stream elements that exchange information via socket.
Close method orders the primary operating system to shutdown.
Few methods obtain information about the link.

ServerSocket

ServerSocket denotes a listening TCP link. When a link is requested, this class will deliver a Socket component representing the link.

Constructors

The constructors get the port number as argument for listening the link requests.

Methods

The accept( ) method stops the requesting thread until a link is accepted.
The close( ) method instructs the system to prevent listening to requests on the socket.
There are also methods to recover the host name and port number.

DATAGRAMSOCKET

The DatagramSocket signifies a linkless datagram socket. Along with DatagramPacket, this class enables communication utilizing the UDP protocol.

Constructors

As UDP is linkless, port number alone is required and host name is not required for developing a DatagramSocket. There is another constructor that does not obtain arguments.

Methods

Every method acquires a properly created DatagramPacket.

send( ) – sends the packet data to the given host and port.
receive( ) – stops processing until a packet is obtained by the socket.
close( ) – requests the socket to shutdown.
getLocalPort( ) – submits the local port number linked with the socket.

DATAGRAMPACKET

DatagramPacket signifies a data packet transmitted by means of UDP protocol (with a DatagramSocket).

Constructors

The DatagramPacket offers 2 constructors for:

Incoming packets that picks a byte array as argument and
Outgoing packets that picks distant host name and port number as arguments.

Methods

There are 4 methods in the class, they are:

getData( ) – retrieves data
getLength( ) – retrieves datagram length
getAddress( ) – retrieves address
getPort( ) – retrieves port number

INETADDRESS

The InetAddress signifies a host name and its IP values. The class also offers the functionality for acquiring IP value.

Constructors

This class has no clear constructors. Alternatively, static methods getByName( ) and getAllByName( ), are used.

Methods

getHostName( ) – delivers a host name that the InetAddress specifies
getAddress( ) – delivers an array of the raw bytes of address
equals( ) – compares the address objects
toString( ) – prints host name and IP address

Java Regular Expressions

July 26, 2017 By j2eereference Leave a Comment

Java regular expressions are unique series of characters, which assists in matching or locating other strings or collection of strings, with a unique syntax applied in a pattern. Java offers a regex package for matching with regular expressions.

The java.util.regex package mainly is composed of 3 classes.

Pattern Class

A Pattern element is a compiled form of a regular expression. Pattern class does not offer public constructors. It is used for defining a pattern for the regex mechanism. The following compile methods permit a regular expression as the primary argument.

static Pattern compile(String regex) piles up the specified regex and sends the instance of pattern as response.
Matcher matcher(CharSequence input) builds a matcher that equals the specified input to the pattern.
static boolean matches(String regex, CharSequence input) acts as the blend of compile and matcher methods.
String[] split(CharSequence input) divides the input string between matches of specified pattern.
String pattern() delivers the regex pattern.

Matcher Class

A Matcher element understands the pattern and then executes matching actions against an input string. Matcher class does not offer public constructors. It executes Match Result interface. The matcher methods are:

boolean matches() checks if the regular expression equals the pattern.
boolean find() locates the subsequent expression that equals the pattern.
boolean find(int start) locates the upcoming expression that equals the pattern from the specified start number.
String group() delivers the equated subsequence.
int start() delivers the first index of the equated subsequence.
int end() delivers the final index of the equated subsequence.
int groupCount() delivers the total of the equated subsequence.

PatternSyntaxException

A PatternSyntaxException element is an unverified exception that points out syntax mistakes in a regular expression pattern. The class methods are:

public String getDescription() fetches the report of the mistakes.
public int getIndex() fetches the fault index.
public String getPattern() fetches the invalid regular expressions.
public String getMessage() delivers a multi-line string that contains (i) the report of the error and index, (ii) the invalid pattern, and (iii) a visual sign of the fault index inside the pattern.

Java Regular Expressions Example

In the below example, the regular expressions “.x”, “.x.”, and “..x” are used for finding the occurrence of the string in the given words. Here, a dot signifies a single character. The regular expressions can be written in 3 approaches.

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RGEXP {
	public static void main(String args[]) {

		// Way-1
		Pattern s = Pattern.compile(".x");
		Matcher a = s.matcher("ox");
		boolean y = a.matches();

		// Way-2
		boolean y2 = Pattern.compile(".x.").matcher("oxe").matches();

		// Way-3
		boolean y3 = Pattern.matches("..x", "xx");

		System.out.println("Regular expression testing " + y + " " + y2 + " " + y3);
	}
}

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class RGEXP {

public static void main(String args[]) {

// Way-1

Pattern s = Pattern.compile(".x");

Matcher a = s.matcher("ox");

boolean y = a.matches();

// Way-2

boolean y2 = Pattern.compile(".x.").matcher("oxe").matches();

// Way-3

boolean y3 = Pattern.matches("..x", "xx");

System.out.println("Regular expression testing " + y + " " + y2 + " " + y3);

}

Output for the above program would be

Regular expression testing true true false

In the above example,
• The 1st approach is true as 2nd character is x.
• The 2nd approach is true as 2nd character is x.
• The 3rd approach output is false as it requests for 3rd character and “xx” has only 2 characters.

Method Local Inner Class in Java

July 25, 2017 By j2eereference Leave a Comment

Method local inner class in Java is limited to a code section, and it can be processed only inside the same code section it is declared in. Hence it can never execute modifiers. A local inner class instance can be delivered as argument and retrieved from methods, and is available inside a valid scope.

Purpose of Method Local Inner class

The only limitation in method local inner class is that a local parameter can be executed only when it is defined ‘final’. The basis for this limitation associates primarily to multi-threading problems and makes sure that every variable has definite values when accessed from local inner class. The method executing the local parameters can be called after the execution of the method, within which the local inner class was declared. As a result, the local parameters will no longer retain their values. Hence the values must be fixed before creating the local inner class object. If required, a non-final variable can be copied into a final variable which is subsequently executed by the local inner class.

The following example program will not compile unless the statement System.out.println(b); is eliminated.

class J2EEReferenceOuterClass {
	private int a = 5;

	public void exampleMethod() {
		int b = 10; // here the variable is not declared final
		final int c = 20;

		class J2EEReferenceLocalInnerClass {
			public void accessSampleOuter() {
				System.out.println(a);

				System.out.println(b); // (Error: Cannot refer to non-final
				// variable b inside an inner class
				// defined in a different method)

				System.out.println(c);
			}
		}
		J2EEReferenceLocalInnerClass innercls = new J2EEReferenceLocalInnerClass();
		innercls.accessSampleOuter();
	}
}

class J2EEReferenceOuterClass {

private int a = 5;

public void exampleMethod() {

int b = 10; // here the variable is not declared final

final int c = 20;

class J2EEReferenceLocalInnerClass {

public void accessSampleOuter() {

System.out.println(a);

System.out.println(b); // (Error: Cannot refer to non-final

// variable b inside an inner class

// defined in a different method)

System.out.println(c);

}

J2EEReferenceLocalInnerClass innercls = new J2EEReferenceLocalInnerClass();

innercls.accessSampleOuter();

}

public class LocalInnerTest {
	public static void main(String[] args) {
		J2EEReferenceOuterClass outercls = new J2EEReferenceOuterClass();
		outercls.exampleMethod();
	}
}

public class LocalInnerTest {

public static void main(String[] args) {

J2EEReferenceOuterClass outercls = new J2EEReferenceOuterClass();

outercls.exampleMethod();

}

OUTPUT

Compilation Error

On declaring the variable ‘b’ as final, the output for the program would be

On eliminating the statement ‘System.out.println(b);’ the output would be,

It is obvious that a method local inner class can never be addressed (i) public, (ii) private, (iii) protected, (iv) static or (v) transient as it is local to a method. Either abstract or final can be applied as modifiers to a method local inner class.

URL Processing in Java

July 24, 2017 By j2eereference Leave a Comment

Uniform Resource Locator (URL) signifies a source on the WWW (World Wide Web). A URL can be split up into protocol (http, https, etc), host (authority), port, path (filename), reference and query. URL Processing in Java is done using two classes namely URL Class and URLConnection class.

URL Class

The java.net.URL class includes a collection of methods to operate URL in Java. The URL class contains numerous constructors for building URLs:

public URL(String protocol,Stringhost, int port, String file) throws MalformedURLException and generates a URL by bringing the provided parts collectively.
public URL(String protocol, String host, String file) throws MalformedURLException , here the standard port for a protocol is used.
public URL(String url) throws MalformedURLException generates URL from a String.
public URL(URL context, String url) throws MalformedURLException generates URL by syntactically analyzing the string and URL arguments together.

The URL class offers the following methods for executing different parts of the URL:

public String getPath() delivers the path.
public String getQuery() delivers the query portion.
public String getAuthority() delivers the authority.
public int getPort() delivers the port.
public int getDefaultPort() delivers the standard port a protocol.
public String getProtocol() delivers the protocol.
public String getHost() delivers the host.
public String getFile() delivers the filename.
public String getRef() delivers the reference.
public URLConnection openConnection() throws IOException develops a link to the URL, permitting a user-resource communication.

URLConnection Class

The openConnection mode of URL class provides a URL Connection whose lower classes signify different types of URL connections. i.e., when a URL with http protocol is linked, openConnection mode delivers httpUrlConnection object.

This URLConnection class includes the following methods to fix or fetch information about the connection:

Object getContent() and Object getContent(Class[] classes) are used for fetching the corresponding contents of the connection.
Methods like (a) String getContentEncoding(), (b) int getContentLength(), (c) String getContentType(), (d) int getLastModified(), (e) long getExpiration(), (f) long getIfModifiedSince() deliver the corresponding estimates of the header field.
public void setDoInput(boolean input) method generally has input value to be true as the users normally read from a URLConnection.
public void setDoOutput(boolean output) method generally has input value to be false as several forms of URL do not accept writing.
public InputStream getInputStream() throws IOException delivers the input stream to read from the source.
public OutputStream getOutputStream() throws IOException delivers the output stream to write to the source.
public URL getURL() delivers the URL, which is linked to the given URLConnection.

URL Processing in Java Example

Here is a simple example to demonstrate how a URL will be processed in Java:

import java.io.IOException;
import java.net.URL;

public class URLProcessingExample {
	public static void main(String [] args) {
		try {

			URL url = new URL("https://j2eereference.com/category/design-patterns/");

			System.out.println(url.toString() +" is the URL");
			System.out.println(url.getProtocol()+" is the Protocol");
			System.out.println(url.getAuthority()+" is the Authority");
			System.out.println(url.getFile()+" is the File Name");
			System.out.println(url.getHost()+" is the Host");
			System.out.println(url.getPath()+" is the Path");
			System.out.println(url.getPort()+" is the Port");
			System.out.println(url.getDefaultPort()+" is the Default Port");

		}catch(IOException e) {
			e.printStackTrace();
		}
	}
}

import java.io.IOException;

import java.net.URL;

public class URLProcessingExample {

public static void main(String [] args) {

try {

URL url = new URL("https://j2eereference.com/category/design-patterns/");

System.out.println(url.toString() +" is the URL");

System.out.println(url.getProtocol()+" is the Protocol");

System.out.println(url.getAuthority()+" is the Authority");

System.out.println(url.getFile()+" is the File Name");

System.out.println(url.getHost()+" is the Host");

System.out.println(url.getPath()+" is the Path");

System.out.println(url.getPort()+" is the Port");

System.out.println(url.getDefaultPort()+" is the Default Port");

}catch(IOException e) {

e.printStackTrace();

}

Output will be:

https://j2eereference.com/category/design-patterns/ is the URL
https is the Protocol
j2eereference.com is the Authority
/category/design-patterns/ is the File Name
j2eereference.com is the Host
/category/design-patterns/ is the Path
-1 is the Port
443 is the Default Port

Callable and Future Interface

June 20, 2017 By j2eereference Leave a Comment

Callable and Future Interface :

Callable and Future interface has been introduced in JDK 1.5 under java.util.cocurrent package.

Callable interface is used to execute task and is similar to Runnable interface but can return value to caller and is able to throw checked Exception as well .Callable interface has call() method to execute task, computing result and returning result or throws an exception if unable to execute.

Callable interface is used by Executor framework, which contains pool of threads called worker threads then will call submit method of ExecutorService which is used to execute the Callable tasks by available threads in the pool.

When we submit callable task then returned result is an instance of Future object. This Future object is used to find out the status of callable task ,get the result of task computation or cancel the task.

Example using future and Callable :

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableDemo {
  private static final int WORKER_THREADS = 10;
  public static void main(String[] args) throws InterruptedException,ExecutionException {
        ExecutorService executor = Executors.newFixedThreadPool(WORKER_THREADS);
        Future&lt;Integer&gt; futureAdd = executor.submit(new AdditionCallable(10));
        System.out.println("Computation result returned after submitting Callable task "
         + futureAdd.get());
        executor.shutdown();
  }
}

class AdditionCallable implements Callable&lt;Integer&gt; {
  Integer n;
  AdditionCallable(Integer n) {
     this.n = n;
  }

  @Override
  public Integer call() throws Exception {
   Integer sum = 0;
   for (int i = 0; i &lt;= n; i++) {
       System.out.println("value added in sum is " + i);
       sum += i;
       System.out.println("Updated sum is " + sum);
   }
   return sum;
  }
}

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

public class CallableDemo {

private static final int WORKER_THREADS = 10;

public static void main(String[] args) throws InterruptedException,ExecutionException {

ExecutorService executor = Executors.newFixedThreadPool(WORKER_THREADS);

Future<Integer> futureAdd = executor.submit(new AdditionCallable(10));

System.out.println("Computation result returned after submitting Callable task "

+ futureAdd.get());

executor.shutdown();

}

class AdditionCallable implements Callable<Integer> {

Integer n;

AdditionCallable(Integer n) {

this.n = n;

}

@Override

public Integer call() throws Exception {

Integer sum = 0;

for (int i = 0; i <= n; i++) {

System.out.println("value added in sum is " + i);

sum += i;

System.out.println("Updated sum is " + sum);

}

return sum;

}

OutPut:

value added in sum is 0
Updated sum is 0
value added in sum is 1
Updated sum is 1
value added in sum is 2
Updated sum is 3
value added in sum is 3
Updated sum is 6
value added in sum is 4
Updated sum is 10
value added in sum is 5
Updated sum is 15
value added in sum is 6
Updated sum is 21
value added in sum is 7
Updated sum is 28
value added in sum is 8
Updated sum is 36
value added in sum is 9
Updated sum is 45
value added in sum is 10
Updated sum is 55
Computation result returned after submitting Callable task 55

Methods of Callable and Future :
1) V call() throws Exception: This method returns result of executable task or throws an exception .
2) Get() :this method is used to get the result of callable task.It is a blocking call which means that if task is not finishes then it will wait until it is finished.
3) get(long timeout, TimeUnit): this method will wait at most the time specified in the method for the task to complete and give results if available.
4) Boolean Cancel() : this method will return true if attempt to cancel the task is successful. If task is already completed or cancelled then attempt will fail.
5) Boolean isCancelled(): this method will return true if task is cancelled before it gets complete.
6) Boolean isDone() : this method will return true if task compeltes.Completion of task can be exception,normal or cancelled.

Difference between Stack and Heap memory

June 15, 2017 By j2eereference Leave a Comment

Lets see some of the main differences between Stack and Heap memory.

1) Stack memory is used to store local variables and references to other objects in the method whereas heap memory is used to store objects.
2) Size of heap memory is much bigger than the stack memory.
3) Each thread has their own stack which stores local variables and these variables are not accessible globally whereas objects stored in heap are globally accessible.
4) Heap memory size is bigger where we can create and store objects in any order whereas stack memory follows LIFO(Last In First Out) order.
5) We can change the size of heap memory using jvm parameters : -Xms for initial heap memory and –Xmx for maximum heap memory. For stack , use –Xss to specify stack size for each thread.
6) If stack memory is filled up then you will get java.lang.StackOverFlowError . If there is no space left to allocate new Object in Heap memory then you will get java.lang.OutOfMemoryError: Java Heap Space.

Program to generate StackOverFlowError exception :

package com.j2eereference;
public class StackOverflowErrorDemo{
  public static void recursiveComputation(int count) 
  {
    if(count == 0)
      return;
    else
      recursiveComputation(++count);
   }
  public static void main(String[] args) 
   {
      StackOverflowErrorDemo.recursiveComputation(10);
   }
}

package com.j2eereference;

public class StackOverflowErrorDemo{

public static void recursiveComputation(int count)

{

if(count == 0)

return;

else

recursiveComputation(++count);

}

public static void main(String[] args)

{

StackOverflowErrorDemo.recursiveComputation(10);

}

OutPut:
Exception in thread “main” java.lang.StackOverflowError
at com.j2eereference.StackOverflowErrorDemo.recursiveComputation(StackOverflowErrorDemo.java:13)
at com.j2eereference.StackOverflowErrorDemo.recursiveComputation(StackOverflowErrorDemo.java:13)

Program to generate OutOfMemoryError: Java heap space

package com.j2eereference;

import java.util.ArrayList;
import java.util.List;
public class OutOfMemoryDemo 
{
    private static List<String> heapList=new ArrayList<>();
    public static void main(String[] args) 
      {
    	while(true)
           {
            heapList.add(new String("Shobhna"));   
           }
       }
}

package com.j2eereference;

import java.util.ArrayList;

import java.util.List;

public class OutOfMemoryDemo

{

private static List<String> heapList=new ArrayList<>();

public static void main(String[] args)

{

while(true)

{

heapList.add(new String("Shobhna"));

}

OutPut:
Exception in thread “main” java.lang.OutOfMemoryError: Java heap space
at java.util.Arrays.copyOf(Arrays.java:3210)
at java.util.Arrays.copyOf(Arrays.java:3181)
at java.util.ArrayList.grow(ArrayList.java:261)
at java.util.ArrayList.ensureExplicitCapacity(ArrayList.java:235)
at java.util.ArrayList.ensureCapacityInternal(ArrayList.java:227)
at java.util.ArrayList.add(ArrayList.java:458)
at com.j2eereference

7) Stack memory allocation is simple as compared to heap memory allocation as Stack uses LIFO order,so stack memory is fast as compared to heap memory.
8) Stack memory is used by only threads whereas heap memory is used by whole application.
9) use stack when you know that how much memory is needed to allocate before compile time on the other hand, use heap if you are not sure about the amount of memory needed at runtime.

What is ThreadMXBean in java?

June 14, 2017 By j2eereference Leave a Comment

What is ThreadMXBean :

In the previous article, we have explained about deadlock, why it occurs and how to avoid deadlock condition. Here we will see what is ThreadMXBean and how can it detect deadlock threads. ThreadMXBean is an interface and belongs to java.lang.Management package. It helps to detect the threads which have entered into deadlock condition and also helps in retrieving details about them.

ThreadMXBean is an interface, to get an instance of ThreadMXBean use getThreadMXBean() method of ManagementFactory.

Let’s create a program to explain some methods of ThreadMXBean interface.

package com.j2eereference;
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
 
class ThreadDemo
{
    synchronized void executeMethod1(ThreadDemo demo)
    {
        System.out.println("Thread "+Thread.currentThread().getName()+" is executing");
        demo.executeMethod2(this);
        System.out.println(Thread.currentThread().getName()+" has finished method execution");
    }
   synchronized void executeMethod2(ThreadDemo demo)
    {
    	 System.out.println("Thread "+Thread.currentThread().getName()+" is executing"); 
         demo.executeMethod1(this);
         System.out.println(Thread.currentThread().getName()+" has finished method execution");
    }
}
 
public class ThreadsMXBeanDemo
{
    public static void main(String[] args)
    {
        final ThreadDemo threadDemo1 = new ThreadDemo();
        final ThreadDemo threadDemo2  = new ThreadDemo();
        Thread t1 = new Thread("Thread1")
        {
            public void run()
            {
            	threadDemo1.executeMethod1(threadDemo2);
            }
        };
 
        Thread t2 = new Thread("Thread2")
        {
            @Override
            public void run()
            {
            	threadDemo2.executeMethod2(threadDemo1);
            }
        };
 
        t1.start();
        t2.start();
        ThreadMXBean mxBean = ManagementFactory.getThreadMXBean();
        long threadId[] = mxBean.findMonitorDeadlockedThreads();
        if(threadId != null)
        {
            ThreadInfo info[] = mxBean.getThreadInfo(threadId);
 
            for (ThreadInfo threadInfo : info)
            {
            	System.out.println("\nDeadlock Thread details.");
                System.out.println(threadInfo.getThreadId());    
                System.out.println(threadInfo.getThreadName());  
                System.out.println(threadInfo.getLockName());
 
                System.out.println(threadInfo.getLockOwnerId());
                System.out.println(threadInfo.getLockOwnerName());             
             }
           }
       
            System.out.println("\nGeneral Thread details");
            System.out.println(("Current number of live threads :"+ mxBean.getThreadCount()));
            System.out.println("Total CPU time for the current thread: "+mxBean.getCurrentThreadCpuTime());
            System.out.println("Current number of live daemon threads:"+mxBean.getDaemonThreadCount());
            System.out.println("Peak live thread count :"+mxBean.getPeakThreadCount());
            System.out.println("Total number of threads created and started"
            +mxBean.getTotalStartedThreadCount());
          }
}

package com.j2eereference;

import java.lang.management.ManagementFactory;

import java.lang.management.ThreadInfo;

import java.lang.management.ThreadMXBean;

class ThreadDemo

{

synchronized void executeMethod1(ThreadDemo demo)

{

System.out.println("Thread "+Thread.currentThread().getName()+" is executing");

demo.executeMethod2(this);

System.out.println(Thread.currentThread().getName()+" has finished method execution");

}

synchronized void executeMethod2(ThreadDemo demo)

{

System.out.println("Thread "+Thread.currentThread().getName()+" is executing");

demo.executeMethod1(this);

System.out.println(Thread.currentThread().getName()+" has finished method execution");

}

public class ThreadsMXBeanDemo

{

public static void main(String[] args)

{

final ThreadDemo threadDemo1 = new ThreadDemo();

final ThreadDemo threadDemo2 = new ThreadDemo();

Thread t1 = new Thread("Thread1")

{

public void run()

{

threadDemo1.executeMethod1(threadDemo2);

}

};

Thread t2 = new Thread("Thread2")

{

@Override

public void run()

{

threadDemo2.executeMethod2(threadDemo1);

}

};

t1.start();

t2.start();

ThreadMXBean mxBean = ManagementFactory.getThreadMXBean();

long threadId[] = mxBean.findMonitorDeadlockedThreads();

if(threadId != null)

{

ThreadInfo info[] = mxBean.getThreadInfo(threadId);

for (ThreadInfo threadInfo : info)

{

System.out.println("\nDeadlock Thread details.");

System.out.println(threadInfo.getThreadId());

System.out.println(threadInfo.getThreadName());

System.out.println(threadInfo.getLockName());

System.out.println(threadInfo.getLockOwnerId());

System.out.println(threadInfo.getLockOwnerName());

}

System.out.println("\nGeneral Thread details");

System.out.println(("Current number of live threads :"+ mxBean.getThreadCount()));

System.out.println("Total CPU time for the current thread: "+mxBean.getCurrentThreadCpuTime());

System.out.println("Current number of live daemon threads:"+mxBean.getDaemonThreadCount());

System.out.println("Peak live thread count :"+mxBean.getPeakThreadCount());

System.out.println("Total number of threads created and started"

+mxBean.getTotalStartedThreadCount());

}

OutPut :

Thread Thread1 is executing
Thread Thread2 is executing

Deadlock Thread details.
11
Thread2
com.j2eereference.ThreadDemo@15db9742
10
Thread1

Deadlock Thread details.
10
Thread1
com.j2eereference.ThreadDemo@6d06d69c
11
Thread2

General Thread details
Current number of live threads :7
Total CPU time for the current thread: 46800300
Current number of live daemon threads:4
Peak live thread count :7
Total number of threads created and started7

Important methods of ThreadMXBean:

findMonitorDeadlockedThreads(): This method will return number threads that are in deadlock state and waiting to acquire object monitors.
getThreadId(): This method will return the unique ID of thread
getThreadName(): This method will return the thread name
getLockName(): this method will reurn the string representation of an object for which associated thread is blocked waiting.
getLockOwnerId(): This method will return the ID of the thread which owns the object lock
getLockOwnerName(): This method will return the the name of the thread which owns the object lock.
getThreadCount(): This method will return number of live threads including both daemon and non-daemon threads.
getCurrentThreadCpuTime(): This method will return total CPU time for the current thread in
getDaemonThreadCount(): This method will return current number of live daemon threads.
getPeakThreadCount(): This method will return the peak live thread count since the Java virtual machine has been started .

What is serialVersionUID

June 13, 2017 By j2eereference Leave a Comment

What is serialVersionUID? In serialization process at runtime each serializable class is associated with a version number, called a serialVersionUID, and this versionUID is used to ensure that during deserialization the same class is loaded which was used during serialization process. If serialVersionUID is not declared explicitly then JVM will do it for you automatically.

Problem occur if not defining serialVersionUID: serialVersionUID is used to control the version of class.If serialVersionUID is not declared in the class and if there is any incompatible modification made in class, then we would not be able to deserialize this class as serialVersionUID generated by java compiler for modified class will be different from old serialized class and deserialization process will throw java.io.InvalidClassException.

In below example, we commented serialVersionUID and serialized class StudentInformation

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;

class StudentInformation implements Serializable
 {
   // private static final long serialVersionUID = 1L;
   private Integer rollNo;
   private String name;
   public StudentInformation()
   {
      System.out.println("No argument constructor is called");
   }
   
   public StudentInformation(Integer rollNo,String name) 
   {
      System.out.println("Parameterised constructor is called");
      this.rollNo = rollNo;
      this.name = name;
   }
   @Override
   public String toString() 
   {
      return "Student Information is rollNo : " + rollNo + "and Student name is : "+name ;
   }
 }

public class SerializableDemo 
 {
   public static void main(String[] args) 
   {
     StudentInformation object1 = new StudentInformation(21,"Shobhna");
     try {
           OutputStream fout = new FileOutputStream("ser.txt");
           ObjectOutput oout = new ObjectOutputStream(fout);
           System.out.println("Serializing StudentInformation object");
           oout.writeObject(object1);
           fout.close();
           oout.close();
           System.out.println("Serialization process completed.");
           InputStream inputStream=new FileInputStream("ser.txt");

         } catch (IOException e) 
         {
           e.printStackTrace();
         }
    }
}

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.ObjectInput;

import java.io.ObjectInputStream;

import java.io.ObjectOutput;

import java.io.ObjectOutputStream;

import java.io.OutputStream;

import java.io.Serializable;

class StudentInformation implements Serializable

{

// private static final long serialVersionUID = 1L;

private Integer rollNo;

private String name;

public StudentInformation()

{

System.out.println("No argument constructor is called");

}

public StudentInformation(Integer rollNo,String name)

{

System.out.println("Parameterised constructor is called");

this.rollNo = rollNo;

this.name = name;

}

@Override

public String toString()

{

return "Student Information is rollNo : " + rollNo + "and Student name is : "+name ;

}

public class SerializableDemo

{

public static void main(String[] args)

{

StudentInformation object1 = new StudentInformation(21,"Shobhna");

try {

OutputStream fout = new FileOutputStream("ser.txt");

ObjectOutput oout = new ObjectOutputStream(fout);

System.out.println("Serializing StudentInformation object");

oout.writeObject(object1);

fout.close();

oout.close();

System.out.println("Serialization process completed.");

InputStream inputStream=new FileInputStream("ser.txt");

} catch (IOException e)

{

e.printStackTrace();

}

OutPut:

Parameterised constructor is called
Serializing StudentInformation object
Serialization process completed.

Now, modify this class by adding field address and do not serialize class again as given below

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;

class StudentInformation implements  Serializable
{
  private Integer rollNo;
  private String name;
  private String address;
  public StudentInformation()
  {
    System.out.println("No argument constructor is called");
  }
  public StudentInformation(Integer rollNo,String name)
  {
    System.out.println("Parameterised constructor is called");
    this.rollNo = rollNo;
    this.name = name;
   }
   @Override
   public String toString() 
   {
     return "Student Information is rollNo : " + rollNo + "and Student name is : "+name ;
   }
}
public class SerializableDemo 
 {
  public static void main(String[] args) 
  {
    StudentInformation object1 = new StudentInformation(21,"Shobhna");
  }
}

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.ObjectInput;

import java.io.ObjectInputStream;

import java.io.ObjectOutput;

import java.io.ObjectOutputStream;

import java.io.OutputStream;

import java.io.Serializable;

class StudentInformation implements Serializable

{

private Integer rollNo;

private String name;

private String address;

public StudentInformation()

{

System.out.println("No argument constructor is called");

}

public StudentInformation(Integer rollNo,String name)

{

System.out.println("Parameterised constructor is called");

this.rollNo = rollNo;

this.name = name;

}

@Override

public String toString()

{

return "Student Information is rollNo : " + rollNo + "and Student name is : "+name ;

}

public class SerializableDemo

{

public static void main(String[] args)

{

StudentInformation object1 = new StudentInformation(21,"Shobhna");

}

OutPut:

Parameterised constructor is called

Now , try to deserialize the saved class StudentInformation , you will get InvalidClassException

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;

class StudentInformation implements  Serializable
{
  // private static final long serialVersionUID = 1L;
  private Integer rollNo;
  private String name;
  private String address;
  public StudentInformation()
  {
    System.out.println("No argument constructor is called");
  }
  public StudentInformation(Integer rollNo,String name) 
  {
    System.out.println("Parameterised constructor is called");
    this.rollNo = rollNo;
    this.name = name;
  }
  @Override
  public String toString() 
  {
    return "Student Information is rollNo : " + rollNo + "and Student name is : "+name ;
  }
}

public class SerializableDemo
{
  public static void main(String[] args) 
  {
    try {
          InputStream inputStream=new FileInputStream("ser.txt");
          ObjectInput outInput=new ObjectInputStream(inputStream);
          System.out.println("\nDeSerializing StudentInformation objects");
          StudentInformation std=(StudentInformation)outInput.readObject();
          System.out.println(std);
          inputStream.close();
          outInput.close();
          System.out.println("Object DeSerialization completed.");
         } catch (Exception e) {
             e.printStackTrace();
        }
   }
}

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.ObjectInput;

import java.io.ObjectInputStream;

import java.io.ObjectOutput;

import java.io.ObjectOutputStream;

import java.io.OutputStream;

import java.io.Serializable;

class StudentInformation implements Serializable

{

// private static final long serialVersionUID = 1L;

private Integer rollNo;

private String name;

private String address;

public StudentInformation()

{

System.out.println("No argument constructor is called");

}

public StudentInformation(Integer rollNo,String name)

{

System.out.println("Parameterised constructor is called");

this.rollNo = rollNo;

this.name = name;

}

@Override

public String toString()

{

return "Student Information is rollNo : " + rollNo + "and Student name is : "+name ;

}

public class SerializableDemo

{

public static void main(String[] args)

{

try {

InputStream inputStream=new FileInputStream("ser.txt");

ObjectInput outInput=new ObjectInputStream(inputStream);

System.out.println("\nDeSerializing StudentInformation objects");

StudentInformation std=(StudentInformation)outInput.readObject();

System.out.println(std);

inputStream.close();

outInput.close();

System.out.println("Object DeSerialization completed.");

} catch (Exception e) {

e.printStackTrace();

}

<span style="text-decoration: underline;"><strong>OutPut:</strong></span>
java.io.InvalidClassException: StudentInformation; local class incompatible:
 stream classdesc serialVersionUID = 8086333747608896269,
 local class serialVersionUID = -2722271583385024093
at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:616)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1623)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1518)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1774)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:371)
at SerializableDemo.main(SerializableDemo.java:57)

<span style="text-decoration: underline;"><strong>OutPut:</strong></span>

java.io.InvalidClassException: StudentInformation; local class incompatible:

stream classdesc serialVersionUID = 8086333747608896269,

local class serialVersionUID = -2722271583385024093

at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:616)

at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1623)

at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1518)

at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1774)

at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)

at java.io.ObjectInputStream.readObject(ObjectInputStream.java:371)

at SerializableDemo.main(SerializableDemo.java:57)

What is exchanger in concurrency?

June 12, 2017 By j2eereference Leave a Comment

Exchanger :

Exchanger is introduced in jdk1.5 with classes like CountDownLatch,CyclicBarrier and Semaphores.

This class is used to exchange data between two threads. An Exchanger waits until both the threads call its exchange() method and when this method is invoked, the exchanger exchanges data between two threads. It uses method exchange for exchanging data .

It has two version of exchange method given below :

V exchange(V x): This method will wait until other thread calls exchange method or interrupts it. When other thread calls exchange method then waiting thread resumed and data exchanging is done between two threads.
V exchange(V x, long timeout, TimeUnit unit) : This method will wait until other thread calls exchange method or interrupts it or specified time elapses. . When other thread calls exchange method then waiting thread resumed and data exchanging is done between two threads.

Example to demonstrate Exchanger :

import java.util.concurrent.Exchanger;
class ProducerBuffer implements Runnable {
  Exchanger<String> exchanger;
  String message;
  ProducerBuffer(Exchanger<String> exchanger) {
     message = new String();
     this.exchanger = exchanger;
  }

 @Override
 public void run() {
    for (int i = 0; i < 10; i++) {
      message += i;
      System.out.println("Producer produced message: " + message);
      try {
       message = exchanger.exchange(message);
     } catch (InterruptedException e) {
       e.printStackTrace();
     }
   }
 }
}

class ConsumerBuffer extends Thread {
  ProducerBuffer prod;
  Exchanger<String> exchanger;
  String message;
  ConsumerBuffer(Exchanger<String> exchanger) {
     this.exchanger = exchanger;
  }

  public void run() {
   for (int i = 0; i < 10; i++) {
     try {
       message = exchanger.exchange(new String());
       System.out.println("Consumer consumed message: " + message);
     } catch (InterruptedException e) {
       e.printStackTrace();
    }
   }
  }
}
public class ExchangerDemo {
  public static void main(String[] args) {
   Exchanger<String> exchanger = new Exchanger<String>();
   ProducerBuffer prodBuffer = new ProducerBuffer(exchanger);
   ConsumerBuffer consBuffer = new ConsumerBuffer(exchanger);
   Thread prodThread = new Thread(prodBuffer, "prodThread");
   Thread consThread = new Thread(consBuffer, "consThread");
   prodThread.start();
   consThread.start();
  }
}

import java.util.concurrent.Exchanger;

class ProducerBuffer implements Runnable {

Exchanger<String> exchanger;

String message;

ProducerBuffer(Exchanger<String> exchanger) {

message = new String();

this.exchanger = exchanger;

}

@Override

public void run() {

for (int i = 0; i < 10; i++) {

message += i;

System.out.println("Producer produced message: " + message);

try {

message = exchanger.exchange(message);

} catch (InterruptedException e) {

e.printStackTrace();

}

class ConsumerBuffer extends Thread {

ProducerBuffer prod;

Exchanger<String> exchanger;

String message;

ConsumerBuffer(Exchanger<String> exchanger) {

this.exchanger = exchanger;

}

public void run() {

for (int i = 0; i < 10; i++) {

try {

message = exchanger.exchange(new String());

System.out.println("Consumer consumed message: " + message);

} catch (InterruptedException e) {

e.printStackTrace();

}

public class ExchangerDemo {

public static void main(String[] args) {

Exchanger<String> exchanger = new Exchanger<String>();

ProducerBuffer prodBuffer = new ProducerBuffer(exchanger);

ConsumerBuffer consBuffer = new ConsumerBuffer(exchanger);

Thread prodThread = new Thread(prodBuffer, "prodThread");

Thread consThread = new Thread(consBuffer, "consThread");

prodThread.start();

consThread.start();

}

OutPut:

Producer produced message: 0
Producer produced message: 1
Consumer consumed message: 0
Consumer consumed message: 1
Producer produced message: 2
Consumer consumed message: 2
Producer produced message: 3
Consumer consumed message: 3
Producer produced message: 4
Consumer consumed message: 4
Producer produced message: 5
Consumer consumed message: 5
Producer produced message: 6
Consumer consumed message: 6
Producer produced message: 7
Consumer consumed message: 7
Producer produced message: 8
Consumer consumed message: 8
Producer produced message: 9
Consumer consumed message: 9

Real Time usecase:
Exchanger is mainly used which implements Producer consumer problem as booth threads exchange data between each other

UncaughtExceptionHandler in java

June 6, 2017 By j2eereference Leave a Comment

UnCaughtExceptionHandler: There are two kinds of exceptions in Java one is checked exceptions and other is Unchecked exceptions. We already know about checked and unchecked exception.

In this tutorial we will learn about UnCaughtExceptionHandler. Unchecked exceptions don’t have to be caught and when an unchecked exception is thrown inside the run() method of a Thread , the default behavior is to write the stack trace and exit the program.

For this , Java provides an elegant mechanism of handling Runtime Exceptions that is not handled by programmer to avoid the program ending abruptly using UnCaughtExceptionHandler.

When a thread terminates due to an uncaught runtime exception ,JVM will consult the thread for its UncaughtExceptionHandler using method Thread.getUncaughtExceptionHandler() which then will invoke the handler’s uncaughtException method.

If the thread doesn’t have an explicitly UncaughtExceptionHandler then its ThreadGroup will act as its UncaughtExceptionHandler and exhibit the default behavior to write the stacktrace.

Program to demonstrate:

Lets see below program , in this we throw Runtime Exception and handles it using UncaughtExceptionHandler . Inside uncaughtException method of handler we print information about thread which has failed and exception information.

package com.j2eereference;


public class UnCaughtExceptionHandlerDemo {

   public static void main(String[] args) {

      Thread t = new Thread(new MyRunnableDemo());
      t.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

         public void uncaughtException(Thread t, Throwable e) {
        	 System.out.printf("An exception has been handled\n");
             System.out.printf("Thread Id: %s\n", t.getId());
             System.out.printf("Thread status: %s\n", t.getState());
             System.out.printf("Thread priority: %s\n", t.getPriority());
             System.out.printf("Exception type: %s: %s\n", e.getClass().getName(), e.getMessage());
             System.out.printf("Stack Trace description: \n");
             e.printStackTrace(System.out);
            
           
         }
      });
      
      t.start();
   }
}

class MyRunnableDemo implements Runnable {

   public void run() {
      throw new RuntimeException();
   
   }
}

package com.j2eereference;

public class UnCaughtExceptionHandlerDemo {

public static void main(String[] args) {

Thread t = new Thread(new MyRunnableDemo());

t.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

public void uncaughtException(Thread t, Throwable e) {

System.out.printf("An exception has been handled\n");

System.out.printf("Thread Id: %s\n", t.getId());

System.out.printf("Thread status: %s\n", t.getState());

System.out.printf("Thread priority: %s\n", t.getPriority());

System.out.printf("Exception type: %s: %s\n", e.getClass().getName(), e.getMessage());

System.out.printf("Stack Trace description: \n");

e.printStackTrace(System.out);

}

});

t.start();

}

class MyRunnableDemo implements Runnable {

public void run() {

throw new RuntimeException();

}

OutPut :

An exception has been handledThread Id: 10

Thread status: RUNNABLE

Thread priority: 5

Exception type: java.lang.RuntimeException: null

Stack Trace description:

java.lang.RuntimeException at com.j2eereference.MyRunnableDemo.run(UnCaughtExceptionHandlerDemo.java:31)at java.lang.Thread.run(Thread.java:745)

Where to use :

We can use UncaughtExceptionHandler for making logging more informative as well often default logs doesn’t provide enough information about the exception when thread execution failed.
It can also be used In real life application where programmer would like to start a failed thread more than once to perform a critical task even if it failed couple of times by again starting thread from UnCaughtExceptionHandler.

Main navigation

Core Java

Related Posts

Related Posts

Related Posts

Related Posts

Related Posts

Related Posts

Related Posts

Related Posts

Related Posts

Footer