基于DNS的数据库切换·事故

➜  ~ dig @198.41.0.4 www.ffutop.com

; <<>> DiG 9.10.6 <<>> @198.41.0.4 www.ffutop.com
; (1 server found)

;; QUESTION SECTION:
;www.ffutop.com.			IN	A

;; AUTHORITY SECTION:
com.			172800	IN	NS	a.gtld-servers.net.
# ... some records omitted ...
com.			172800	IN	NS	m.gtld-servers.net.

;; ADDITIONAL SECTION:
a.gtld-servers.net.	172800	IN	A	192.5.6.30
# ... some records omitted ...
m.gtld-servers.net.	172800	IN	A	192.55.83.30

;; Query time: 220 msec
;; SERVER: 198.41.0.4#53(198.41.0.4)
;; WHEN: Thu Feb 27 18:04:28 CST 2020
;; MSG SIZE  rcvd: 839

/** Source File: java.net.InetAddress */
private static InetAddress[] getAllByName0(String host, InetAddress reqAddr, boolean check, boolean useCache)
        throws UnknownHostException  {
    // 从缓存中主动移除过期的记录 （如果这条记录的缓存时间预期会超时的话）
    long now = System.nanoTime();
    for (CachedAddresses caddrs : expirySet) {
        if ((caddrs.expiryTime - now) < 0L) {
            if (expirySet.remove(caddrs)) {
                cache.remove(caddrs.host, caddrs);
            }
        } else {
            break;
        }
    }

    // look-up or remove from cache
    Addresses addrs;
    if (useCache) {
        // 尝试在缓存中获取
        addrs = cache.get(host);
    } else {
        // 如果 useCache = false，主动清理掉相关的缓存
        addrs = cache.remove(host);
        if (addrs != null) {
            if (addrs instanceof CachedAddresses) {
                expirySet.remove(addrs);
            }
            addrs = null;
        }
    }

    if (addrs == null) {
        // create a NameServiceAddresses instance which will look up
        // the name service and install it within cache...
        Addresses oldAddrs = cache.putIfAbsent(
            host,
            addrs = new NameServiceAddresses(host, reqAddr)
        );
        if (oldAddrs != null) { // lost putIfAbsent race
            addrs = oldAddrs;
        }
    }

    // ask Addresses to get an array of InetAddress(es) and clone it
    return addrs.get().clone();
}

/** Source File: java.net.InetAddress */
public InetAddress[] get() throws UnknownHostException {
    Addresses addresses;
    // only one thread is doing lookup to name service
    // for particular host at any time.
    synchronized (this) {
        // re-check that we are still us + re-install us if slot empty
        addresses = cache.putIfAbsent(host, this);
        if (addresses == null) {
            // this can happen when we were replaced by CachedAddresses in
            // some other thread, then CachedAddresses expired and were
            // removed from cache while we were waiting for lock...
            addresses = this;
        }
        // still us ?
        if (addresses == this) {
            // lookup name services
            InetAddress[] inetAddresses;
            UnknownHostException ex;
            int cachePolicy;
            try {
                inetAddresses = getAddressesFromNameService(host, reqAddr);
                ex = null;
                cachePolicy = InetAddressCachePolicy.get();
            } catch (UnknownHostException uhe) {
                inetAddresses = null;
                ex = uhe;
                cachePolicy = InetAddressCachePolicy.getNegative();
            }
            // remove or replace us with cached addresses according to cachePolicy
            if (cachePolicy == InetAddressCachePolicy.NEVER) {
                cache.remove(host, this);
            } else {
                CachedAddresses cachedAddresses = new CachedAddresses(
                    host,
                    inetAddresses,
                    cachePolicy == InetAddressCachePolicy.FOREVER
                    ? 0L
                    // cachePolicy is in [s] - we need [ns]
                    : System.nanoTime() + 1000_000_000L * cachePolicy
                );
                if (cache.replace(host, this, cachedAddresses) &&
                    cachePolicy != 
                    .FOREVER) {
                    // schedule expiry
                    expirySet.add(cachedAddresses);
                }
            }
            if (inetAddresses == null) {
                throw ex == null ? new UnknownHostException(host) : ex;
            }
            return inetAddresses;
        }
        // else addresses != this
    }
    // delegate to different addresses when we are already replaced
    // but outside of synchronized block to avoid any chance of dead-locking
    return addresses.get();
}