DEV Community: Amit Mishra

Why Java's Automatic Memory Management Makes it a Powerful Language: Everything you need to know

Amit Mishra — Sat, 14 Jan 2023 17:58:08 +0000

Java's automatic memory management, also known as garbage collection, is a powerful feature that makes it easy for developers to write code without worrying about freeing up memory. In many other programming languages, developers are responsible for manually allocating and freeing memory, which can lead to errors and memory leaks if not done properly. With Java's automatic memory management, the Java Virtual Machine (JVM) takes care of allocating and freeing memory, which greatly simplifies the process of writing code.

One of the key benefits of automatic memory management is that it helps to prevent memory leaks, which occur when a program holds onto a memory that is no longer needed. Memory leaks can cause a program to consume an increasing amount of memory over time, eventually leading to the program crashing or freezing. With automatic memory management, the JVM periodically checks for objects that are no longer in use and frees up the associated memory, helping to prevent memory leaks.

Another benefit of automatic memory management is that it can improve the performance of a program. When a program manually manages memory, it can be time-consuming and resource-intensive to repeatedly allocate and free memory. With automatic memory management, the JVM can make more efficient use of memory and reduce the amount of time and resources required to manage memory.

Java's automatic memory management also makes it easier to write concurrent code, because it eliminates the need to manually synchronize access to memory. This allows multiple threads to safely access the same memory without having to worry about conflicts.

In conclusion, Java's automatic memory management is a powerful feature that simplifies the process of writing code, improves the performance and stability of a program, and makes it easier to write concurrent code. It helps developers focus on the logic and functionality of their program rather than worrying about memory management.

How Java's Automatic Memory Management works:
The JVM periodically checks for objects that are no longer in use and frees up the associated memory.

The JVM uses a technique called "garbage collection" to identify and remove objects that are no longer needed by a program. The JVM maintains a heap of memory, which is where objects are created and stored. When an object is no longer being used by a program, it becomes eligible for garbage collection.

To identify eligible objects, the JVM uses a technique called "mark and sweep." The JVM first marks all objects that are currently in use by a program. It then sweeps through the heap and frees up any objects that are not marked.

There are several different algorithms that the JVM can use to perform garbage collection, such as the mark-and-sweep algorithm, the mark-and-compact algorithm, and the concurrent mark-and-sweep algorithm. The JVM's garbage collector also uses a technique called "compacting" to defragment the heap and reduce fragmentation, which improves memory usage and performance.

The JVM's garbage collector also uses a technique called "compacting" to defragment the heap and reduce fragmentation, which improves memory usage and performance.
In conclusion, Java's automatic memory management makes the program more stable and efficient by freeing up memory that is no longer being used. The JVM periodically checks for objects that are no longer in use and frees up the associated memory using different algorithms such as mark-and-sweep, mark-and-compact, and concurrent mark-and-sweep. Additionally, heap fragmentation is reduced using compaction. This way, it eliminates the need for developers to manually allocate and free memory, which can lead to errors and memory leaks if not done properly and makes it easier to write concurrent code.

Different steps performed by JVM for Memory Management:

The Java Virtual Machine (JVM) uses several methods and actions to perform memory management. These include:
Garbage Collection: This is the main method used by the JVM to manage memory automatically. The JVM periodically checks for objects that are no longer in use and frees up the associated memory. The JVM uses different algorithms to perform garbage collection, such as the mark-and-sweep algorithm, the mark-and-compact algorithm, and the concurrent mark-and-sweep algorithm.
Memory Allocation: The JVM uses memory allocation to assign memory to new objects. The JVM uses different algorithms to perform memory allocation, such as the buddy system algorithm, the first-fit algorithm, and the best-fit algorithm.
Object Reachability: The JVM uses object reachability to determine whether an object is still in use or can be garbage collected. An object is considered reachable if it can be accessed by the program or if it is reachable through a chain of other reachable objects.
Compacting: The JVM uses compaction to defragment the heap and reduce fragmentation. This improves memory usage and performance by reducing the amount of unused space in the heap.
Memory Tuning: The JVM uses memory tuning to optimize memory usage and performance. Memory tuning involves adjusting various parameters, such as the size of the heap, the size of the stack, and the garbage collection algorithm used.
Memory Profiling: The JVM uses memory profiling to monitor the memory usage of a program and identify potential memory leaks or other issues. Memory profiling can be used to track the number of objects created and the amount of memory used by a program over time.

