Posts on XGUGENG

Redis Internals: File Event Handling

Sun, 28 Apr 2019 20:20:38 +0800

Events are the core of Redis server, reponsible for dealing with two important tasks:

File events: receive the requests from multiple clients, process and responde to clients.
Time events: server cron job.

In this post, we will take a look at multiplexing event handling processing requests from clients. Clients connect to Redis server via sockets, but the server interacts with these clients only when the sockets can be read or written without blocking.

Connection Pool in redis-py

Fri, 18 Jan 2019 10:52:17 -0800

A typical example of using Collection Pools in redis-py is:

pool = redis.ConnectionPool(host='localhost', port=6379, db=0)
r = redis.Redis(connection_pool=pool)

Redis Internals: Dict

Thu, 15 Nov 2018 19:56:57 +0800

Dictionary is a data structure for storing key-value pair. Each key in a dictionary is unique and has a corresponding value. Redis implements its own dictionary and use it for hash key.

As a data structure in server side, dictionary must take memory into consideration. That’s the reason why resizing and rehashing are so significant.

Redis Internals: List

Tue, 06 Nov 2018 09:38:12 +0800

Redis provides a generic doubly linked list implementation, which is widely used in Redis. If a list key involves two many elements or there are many long strings in the list, Redis will apply linked list for it. Publish-subscribe, slow query, monitor also make use of linked list. Redis keeps the states of clients in linked list, and client’s output buffer use it too.

This post will plough into the implementation of doubly linked list.

Weak References

Mon, 05 Nov 2018 20:46:15 +0800

In Python, objects are never explicitly destroyed. However, they may be garbage-collected when they become unreachable.

The del statement deletes names, not objects. An object may be garbage collected as result of a del command, but only if the variable deleted holds the last reference to the object, or if the object becomes unreachable.

In CPython, the primary algorithm for garbage collection is reference counting. Essentially each object keeps count fo how many references point to it. As soon as that refcount reaches 0, the object is immediately destroyed: CPython calls the __del__ method on the object (if defined) and the frees the memory.

But sometimes, it is useful to have a reference to an object that does not keep it around longer than necessary. Week references to an object do not increase its reference count. A weak reference does not prevent the referent from being garbage collected.

Variables Are Labels, Not Boxes

Thu, 01 Nov 2018 14:51:40 +0800

Variables are labels, not boxes. Take the following code for example:

a = [1, 2, 3]
b = a
a.append(4)
print(b)

If you imagine that variables are like boxes, you cannot make sense of assignment in Python. For an assignment, you must always read the right-hand side first: that’s where the object is created or retrieved. After that, the variable on the left is bound to the object, like a label stuck to it. Just forget about the boxes.

Redis Internals: SDS

Thu, 01 Nov 2018 09:26:50 +0800

C string is used only for literal constant in Redis. For the situation that the string can be modified, Redis provide a Simple Dynamic String(SDS). The key in Redis is actually a SDS, and if you insert a key-value with SET msg "hello world", a SDS instance will be constructed for the key. In this case, the value is also a SDS instance with the content of “hello world”.

Besides string, SDS is also used for buffer which can serve the AOF module and client’s input.

This post will dive into the implementation of SDS comparing with classic C string.

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.

When Python Executes Decorators

Mon, 29 Oct 2018 14:55:25 +0800

A key feature of decorators is that they run right after the decorated function is defined. This is usually at import time.

Design Patterns with First-class Functions

Sat, 27 Oct 2018 16:16:13 +0800

Design patterns are language-independent, but in the context of languages with first-class functions, it’s beneficial to rethink some patterns. The general idea is: you can replace instances of some participant class with simple functions, reducing a lot of boilerplate code.

In this post, I will refactor Strategy using functions objects.

A List Comprehension Puzzler

Wed, 24 Oct 2018 11:19:09 +0800

Sometimes, we need to initialize a list with a certain number of nested lists, for example, a list with 3 lists of length 3 that can represent a Tic-tac-toe board.

