Java on XGUGENG

What Is the Concurrent Mode Failure?

Wed, 31 Oct 2018 14:25:16 +0800

This is a question that I was asked during an interview: what does the concurrent mode failure means? It’s really a good question to check your understanding of Concurrent Mark Sweep (CMS) Collector.

This post starts with concurrent mode failure and explains the whole steps of one CMS cycle.

In a nutshell,

The message “concurrent mode failure” signifies that the concurrent collection of the Old Generation did not finish before the Old Generation became full.

Java NIO: Selector

Sat, 21 Jul 2018 17:54:50 +0800

Taking FileChannel for example in the previous post may bewilder audiences: it’s non-blocking, so how does NIO achievement non-blocking? Here comes Selector.

A Selector is a Java NIO component which can examine one or more NIO Channel’s, and determine which channels are ready for reading or writing. A thread can manage multiply channels with Selector making multiple network connections feasible. This way avoids the cost of switching between threads which is expensive.

Here is an illustration of a thread using a Selector to handle 3 Channels:

Java NIO: Channel

Thu, 19 Jul 2018 11:00:38 +0800

Channels are similar to streams available for blocking IO with a few differences:

You can both read and write to Channels. Streams are typically one-way (read or write).
Channels can be read and written asynchronously.
Channels always read to, or write from, a Buffer.

The Channels have multiple implementations depending on the data to be read or written:

FileChannel: Used to read and write data from and to the files
DatagramChannel: Used for data exchange over network using UDP packets
SocketChannel: TCP channel to exchange data over TCP sockets
ServerSocketChannel: An implementation similar to a web server listening to requests over a specific TCP port. It creates a new SocketChannel instance for every new connection

This post will take FileChannel for further exploration, from example to implementation.

Java NIO: Buffer

Sat, 14 Jul 2018 17:00:53 +0800

Java NIO (New IO), introduced by Java 1.4, is an alternative IO API for Java. It offers a different way of working with IO than the standard IO API’s.

Three core components of Java NIO cover:

Channels
Buffers
Selectors

All IO in NIO involves with Channel. Data can be read from Channel to a Buffer and vice versa.

Buffers are used to interact with Channels. A Buffer is an allocated block of memory with fixed size, into which you can read or write data. In this post, I’ll illustrate the basic usage of Buffer and elucidate how it manages to do that from the view of source code.

JVM Series: class File Format

Thu, 17 May 2018 16:52:29 +0800

Today, let’s focus on the class file format, the hardware- and operating system-independent binary format used to represent compiled classes and interfaces.

A class file consists of a stream of 8-bit bytes. All 16-bit, 32-bit, and 64-bit quantities are constructed by reading in two, four, and eight consecutive 8-bit bytes, respectively.

JVM Series: Class Loader

Wed, 18 Apr 2018 18:27:20 +0800

The Java Classloader, a part of the Java Runtime Environment, dynamically loads Java classes into the Java Virtual Machine. Each Java class must be loaded by a class loader.

JVM Series: Oop and Klass

Tue, 10 Apr 2018 14:46:26 +0800

As a part of JVM Series, this post tries to explore the object model in JVM.

JVM Series: Overview

Tue, 09 Jan 2018 20:56:47 +0800

When executing a java program, you may simply input in terminal, like:

javac HelloWorld.java
java HelloWorld

Behind these commands, JVM, as the cornerstone of the Java platform, does a lot of work, which are what this blog attempts to figure out. Today, a new series about JVM will be started, and this is the first episode.

JDK Build-in Development Tools

Thu, 14 Sep 2017 16:20:46 +0800

The following documents contain important information you will need to know to get the most out of the JDK tools.

Mind Maps for Java and JVM

Fri, 16 Jun 2017 18:14:16 +0800

These two mind maps are drawn for the further exploration of Java and JVM. For Java I try to cover some advanced features ranging from NIO and Thread. As to JVM, few components are covered, of course, I will replenish it at any moment.