All of these methods and actions are used together by the JVM to perform automatic memory management in a way that is efficient, stable and optimized for the program's needs.

What type of task and algorithm JVM performs for Automatic Memory Management:
The Java Virtual Machine (JVM) performs several tasks to manage memory automatically in Java. One of the main tasks is to identify and remove objects that are no longer needed by a program, also known as garbage collection. The JVM uses different algorithms to perform this task.
Mark-and-Sweep Algorithm: In this algorithm, the JVM first marks all the objects that are currently in use by a program. It then sweeps through the heap and frees up any objects that are not marked. This algorithm is simple and easy to implement, but it can cause the program to pause, or "stop the world," during garbage collection, which can affect performance.
Mark-and-Compact Algorithm: This algorithm is similar to the mark-and-sweep algorithm, but it also compacts the heap after sweeping to reduce fragmentation. This improves memory usage and performance, but it can also cause the program to pause during garbage collection.
Concurrent Mark-and-Sweep Algorithm: This algorithm performs garbage collection concurrently with the program, which means that the program can continue to run while garbage collection is taking place. This can help to reduce the impact of garbage collection on performance, but it can be more complex to implement.
Generational Garbage Collection: This is a variation of the mark-and-sweep algorithm, it uses the assumption that most objects die young, and divides the heap into two parts, one which is called Eden and the other called Old Gen. Eden is used for new objects and the old gen is where long-lived objects are kept. The garbage collection algorithm checks and frees up the Eden space more frequently than the Old Gen space.

These are the main algorithms that the JVM can use to perform garbage collection. The JVM's garbage collector also uses a technique called "compacting" to defragment the heap and reduce fragmentation, which improves memory usage and performance. Additionally, the JVM can also use multiple algorithms in combination, such as the parallel scavenge 👇 and serial old algorithm 👇, to perform garbage collection more efficiently.

parallel scavenge and serial old algorithm :
Parallel scavenge and serial old algorithm is a combination of two garbage collection algorithms used in the Java Virtual Machine (JVM) to perform automatic memory management.
Parallel Scavenge: This algorithm is used to collect young generation objects. It uses multiple threads to scan and collect new objects. The algorithm is designed to minimize the impact on application performance by running concurrently with the application.
Serial Old: This algorithm is used to collect old-generation objects. It uses a single thread to scan and collect the old objects. The algorithm is designed to be more efficient than a single-threaded mark-and-sweep algorithm and is able to reclaim large amounts of memory quickly and effectively.

The parallel scavenge algorithm is used to manage the heap space that contains short-lived objects, while the serial old algorithm is used to manage the heap space that contains long-lived objects. By using these two algorithms together, the JVM is able to perform automatic memory management more efficiently, as each algorithm is optimized for its specific task.

This combination of algorithms is highly efficient, as it can reduce the time taken for the garbage collection cycle by running them concurrently, and also it can also reduce the overall impact of garbage collection on the application's performance. Additionally, this combination of algorithms is also known as the parallel old garbage collector.

Follow me @amymishra11 for more.
Thanks for being here.
Happy Coding ✌✌✌
Visit www.javaoneworld.com for more

Beyond the Basics: 10 Uncommon Features That Make Java a Powerful Language

Amit Mishra — Fri, 13 Jan 2023 18:17:08 +0000

When anyone talks about java and its features, why choose java,
what makes Java different from others etc.
For the above type of questions mostly you'll listen to the predefined answers - like

Platform independence
Object-oriented programming
Large developer community
Robustness
Security
etc.

Although these are obviously correct, these points play a major role, but apart from that we have lots of other reasons why java is the most powerful language.

Here are Some Beyond the Basics

Dynamic proxies: Java's support for dynamic proxies makes it easy to create objects that can mimic the behavior of other objects, making it useful for tasks such as mocking and testing.

Native XML support: Java's built-in support for XML through libraries such as JAXB and DOM makes it easy to work with XML data in a Java application.

Reflection: Java's built-in reflection API makes it possible to inspect and manipulate classes and objects at runtime, making it useful for tasks such as debugging and code generation.