>>> board = [[''] * 3] * 3
>> board
[['', '', ''], ['', '', ''], ['', '', '']]
>> board[1][2] = 'X'
>> board
[['', '', 'X'], ['', '', 'X'], ['', '', 'X']]

The output is not expected, why?

What Happens When Starting Redis

Mon, 22 Oct 2018 17:23:59 +0800

Redis is a great example of high-performance server. When I worked as a backend developer, my mentor recommended that I should read the code of Redis. And so I did, it’s rewarding. As the time goes by, the ideas behind Redis are still cutting-edge, so I think it’s time to retrospect the implementation of Redis. This post is a good beginning.

It’s my habit to start from the entry when meeting a big project. In Redis, server.c is responsible for bootstrap, that’s what I pay close attention to in this post.

Using Mixins with Python

Thu, 18 Oct 2018 08:15:29 +0800

Python supports multiple inheritance, while it doesn’t provide the syntax for interface. See PEP-0245. Of course, you can use the abc module for abstract base classes, which seems tricky.

Python introduces a concept called mixin that encapsulates behavior that can be reused in other classes. It’s supported via multiple inheritance, the difference of inheritance and mixin is, inheritance means “is-a” and mixin means “has-a”.

This post will illustrate how mixin works with a simple example.

Special Methods in Python Data Model

Tue, 16 Oct 2018 15:19:05 +0800

You can think of the Data Model as a description of Python as a framework. It formalizes the interfaces of the building blocks of the languages itself, such as sequences, iterators, functions, classes, context managers and so on.

Python allows operator overloading, which let us to define the custom behavior for a class. For instance, if a class defines a __str__(), then it can return a readable string representation of an object.

In this post, I will enumerate some special methods that can change the behavior of an object and may putted into practice in daily work.

Managing Ordered Sequences With bisect

Mon, 24 Sep 2018 14:16:14 +0800

The bisect module offers two main functions - bisect and insort - that use the binary search algorithm to quickly find an d insert items in any sorted sequence.

Python Closure

Wed, 19 Sep 2018 18:38:29 +0800

A closure is a function with an extended scope that encompasses non-global variables but not defined there. It does not matter whether the function is anonymous of not, what matters is that it can access non-global variables that are defined outside of its body.

A Few Things That I Know About Spark

Mon, 03 Sep 2018 20:52:46 +0800

This post concludes a global view of Spark using a mind map, in which I try to enumerate what I know about it. A graph for the relationship of terminologies like Job, Stage is illustrated firstly so that you would be confused.

Handling Missing Keys in Python

Mon, 27 Aug 2018 14:50:08 +0800

In line with fail-fast philosophy, dict access with d[k] raises an error if k is not an existing key. A common solution is d.get(k, default) which return a default rather handling KeyError if k is not present.

This post introduces three alternatives - setdefault, defaultdict and __mising for this situation.

Consensus in Distributed System

Sun, 19 Aug 2018 16:07:16 +0800

The distributed consensus problem deals with reaching an agreement on a single data value among a group of process connected by an unreliable network. The processes must put forth their candidate values, communicate with one another, and agree on a single consensus value in presence of failures of some processes.

Examples of applications of consensus include:

Leader election / Mutable Exclusion
Commit or Abort in distributed transactions
Reaching agreement about which process has failed
Clock phase synchronization
Load balancing

A visual diagram of this problem unfolds in the following. Each process p_k with an input value u_k runs a program to exchange its value. Finally the output of all non-faulty processes become identical. It is permissive that one or more processes may fail at any time, but the output v must be equal to the value of at least one process.

Unpacking in Python

Tue, 14 Aug 2018 20:02:15 +0800

Python provides many friendly advanced API for programmer, one of which is unpacking. By unpacking, it means getting all the elements from a container. A simplest case in the below demonstrates assigns the two items in tuple to variables.

>>> a, b = (1,2)
>>> a
1
>>> b
2

Besides tuple, every iterative object can support unpacking, such as list, dictionary, set, string, generator etc. Let’s traverse them one by one.

A Quick Retrospect of Design Pattern