Differences between Hashtable and HashMap

Fri, 05 Aug 2016 12:01:40 +0800

As I mentioned before, it is vital to read code with prepared questions. Hum, How about reading code with answers? The differences between Hashtable and HashMap have been explained many times including,

null key & null value
synchronized or not
Enumeration and Iterator
hash method

I am wondering how these arguments are supported by code. This post will give a view of code illustrating the above confusion.

Java HashSet

Mon, 01 Aug 2016 11:45:53 +0800

For those who has no patience to look through this post, I conclude it in a word: HashSet is backed by HashMap.

Set is a collection in which every element is unique. So does the keys in HashMap. It is reasonable to infer that the implementation of HashSet is based on HashMap, so it is. Remember resize of HashMap? it makes no guarantees as to the iteration order of the set.

With the help of HashMap, HashSet offers constant time performance for the basic operations, like add, remove, contains and size. Iterating over this set requires time proportional to the sum of the HashSet instance’s size (the number of elements) plus the “capacity” of the backing HashMap instance (the number of buckets).

Java TreeMap

Sun, 12 Jun 2016 12:54:23 +0800

After joining the workforce, I have coded with various programming languages, like C++, Objective-C, Ruby, Python, Scala, Java, Go, etc. I ask to myself spontaneously, which language am I most skillful at? This question dismay me because I cannot answer it immediately.

Since I choice to focus on Big Data, it’s pragmatic to equipped with Java and Python, two powerful weapons in this field. Reading the source code of java.util is a good start.

The leading actor of this post is TreeMap, a Red-Black tree based NavigableMap implementation. It has no array underneath, as many of you think. Because TreeMap inherits directly AbstractMap, in contrast with LinkedHashMap.

Performances differ on account of distinctive data structures. This implementation provides guaranteed log(n) time cost for the containsKey, get, put and remove operations. Now allow me to show you a close look.

Java LinkedHashMap

Fri, 10 Jun 2016 20:01:59 +0800

As its name implies, LinkedHashMap is a hash table and linked list implementation of the Map interface, with predictable iteration order. Different with HashMap, it maintains a doubly-linked list running through all of its entries, which also defines the iteration ordering, same as the order in which keys were inserted into the map. This order remains if a key is re-inserted into the map.

Like HashMap, LinkedHashMap provides constant-time performance for the basic operations add, contains and remove, assuming the hash function disperses elements properly among the buckets. Performance is likely to be just slightly below that of HashMap, due to the added expense of maintaining the linked list,

Thanks to the linked list, this kind of map is well-suited to building LRU caches. So my questions is how LinkedHashMap preserves the linked list when key changes.

Java HashMap

Thu, 09 Jun 2016 20:42:52 +0800

It’s necessary to learn with questions. Otherwise, you may distract your focus when something you don’t know appears, whether should I go deeper or not. With preliminary doubts in your mind, this would not be a problem. Learning can be direct, clear and fruitful, which brings you more sense of achievement.

For this post about the source code of HashMap, few questions need answers:

data structure underneath
why HashMap permits nulls and unsynchronized
does it make guarantees as to the order of the map
what happens when I put and get a key with value, and time complexity
how the map shrink or expand when size changes

Java LinkedList

Mon, 18 Apr 2016 11:37:29 +0800

LinkedList is a doubly-linked list implementation of the List and Deque interfaces. By “doubly-linked”, it means we can traverse the list from the beginning to the end, and vice versa. This class is a member of Java Collections Framework, located in java.util. Let’s go straight to the source code.

Java String

Wed, 13 Apr 2016 11:33:34 +0800

String is one of the most common type of data in computer languages. A Java string is a series of characters gathered together, such as “abc”. Strings are constant, which means their value cannot be changed after created.

This post introduces the basic of Java string, includes methods for examining individual characters of the sequence, for comparing strings, for searching strings, for extracting substrings and so on.