Java Garbage Collection

Garbage collection is the process of looking at heap memory, identifying which objects are in use and which are not, and deleting the unused objects.

unused objects are considered to be any instances that cannot be reached by a live thread or for circularly referenced instances that cannot be reached by any other instances.

The basic process are :

1. Marking : garbage collector identifies which objects are used and which are unused.
2. Deletion: remove unused object and pointer to free space.
3. Compacting : To improve performance move used object together so that there is no gap among them.   

Having to mark, delete and compact all the objects in a JVM is inefficient. empirical analysis of applications has shown that most objects are short lived and fewer objects remain allocated over time hence JVM Heap is broken into smaller parts as Young Generation, Tenured/ Old generation, Permanent Generation(removed in java 8).

Young Generation: This part of the heap is further divided into Eden Space, First survivor space, and Second survivor space.

Old Generation: long survived object are stored after minor GC.  

Permanent Generation: contain metadata of class and methods  required by JVM.

Few Important Terms:

Minor GC: minor GC triggered when JVM unable to allocate memory for new object. Generally when Eden space is full.

Major GC: happens for the Old Generation or aged Objects.

Stop The World : All minor/major garbage collections are "Stop the World" events means that all application threads are stopped until the operation completes.

Generational Garbage Collection Process:

1. New objects are allocated to the eden space.
2. When eden space is full minor GC triggered referenced object moved to first survivor space and eden space is cleared. During each minor GC aged object from first survivor space moved to second survivor space.
3. As minor GCs continued age of the survived objects incremented and at certain threshold they moved to Old generation space. a major GC will be performed on the old generation which cleans up and compacts that space.

Garbage Collectors:

The Java HotSpot VM includes three different types of collectors, each with different performance characteristics.

1. Serial Collector : Uses a single thread to perform GC hence it cannot take advantage of multiprocessor useful for application with small data sets. The serial collector is selected by default on certain hardware and operating system configurations, or can be explicitly enabled with the option -XX:+UseSerialGC.

2. Parallel Collector: known as the throughput collector performs collections in parallel, which can significantly reduce garbage collection overhead and intended for applications with medium-sized to large-sized data sets that are run on multiprocessor or multithreaded hardware. default on certain hardware and operating system configurations, or can be explicitly enabled with the option -XX:+UseParallelGC.

3. Concurrent collector :  Java Hotspot VM has two mostly concurrent collectors are Concurrent Mark Sweep(CMS Collector) and Garbage-First Garbage Collector(java 8).

Characterize the actual different primary garbage collectors:

Young generation collectors

1. Serial collector (enabled with -XX:+UseSerialGC)
2. PS Scavenge (enabled with -XX:+UseParallelGC)
3. ParNew (enabled with -XX:+UseParNewGC)
4. G1 Young Generation (enabled with -XX:+UseG1GC)

Old generation collectors

1. MarkSweepCompact (enabled with -XX:+UseSerialGC)
2. PS MarkSweep (enabled with -XX:+UseParallelOldGC)
3. ConcurrentMarkSweep (enabled with -XX:+UseConcMarkSweepGC)
4. G1 Mixed Generation (enabled with -XX:+UseG1GC)

All of the garbage collection algorithms except ConcurrentMarkSweep are stop-the-world, it tries to do most of it's work in the background and minimize the pause time, but it also has a stop-the-world phase and can fail into the MarkSweepCompact which is fully stop-the-world.

Reference :

http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html

Spring Transaction

Transaction comprises of a unit of work against a database. Transaction provides “all or noting” preposition unit of work performed entirely committed or rollback.

Unit of work: consider to transfer account balance from account A to account B we have to debit account A and credit account B and this is a unit of work performed to do transfer.

Acronym ACID describes the nature or properties for transaction.

•   Atomic: All of the operations in a transaction happen or none of them happen.  
•   Consistent: After a successful or failed transaction system is left in a consistent state.
• Isolation: it is about concurrent read write if two or more transaction progressing at time. 
•  Durable: after a successful transaction data is persisted permanently.  

Transaction attributes:

• Propagation

1.     PROPAGATION_REQUIRED: transaction already exists then the code will use it otherwise a new transaction is created. This is the default.

2.     PROPAGATION_SUPPORTS: transaction exists then the code will use it, but the code does not require a new one.

3.     PROPAGATION_MANDATORY: Participates in an existing transaction, however if no transaction context is present then it throws a TransactionRequiredException.

4.     PROPAGATION_REQUIRES_NEW: new transaction and if an existing transaction is present then it is suspended. When the new transaction is complete then the original transaction resumes.

5.     PROPAGATION_NOT_SUPPORTED: operations needs to be performed non-transitionally.

6.     PROPAGATION_NEVER: code cannot be invoked within a transaction. if an existing transaction is present then an exception will be thrown.

7.     PROPAGATION_NESTED: code is executed within a nested transaction if existing transaction is present; if no transaction is present then a new transaction is created.

• Isolation

1.     ISOLATION_DEFAULT: Use the isolation level of the underlying database. This is the default.

2.     ISOLATION_READ_UNCOMMITTED:  dirty reads, phantom reads and non-repeatable reads.

3.     ISOLATION_READ_COMMITTED: prevents dirty reads but allows phantom reads and non-repeatable reads.

4.     ISOLATION_REPEATABLE_READ: prevents dirty reads and non-repeatable reads but allows phantom reads.

5.     ISOLATION_SERIALIZABLE: prevents dirty reads, non repeatable reads and phantom reads.

Dirty Reads- Dirty reads occur when transaction B reads data that has been modified by transaction A but not committed. The problem occurs when transaction A rollbacks the transaction, in which case the data read by transaction B will be invalid.

Non Repeatable Reads- Non-repeatable reads happen when a transaction fires the same query multiple times but receives different data each time for the same query.

Phantom Reads - Phantom reads occur when the collection of rows returned is different when a same query is executed multiple times in a transaction.

• Read only: The read only attribute specifies that the transaction is only going to read data from a database. by default false.
• Rollback rule: specify that transactions roll back on certain exceptions and do not rollback on other exceptions.By default RuntimeException.
• Timeout: Timeout specifies the maximum time allowed for a transaction to run then rolled back.

Spring Transaction supports:

• It offers both programmatic and declarative transaction.
• Declarative transaction can be used in stand-alone application unlike EJB.
• Support wide range of transactional manager,.
• Spring transactions are good at application using single database. I multiple databases access required have to use XA transaction of JTA.

Spring transaction managers: soring does not manage transaction directly rather delegate the responsibility to configured platform specific transaction manager.

JDBC	DataSourceTransactionManager
Hibernate	HibernateTransactionManager
JDO	JdoTransactionManager
JTA	JtaTransactionManager
JPA	JpaTransactionManager

x