Mon, 13 Aug 2018 15:24:26 +0800

This post summarizes some design patterns I used in daily work or learnt from books.

Linux: Principles, Manual and Programming

Fri, 10 Aug 2018 10:27:16 +0800

This post only involves three mind maps for Linux covering principles, manual and programming. I find it is beneficial to organize my knowledge with mind map.

I also realized a few captions are also useful for the full picture, so they are attached.

Refactor: Why, What, When and How

Wed, 08 Aug 2018 10:45:36 +0800

I read Refactoring: Improving the Design of Existing Code while chasing my master degree and did not realize how beneficial it would be considering the number of lines I wrote.

After joining the workforce, I found its importance can never be overstressed. It is rewarding to read this book over and over, so I draw this mind map for quick index.

Binary Search for Upper Bound

Fri, 03 Aug 2018 10:55:27 +0800

A frequent question I ask when interviewing some candidates is binary search. It cannot be more easier to write a binary search, but the variant may be challenging. For example, upper bound for the given target. When should I shrink my scope to left?

This post elucidates the steps of binary search by illustrating some common mistakes and sloving a problem in LeetCode. And I will remind what should be paid more attention when doing search.

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.

Learn Consciously

Sun, 15 Jul 2018 17:53:35 +0800

Learning is an eternal topic for everyone, no matter which field you are engaging in. I highly admire the guys who produce excellent performance in any specific domain. It needs patience, and hours and hours will be spent on practice. Aside from tenacity, there must be something related contributing to their success.

Two books changed my perspective of learning. The first one is The Art of Learning telling a remarkable story of personal achievement and inspires me with a series of principles for improving performance in any field. The other, Learn Better, demonstrates that how we learn can matter just as much as what we learn.

Stimulated by my preparation for IELTS recently, I think it must be rewarding to summarize my strategy of learning, active learning or conscious learning. Most of ideas come from the above books, and I put them into practice again and again proving their effectiveness.

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.

How HMaster Detect Death of RegionServer

Fri, 06 Jul 2018 10:31:19 +0800

Step 3 of explanation about what happens after Full GC may be vague. It confuses audiences by

ServerManager on HMaster finds there must be something wrong with this RegionServer

How does HMaster detect the death of RegionServer?

RegionServer Stops after Full GC

Thu, 05 Jul 2018 16:31:24 +0800

One of the most devastating and unpredictable latency intruders is the Java Virtual Machine’s “stop the world” pauses for garbage collection (memory clean-up). This post troubleshoots an unexpected shutdown of RegionServer fundamentally caused by Full GC and makes the whole process clear.

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.

IndexOutput: Lucene Index Output

Mon, 09 Apr 2018 11:25:40 +0800

Immediately following Indexwriter: Lucene Index Creation and Maintenance, IndexOutput, a random-access output stream. is used for all Lucene index output operations.

IndexWriter: Lucene Index Creation and Maintenance

Tue, 03 Apr 2018 14:37:02 +0800

An IndexWriter creates and maintains an index. It’s the basic Class defined in Lucene Core.

A Troubleshooting for Threads Explosion in HBase Client

Fri, 09 Mar 2018 18:27:56 +0800

An issue, excessive threads of HBase client, annoyed me for a quite while. It reminds me to penetrate into uses of Executorservice in HBase client. That’s the origin of this blog.

Consistency Models and Protocols in Distributed System

Fri, 09 Feb 2018 17:03:05 +0800

Data replication is a vital feature in distributed system, but brings in an inevitable price to be paid: consistency maintenance. The consistency model specifies a contract between programmer and system, wherein the system guarantees that if the programmer follows the rules, memory will be consistent and the results of reading, writing, or updating memory will be predictable.

In Chinese, “consistency” often mixes up with “consensus” because of their similar translations. The consensus problem requires agreement among a number of processes for a single data value. Some of the processes may fail or be unreliable in other ways, so consensus protocols must be fault tolerant or resilient.

This post focus on consistency only, enumerating various common types of consistency models and illuminating some consistency protocols.

