Java.lang.Runtime

• Runtime class is a built-in class which is available in java.lang package.
• java.lang.Runtime class default constructor has private access modifier, so we cannot instantiate outside from the Runtime class.
• Java.lang.Runtime class has been developed on Singleton Design pattern.

Singleton Design Pattern: - Singleton Design Pattern offers to create a class with a restriction on numbers of object creation.
As we know that when we define a class then we can create multiple objects using new operator. However, the number of objects created in a class that is designed using Singleton Design Pattern can be controlled by the programmer.

            
class JTC{
	public static void main(String arg[]){
		
		// A obj = new A();
		
		A a1 = A.getA();
		A a2 = A.getA();
		A a3 = A.getA();

		System.out.println("a1 hashcode :- "+a1.hashCode());
		System.out.println("a2 hashcode :- "+a2.hashCode());
		System.out.println("a3 hashcode :- "+a3.hashCode());

		System.out.println("a1 == a2 :- "+(a1 == a2));
		System.out.println("a2 == a3 :- "+(a2 == a3));
		System.out.println("a1 == a3 :- "+(a1 == a3));

	}
}
class A{
	
	static A a1 = null;
	
	private A(){

	}
	
	static{
		a1 = new A();
	}

	static A getA(){
		return a1;
	}
}

    a1 hashcode :- 1652149987
    a2 hashcode :- 1652149987
    a3 hashcode :- 1652149987
    a1 == a2 :- true
    a2 == a3 :- true
    a1 == a3 :- true
            

In this example we can see that we have class A and default constructor A() that has private access modifier, so we can’t create Student class object from class JTC.
In class A as we can see we have a static type reference variable (static A a1 = null;) and in static block we are creating an object of class A and storing their reference into a1 reference variable (a1 = new A()). And finally we have a static method getA() which returns A class object to their caller.
We have declared static type reference variable because as we know that static variable gets memory only once. Thereafter we are creating an object inside the static block because we want to create only one object and this we can do only in static block since static block executes only once. Finally we are creating a static method getA() which returns the object of class A that we have created in static block.

• Some important members of java.lang.Runtime class.: -

            
class JTC{
	public static void main(String arg[]){

		// Runtime obj = new Runtime();
		
		Runtime r1 = Runtime.getRuntime();
		System.out.println("r1 hashcode :- "+r1.hashCode());
		
		Runtime r2 = Runtime.getRuntime();
		System.out.println("r2 hashcode :- "+r2.hashCode());

		System.out.println("r1 == r2 :- "+(r1 == r2));
		
	}
}

    r1 hashcode :- 1691875296
    r2 hashcode :- 1691875296
    r1 == r2 :- true
            

In this example there is a class which is class JTC and inside the JTC class first we are trying to create an object of Runtime class using new operator, but as we discussed Runtime class is designed on Singleton Design pattern and so their default constructor has private access modifier, that is the reason we get an error at compile-time.

In the next section we are using getRuntime() method to get object of java.lang.Runtime class. As we know that getRuntime() method returns same object at every invocation, that is the reason the hash codes of r1 and r2 are same and when we compare r1 and r2 using == operator we get true as result.

            
class JTC{
	public static void main(String arg[]){
	
    System.out.println("Numbers of Processor allocated to the current JVM processing :- ");
    System.out.println(Runtime.getRuntime().availableProcessors());}
}

    Numbers of Processor allocated to the current JVM processing :-
    4
            

In this example we are using two methods of java.lang.Runtime class which are getRuntime() and availableProcessors().Here we can see that first we are invoking Runtime.getRuntime() which returns an object of java.lang.Runtime class and using that object we are invoking availableProcessors() method to get the number of processors allocated for the current JVM processing.

            
class JTC{
	public static void main(String arg[]){
		
		System.out.println("Unused Heap Memory :- "+Runtime.getRuntime().freeMemory());

	}
}

    Unused Heap Memory :- 125810232
            

In the above example we are invoking Runtime.getRuntime() which returns an object of java.lang.Runtime class and using that same object we are invoking freeMemory() method which returns unused heap memory. Different invocations of freeMethod()may return different values. Here the memory measures are recorded in bytes.

            
class JTC{
	public static void main(String arg[]){
    System.out.println("Total Heap Memory :- "+Runtime.getRuntime().totalMemory());

	}
}

    Total Heap Memory :- 134217728
            

In this example we are invoking totalMemory() method of java.lang.Runtime class which returns the total amount of memory allocated to Heap area in bytes, the same method returns different values on different hosting environments.

            
class JTC{
	public static void main(String arg[]){
		
		System.out.println("Maximum limit of Heap  :- "+Runtime.getRuntime().maxMemory());
	}
}

    Maximum limit of Heap  :- 2118123520
            

            
class JTC{
	public static void main(String arg[]) throws Exception{
		
		// Dedicated to open mspaint.

		Runtime.getRuntime().exec("mspaint");

		// Dedicated to open calculator.

		Runtime.getRuntime().exec("calc");

		// Dedicated to open Notepad.

		Runtime.getRuntime().exec("notepad");

	}
}

In this example we have a class which is JTC and inside the JTC class we are using exec() method of java.lang.Runtime class to open mspaint, (exec(“mspaint”)), notepad (exec(“notepad”)) and calculator (exec(“calc”)).