How to Optimize Client‑Side DNS Caching Across C/C++, Java, Go, and Python

Background

Using caching is a fundamental principle for performance optimization in computing; a proper data‑caching mechanism can shorten data retrieval paths, reduce remote request frequency, and lower network bandwidth costs. Caches appear in CPU hierarchies, browsers, CDNs, and cloud storage gateways, relieving pressure on DNS services and enabling high‑throughput network infrastructure.

Terminology

Client

Any entity that initiates network requests, such as servers, PCs, mobile devices, operating systems, command‑line tools, scripts, services, or user applications.

DNS

Domain Name System, a database‑like service that maps human‑readable domain names to IP addresses, allowing clients to locate servers without memorizing numeric addresses.

LDNS

Local DNS server; in public networks it is assigned by the ISP, while in private networks it is managed by the IT department. Configuration is typically found in /etc/resolv.conf and can be edited manually, though changes in internal networks should be coordinated with IT.

hosts

The static /etc/hosts file provides local domain‑to‑IP mappings that are consulted before DNS queries; it is often used to bypass DNS for specific hosts.

TTL

Time‑To‑Live defines how long cached data remains valid. For client‑side DNS records a TTL of 60 seconds is recommended, with longer values acceptable for low‑sensitivity services.

DNS Optimization Recommendations

1. Language‑Specific DNS Cache Support

C/C++

The glibc getaddrinfo function is thread‑safe and supports DNS caching via nscd. Example prototype:

int getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res);

Strace shows the lookup sequence: connect to nscd socket, read /etc/hosts, then query DNS servers from /etc/resolv.conf. The /etc/nsswitch.conf file controls the order of hosts and DNS lookups.

libcurl

libcurl also relies on getaddrinfo and thus benefits from nscd caching.

Java

Both HttpURLConnection and Apache httpcomponents‑client support DNS caching. The JVM maintains a simple DNS cache (default 30 seconds) configurable via networkaddress.cache.ttl. Java also uses nscd when available.

# Default cache TTL in jre/lib/security/java.security
networkaddress.cache.ttl=10

Go

The standard net/http library does not use OS DNS caching or nscd. Third‑party libraries such as fasthttp provide DNS caching with configurable duration.

type TCPDialer struct {
    Resolver          Resolver
    DNSCacheDuration time.Duration
    // ...
}

Example usage of fasthttp with a one‑hour DNS cache:

client := &fasthttp.Client{
    Dial: (&fasthttp.TCPDialer{DNSCacheDuration: time.Hour}).Dial,
}

Python

Libraries requests, httplib2, and urllib2 all rely on the underlying OS resolver and therefore benefit from nscd caching.

import requests
for i in range(5):
    r = requests.get('http://example.my.com/', headers={'Connection':'close'})
    print(r.text)

2. DNS Cache Services for Unix‑like Systems

nscd

Install via package manager (e.g., yum install nscd). Restart with service nscd restart or clear hosts cache with nscd -i hosts.

dnsmasq

A lightweight alternative; install with yum install dnsmasq. Basic configuration example:

listen-address=127.0.0.1
port=53
resolv-file=/etc/dnsmasq.d/resolv.conf
cache-size=150
no-negcache
log-queries=extra
log-facility=/var/log/dnsmasq.log

Reload configuration with kill -s HUP $(pidof dnsmasq).

3. Additional Recommendations

Enable HTTP keep‑alive to reuse TCP connections and reduce repeated DNS lookups. For internal services that do not use IPv6, consider disabling AAAA queries to avoid unnecessary traffic. Ensure client implementations strictly validate domain names to prevent excessive NXDOMAIN requests.

Overall, C/C++, Java, and Python can leverage OS‑level DNS caching, while Go requires explicit library support. Combining keep‑alive with nscd or dnsmasq caching yields the most efficient client‑side DNS resolution.