HBase Batch Puts with BufferedMutator

Mon, 15 Jan 2018 16:56:23 +0800

BufferedMutator is meant for batched, potentially asynchronous puts into a single table. This class relies heavily on AsyncProcess, which I has explained here. Then, we can focus on what BufferedMutator does in this post.

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.

HBase Batch Puts without BufferedMutator

Tue, 09 Jan 2018 11:33:34 +0800

For batch puts, it’s better if you construct a list of puts and then call HTable.put(final List<Put> puts), because it uses a single RPC call to commit the batch, but depending on the size of the list write buffer may flush it all or not.

In this post, BufferedMutator is excluded. It will be discussed in the near future.

2017 in Review and Look Ahead

Wed, 03 Jan 2018 18:43:27 +0800

After reading many blogs about retrospect of 2017, I realized that I should to do it too. it looks necessary and helpful.

Multiversion Concurrency Control in HBase

Wed, 27 Dec 2017 16:19:17 +0800

Multiversion Concurrency Control (MVCC for short) manages the read/write consistency, providing an interface for readers to determine what entries to ignore, and a mechanism for writers to obtain new write numbers, then “commit” the new writes for readers to read (thus forming atomic transactions).

A Lifecycle of HBase's Put: Server-side

Tue, 05 Dec 2017 15:14:28 +0800

Following the preceding A Lifecycle of HBase’s Put: Client-side, this post will figure out how a Put request does its mutation on HRegionServer. The whole process involves WAL, MemStore, and Coprocessor etc. After reading this post, hope you make their roles clear.

A Lifecycle of HBase's Put: Client-side

Fri, 24 Nov 2017 11:38:14 +0800

Put is used to perform insert or update a single row of HBase table. It’s essential to understand its lifecycle, which can be broke into two pieces,

Client-side, How the put request is built up and sent to the right RegionServer.
Server-side, How the RegionServer handle the Put request and update one row.

In view of the limitation of one single post, the client-side is discussed only.

HBase Code Analysis: MemStore

Thu, 23 Nov 2017 11:39:43 +0800

The MemStore holds in-memory modifications to the Store. This post deeps into the source code for sake of understanding what it really do underneath.

HBase Storage Internals

Thu, 16 Nov 2017 11:34:49 +0800

Overview

An HBase Table consists of multiple rows.
Table will be split into Regions based on rows’ lexicographical order.
A Store corresponds to a column family for a table for a given region.
A Store hosts a MemStore and 0 or more StoreFiles (HFiles).
The MemStore holds in-memory modifications to the Store.
StoreFiles are composed of Blocks.

Variable Scope Rules in Python

Sun, 29 Oct 2017 15:44:51 +0800

What’s the output of the following code:

ans = []
def bt():
    for i in range(3):
        ans += [i]

bt()
print(ans)

Fixing Elasticsearch with Red Status

Tue, 10 Oct 2017 10:05:01 +0800

Elasticsearch’s red status means at least one primary shard (and all of its replicas) is missing. This reminds you of missing data: searches will return partial results, and indexing into that shard will return an exception.

Understanding Python Decorator

Wed, 20 Sep 2017 19:36:07 +0800

A Python decorator, similar with Decorator Pattern, is a specific change to the Python syntax that allows us to more conveniently alter functions and methods. In this post, I will try my best to deep into this advanced feature in Python.

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.

*args and **kwargs Usage in Python

Fri, 08 Sep 2017 16:46:50 +0800

The *args and **kwargs is a common idiom to allow arbitrary number of arguments to functions as described in the section more on defining functions in the Python documentation.

How Does Client Find the Region

Fri, 08 Sep 2017 11:04:57 +0800

client-related source code is located in the module hbase-client.

Directory in Lucene

Tue, 05 Sep 2017 16:26:31 +0800

Directory represents the storage location of the indexes and generally it is a list of files. These files are called index files. Index files are normally created once and then used for read operation or can be deleted.

When finally Really Executes

Mon, 04 Sep 2017 16:22:03 +0800