Built-in regular expressions: Java's built-in support for regular expressions makes it easy to search and manipulate text data in a Java application.

Built-in cryptography: Java's built-in support for cryptography makes it easy to add security features to a Java application, such as encryption and digital signing.

Dynamic scripting support: Java's built-in support for dynamic scripting languages, such as JavaScript, through libraries like Rhino, makes it easy to add scripting functionality to a Java application.

Follow the below link to read the complete post.

10 Uncommon Features That Make Java a Powerful Language

Follow @amymishra11 for more.

ChatGPT: 20 Fun Ways to put this Clever AI to work.

Amit Mishra — Sat, 31 Dec 2022 18:10:44 +0000

CHATGPT Your Go-To source for fun and innovation

ChatGPT the AI Companion that offers Endless Entertainment Options.

Here are 20 ideas for entertaining uses of ChatGPT.

Have ChatGPT help you come up with ideas for things to do or places to go.

Use ChatGPT to create a choose-your-own-adventure style story.
Have ChatGPT play the role of a character in a role-playing game.
Use ChatGPT to generate jokes or puns.
Have ChatGPT help you write a letter or email.
Use ChatGPT to generate ideas for new recipes or meal plans.
Have ChatGPT write a short story or poem.

For more ....

ChatGPT 20 Fun Ways to use it

Follow me for such well written article.

Happy coding.

Log4j2 vulnerability

Amit Mishra — Thu, 16 Dec 2021 21:58:56 +0000

No one leaving the battle ground, neither developer nor hacker 😂😂.

As soon as developer got some fix immediately the another guy(bad guy) trying to breakdown the fix.

Log4j2 vulnerability

As per an article

log4j security flaw prompting 100 new hacking attempts every minute.

Log4j Vulnerability

Amit Mishra — Thu, 16 Dec 2021 21:52:14 +0000

Summary of the Vulnerability

On Dec. 9, 2021, a remote code execution (RCE) vulnerability in Apache log4j 2 was recognized as being taken advantage of in nature. Public proof of concept (PoC) code was delivered and the resulting examination uncovered that double-dealing was unbelievably simple to perform. By presenting a uniquely created solicitation to a weak framework, contingent upon how the framework is designed, an aggressor can teach that framework to download and consequently execute a malicious payload. Because of the disclosure of this adventure being so later, there are as yet numerous servers, both on-premises and inside cloud conditions, that presently can't seem to be fixed. In the same way, as other high seriousness RCE takes advantage of, hitherto, enormous checking movement for CVE-2021-44228 has started on the web with the aim of searching out and taking advantage of unpatched frameworks. We enthusiastically prescribe that associations move up to the most recent rendition (2.16.0) of Apache log4j 2 for all frameworks. This form additionally fixes the less extreme vulnerability CVE-2021-45046, found on Dec. 14.

Well explained article on the log4j2 vulnerability.

Log4j2 vulnerability

Still the team looking into and trying to root cause of this.

JDK 18: What to expect in Java 18

Amit Mishra — Thu, 02 Dec 2021 20:59:22 +0000

*Due in March 2022, Java 18 has attracted recommendations to hatch the vector API, preview pattern matching for switch statements, and embrace UTF-8 as the default character set. *

Due in March 2022, Java 18 keeps on adding highlights, with nine component recommendations being considered for it up until this point, including the deprecation of finalization, a capability that was intended to help avoid resource leaks but has brought with it risks of unconstrained behavior and unpredictable latency.

The OpenJDK page for Java Development Kit (JDK) 18 records the accompanying elements as authoritatively focusing on JDK 18 as of November 24: a service provider interface, a basic web server, a vector API, code snippets, a reimplementation of core reflection, a UTF-8 charset, the second incubator of a foreign function and memory API, and the second preview of pattern matching for switch statements. Deprecation of finalization is proposed to target JDK 18 in the JDK Enhancement Proposal (JEP) record.

Upcoming feature Specifics of the JDK 18 proposals includes

How to force jvm to share same memory pool between two string object? intern() in java.

Amit Mishra — Thu, 08 Jul 2021 14:38:28 +0000

 String str1 = new String ("javaoneworld"); 
  String str2  = new String ("javaoneworld");

System.out.println(str1 == str2); //false but it can be true also 🤔
/*
  * as we initializing str1 and 
str2 with new keyword so they 
will not share the
  * same memory pool
  */

  System.out.println(str1 == str2); //false