Epitome:

return doesn’t really return, it pushes value to stack, then jumps to finally, which was set up by SETUP_FINALLY before.
after executing finally, END_FINALLY returns.

Exit Options in Python

Fri, 01 Sep 2017 16:47:37 +0800

First candidate is os._exit, which exits without calling cleanup handlers, flushing stdio buffers, etc. (and which should normally only be used in the child process after a fork()).

Second, sys.exit is intended for use in programs. According to official document:

This is implemented by raising the SystemExit exception, so cleanup actions specified by finally clauses of try statements are honored, and it is possible to intercept the exit attempt at an outer level. Since exit() ultimately “only” raises an exception, it will only exit the process when called from the main thread, and the exception is not intercepted.

The Difference between range and xrange

Fri, 01 Sep 2017 16:22:27 +0800

Short answer:

range creates a list, so if you do range(1, 10000000) it creates a list in memory with 9999999 elements. This will become an expensive operation on very large ranges.
xrange is a sequence object that evaluates lazily(it will only compute the next value when needed).

A Dive into slots

Thu, 31 Aug 2017 14:25:37 +0800

__slots__ tells the interpreter not to use a dict, and only allocate space for a fixed set of attributes.

How to Read English Books

Thu, 10 Aug 2017 18:04:07 +0800

For the sake of learning English, I try to read the original version of The Power of Now and Hackers and Painters. To be honest, it’s very difficult, two many unacquainted words and phrases. Even only one in a sentence would affect my understanding.

Therefore, I stopped my reading and searched on the Internet for better approach to do this. After a long surfing, Here is the tips that I summarized.

Document in Lucene

Mon, 07 Aug 2017 18:52:01 +0800

In Lucene, a Document is the unit of search and index.

An index consists of a sequence of documents.
A document contains of one or more Fields.
A field is a named sequence of terms.
A term is a string.

In order to index data with Lucene, you must convert it to a stream of plain-text tokens firstly. Based on the stream, the document containing fields will be created. After that, you can call addDocument method in IndexWriter class to transmit it to index. During this procedure, analyzer may be used to make the data more suitable for indexing.

Guice Usage in Elasticsearch

Fri, 04 Aug 2017 15:58:27 +0800

The motivation of using Guice lists here: Motivation.

To create bindings, extend AbstractModule and override its configure method. In the method body, call bind() to specify each binding. These methods are type checked so the compiler can report errors if you use the wrong types. Once you’ve created your modules, pass them as arguments to Guice.createInjector() to build an injector.

Elasticsearch has a ModulesBuilder which is responsible for assembling modules.

public class ModulesBuilder implements Iterable<Module> {

    // container for all Module
    private final List<Module> modules = new ArrayList<>();

    // add new Modules into container
    public ModulesBuilder add(Module... newModules) {
        Collections.addAll(modules, newModules);
        return this;
    }

    @Override
    public Iterator<Module> iterator() {
        return modules.iterator();
    }

    public Injector createInjector() {
        Injector injector = Guice.createInjector(modules);
        ((InjectorImpl) injector).clearCache();
        // in ES, we always create all instances as if they are eager singletons
        // this allows for considerable memory savings (no need to store construction info) as well as cycles
        ((InjectorImpl) injector).readOnlyAllSingletons();
        return injector;
    }
}

A Node represents a node within a cluster. Node is made up of many Modules with the help of ModulesBuilder. Here is the short version of Node class.

Pip Install ipython Exception on EI Capitan

Thu, 03 Aug 2017 15:23:36 +0800

For those impatient: OS X EI Capitan shipped a security feature named System Integrity Protection, which would be a hinder for pip. Try to install IPython in user mode: pip install ipython --user.

A Mind Map for HBase

Sat, 01 Jul 2017 15:17:33 +0800

This map records my learning path to HBase. Every time I know something new about HBase, I will append it to this map.

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.

Redis Mind Map

Sun, 06 Nov 2016 21:20:07 +0800

This post includes a few mind maps for Redis ranging from quick start to implementation.

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.