But what if I want true for the above statement?

How ?

So the only way to get this is ,if somehow we force jvm to share the same memory pool to both the variable.

So is it possible?

Yes absolutely, it's possible, click on below to see how.

  /*
 * using the intern() method we can force both the string to share same memory
 * pool
 */

     str1 = str1.intern();
     str2 = str2.intern();

     System.out.println(str1 == str2); //true

https://www.javaoneworld.com/2021/07/java-amazing-interesting-and-cool-tricks.html?m=1

code #codechallenge

coders

coderlife

CodeIgniter

java

javadevelopment

javadeveloper

javacode

javatricks

Does Java provide something which can clear all the cache at once?👆👆👆👆

Amit Mishra — Fri, 18 Jun 2021 05:46:00 +0000

Does Java provide something which can clear all the cache at once?👆👆👆👆❓❓❓

The answer is NO 👎👎👎😕😕😕.

Java does not provide any such feature which can clear all the cache at once.👍👍👍👍

So how do clear all the cache?😞😞😞
Found the Complete post below👇👇👇👌

https://www.javaoneworld.com/2021/06/how-to-clear-cache-in-springboot-java.html?m=1

happycoding

staysafe

stayCode

Find odd even using Bitwise operator.

Amit Mishra — Mon, 17 May 2021 09:44:05 +0000

Here we'll use & operator to find thae number is Odd or Even.

public class JavaOneWorld {
public static void main(String 
     args[]) {
     int x= 7;

   if((x&1)==0){
     System.out.println("even");
 }else{
    System.out.println("odd");
    }
   }
  }

The idea behind using the & operator !!!!!

As we already know binary works only on 1 and 0.
and a number is either odd or even,
so if a number is even then the last bit of that number must be 0 and if odd then the last bit must be 1.

i.e.-

5 odd
101 last bit is 1.

4 even

100 last bit is 0.

so here we have to use this property to find out the odd/even

Deep dive in this post...

https://www.javaoneworld.com/2021/05/find-odd-even-using-bitwise-operator.html?m=1

Bitwise or mathematical which operator is best to swap two number?

Amit Mishra — Sun, 28 Mar 2021 06:47:22 +0000

Hi dev...share your observations?

 x = x^y;
 y = x^y;
 x = x^y;


 Or

 temp = x;
 x = y;
 y = temp;

Which one is better?

Swap two number using Bitwise operators without using third variable.

Amit Mishra — Sun, 28 Mar 2021 06:39:35 +0000

28 Mar ・1 min read
Bitwise operators are always more efficient than mathematical operators.

And reason behind this is, Bitwise operators directly work on bits that's why.

So going with Bitwise operators will be good.

https://www.javaoneworld.com/2020/03/swap-two-numbers-using-bitwise-operator.html?m=1

Are you using pure Black color for the Text on white background? Stop please.

Amit Mishra — Wed, 24 Mar 2021 14:28:40 +0000

1- Are you going to implement dark theme in your app?

2- Which text color you should use on white background?

so for the above both task if you are using pure Black

000000 rgb(0, 0, 0)

Stop please.

Then what?
Here is a beautiful post on different shade of black color, which we can use for the same.

https://www.javaoneworld.com/2020/08/best-black-shade-color-code.html?m=1

DEV Community: Amit Mishra

Why Java's Automatic Memory Management Makes it a Powerful Language: Everything you need to know

Beyond the Basics: 10 Uncommon Features That Make Java a Powerful Language

ChatGPT: 20 Fun Ways to put this Clever AI to work.

Log4j2 vulnerability

Log4j Vulnerability

JDK 18: What to expect in Java 18

How to force jvm to share same memory pool between two string object? intern() in java.

code #codechallenge﻿﻿

coders

coderlife

CodeIgniter

java

javadevelopment

javadeveloper

javacode

javatricks

Does Java provide something which can clear all the cache at once?👆👆👆👆

happycoding

staysafe

stayCode

Find odd even using Bitwise operator.

Bitwise or mathematical which operator is best to swap two number?

Swap two number using Bitwise operators without using third variable.

Are you using pure Black color for the Text on white background? Stop please.

000000 rgb(0, 0, 0)

code #codechallenge