diff --git a/doc/api/dns.md b/doc/api/dns.md
index d0d3071cc8d203..5be30f22284b9c 100644
--- a/doc/api/dns.md
+++ b/doc/api/dns.md
@@ -54,6 +54,55 @@ dns.resolve4('archive.org', (err, addresses) => {
 There are subtle consequences in choosing one over the other, please consult
 the [Implementation considerations section][] for more information.
 
+## Class dns.Resolver
+<!-- YAML
+added: REPLACEME
+-->
+
+An independent resolver for DNS requests.
+
+Note that creating a new resolver uses the default server settings. Setting
+the servers used for a resolver using
+[`resolver.setServers()`][`dns.setServers()`] does not affect
+other resolver:
+
+```js
+const { Resolver } = require('dns');
+const resolver = new Resolver();
+resolver.setServers(['4.4.4.4']);
+
+// This request will use the server at 4.4.4.4, independent of global settings.
+resolver.resolve4('example.org', (err, addresses) => {
+  // ...
+});
+```
+
+The following methods from the `dns` module are available:
+
+* [`resolver.getServers()`][`dns.getServers()`]
+* [`resolver.setServers()`][`dns.setServers()`]
+* [`resolver.resolve()`][`dns.resolve()`]
+* [`resolver.resolve4()`][`dns.resolve4()`]
+* [`resolver.resolve6()`][`dns.resolve6()`]
+* [`resolver.resolveAny()`][`dns.resolveAny()`]
+* [`resolver.resolveCname()`][`dns.resolveCname()`]
+* [`resolver.resolveMx()`][`dns.resolveMx()`]
+* [`resolver.resolveNaptr()`][`dns.resolveNaptr()`]
+* [`resolver.resolveNs()`][`dns.resolveNs()`]
+* [`resolver.resolvePtr()`][`dns.resolvePtr()`]
+* [`resolver.resolveSoa()`][`dns.resolveSoa()`]
+* [`resolver.resolveSrv()`][`dns.resolveSrv()`]
+* [`resolver.resolveTxt()`][`dns.resolveTxt()`]
+* [`resolver.reverse()`][`dns.reverse()`]
+
+### resolver.cancel()
+<!-- YAML
+added: REPLACEME
+-->
+
+Cancel all outstanding DNS queries made by this resolver. The corresponding
+callbacks will be called with an error with code `ECANCELLED`.
+
 ## dns.getServers()
 <!-- YAML
 added: v0.11.3
@@ -590,6 +639,7 @@ uses. For instance, _they do not use the configuration from `/etc/hosts`_.
 
 [`Error`]: errors.html#errors_class_error
 [`dns.lookup()`]: #dns_dns_lookup_hostname_options_callback
+[`dns.resolve()`]: #dns_dns_resolve_hostname_rrtype_callback
 [`dns.resolve4()`]: #dns_dns_resolve4_hostname_options_callback
 [`dns.resolve6()`]: #dns_dns_resolve6_hostname_options_callback
 [`dns.resolveCname()`]: #dns_dns_resolvecname_hostname_callback
@@ -601,6 +651,9 @@ uses. For instance, _they do not use the configuration from `/etc/hosts`_.
 [`dns.resolveSrv()`]: #dns_dns_resolvesrv_hostname_callback
 [`dns.resolveTxt()`]: #dns_dns_resolvetxt_hostname_callback
 [`dns.resolveAny()`]: #dns_dns_resolveany_hostname_callback
+[`dns.getServers()`]: #dns_dns_getservers
+[`dns.setServers()`]: #dns_dns_setservers_servers
+[`dns.reverse()`]: #dns_dns_reverse_ip_callback
 [DNS error codes]: #dns_error_codes
 [Implementation considerations section]: #dns_implementation_considerations
 [supported `getaddrinfo` flags]: #dns_supported_getaddrinfo_flags
diff --git a/lib/dns.js b/lib/dns.js
index 4e39cfe49e18c2..036197c28dbff5 100644
--- a/lib/dns.js
+++ b/lib/dns.js
@@ -29,11 +29,14 @@ const internalNet = require('internal/net');
 const { customPromisifyArgs } = require('internal/util');
 const errors = require('internal/errors');
 
-const GetAddrInfoReqWrap = cares.GetAddrInfoReqWrap;
-const GetNameInfoReqWrap = cares.GetNameInfoReqWrap;
-const QueryReqWrap = cares.QueryReqWrap;
+const {
+  GetAddrInfoReqWrap,
+  GetNameInfoReqWrap,
+  QueryReqWrap,
+  ChannelWrap,
+  isIP
+} = cares;
 
-const isIP = cares.isIP;
 const isLegalPort = internalNet.isLegalPort;
 
 
@@ -239,11 +242,19 @@ function onresolve(err, result, ttls) {
     this.callback(null, result);
 }
 
+// Resolver instances correspond 1:1 to c-ares channels.
+class Resolver {
+  constructor() {
+    this._handle = new ChannelWrap();
+  }
 
-function resolver(bindingName) {
-  var binding = cares[bindingName];
+  cancel() {
+    this._handle.cancel();
+  }
+}
 
-  return function query(name, /* options, */ callback) {
+function resolver(bindingName) {
+  function query(name, /* options, */ callback) {
     var options;
     if (arguments.length > 2) {
       options = callback;
@@ -263,26 +274,29 @@ function resolver(bindingName) {
     req.hostname = name;
     req.oncomplete = onresolve;
     req.ttl = !!(options && options.ttl);
-    var err = binding(req, name);
+    var err = this._handle[bindingName](req, name);
     if (err) throw errnoException(err, bindingName);
     return req;
-  };
+  }
+  Object.defineProperty(query, 'name', { value: bindingName });
+  return query;
 }
 
-
 var resolveMap = Object.create(null);
-resolveMap.ANY = resolver('queryAny');
-resolveMap.A = resolver('queryA');
-resolveMap.AAAA = resolver('queryAaaa');
-resolveMap.CNAME = resolver('queryCname');
-resolveMap.MX = resolver('queryMx');
-resolveMap.NS = resolver('queryNs');
-resolveMap.TXT = resolver('queryTxt');
-resolveMap.SRV = resolver('querySrv');
-resolveMap.PTR = resolver('queryPtr');
-resolveMap.NAPTR = resolver('queryNaptr');
-resolveMap.SOA = resolver('querySoa');
-
+Resolver.prototype.resolveAny = resolveMap.ANY = resolver('queryAny');
+Resolver.prototype.resolve4 = resolveMap.A = resolver('queryA');
+Resolver.prototype.resolve6 = resolveMap.AAAA = resolver('queryAaaa');
+Resolver.prototype.resolveCname = resolveMap.CNAME = resolver('queryCname');
+Resolver.prototype.resolveMx = resolveMap.MX = resolver('queryMx');
+Resolver.prototype.resolveNs = resolveMap.NS = resolver('queryNs');
+Resolver.prototype.resolveTxt = resolveMap.TXT = resolver('queryTxt');
+Resolver.prototype.resolveSrv = resolveMap.SRV = resolver('querySrv');
+Resolver.prototype.resolvePtr = resolveMap.PTR = resolver('queryPtr');
+Resolver.prototype.resolveNaptr = resolveMap.NAPTR = resolver('queryNaptr');
+Resolver.prototype.resolveSoa = resolveMap.SOA = resolver('querySoa');
+Resolver.prototype.reverse = resolver('getHostByAddr');
+
+Resolver.prototype.resolve = resolve;
 
 function resolve(hostname, rrtype, callback) {
   var resolver;
@@ -297,15 +311,16 @@ function resolve(hostname, rrtype, callback) {
   }
 
   if (typeof resolver === 'function') {
-    return resolver(hostname, callback);
+    return resolver.call(this, hostname, callback);
   } else {
     throw new errors.TypeError('ERR_INVALID_OPT_VALUE', 'rrtype', rrtype);
   }
 }
 
 
+Resolver.prototype.getServers = getServers;
 function getServers() {
-  const ret = cares.getServers();
+  const ret = this._handle.getServers();
   return ret.map((val) => {
     if (!val[1] || val[1] === IANA_DNS_PORT) return val[0];
 
@@ -315,10 +330,11 @@ function getServers() {
 }
 
 
+Resolver.prototype.setServers = setServers;
 function setServers(servers) {
   // cache the original servers because in the event of an error setting the
   // servers cares won't have any servers available for resolution
-  const orig = cares.getServers();
+  const orig = this._handle.getServers();
   const newSet = [];
   const IPv6RE = /\[(.*)\]/;
   const addrSplitRE = /(^.+?)(?::(\d+))?$/;
@@ -350,35 +366,39 @@ function setServers(servers) {
     throw new errors.Error('ERR_INVALID_IP_ADDRESS', serv);
   });
 
-  const errorNumber = cares.setServers(newSet);
+  const errorNumber = this._handle.setServers(newSet);
 
   if (errorNumber !== 0) {
     // reset the servers to the old servers, because ares probably unset them
-    cares.setServers(orig.join(','));
+    this._handle.setServers(orig.join(','));
 
     var err = cares.strerror(errorNumber);
     throw new errors.Error('ERR_DNS_SET_SERVERS_FAILED', err, servers);
   }
 }
 
+const defaultResolver = new Resolver();
+
 module.exports = {
   lookup,
   lookupService,
-  getServers,
-  setServers,
-  resolve,
-  resolveAny: resolveMap.ANY,
-  resolve4: resolveMap.A,
-  resolve6: resolveMap.AAAA,
-  resolveCname: resolveMap.CNAME,
-  resolveMx: resolveMap.MX,
-  resolveNs: resolveMap.NS,
-  resolveTxt: resolveMap.TXT,
-  resolveSrv: resolveMap.SRV,
-  resolvePtr: resolveMap.PTR,
-  resolveNaptr: resolveMap.NAPTR,
-  resolveSoa: resolveMap.SOA,
-  reverse: resolver('getHostByAddr'),
+
+  Resolver,
+  getServers: defaultResolver.getServers.bind(defaultResolver),
+  setServers: defaultResolver.setServers.bind(defaultResolver),
+  resolve: defaultResolver.resolve.bind(defaultResolver),
+  resolveAny: defaultResolver.resolveAny.bind(defaultResolver),
+  resolve4: defaultResolver.resolve4.bind(defaultResolver),
+  resolve6: defaultResolver.resolve6.bind(defaultResolver),
+  resolveCname: defaultResolver.resolveCname.bind(defaultResolver),
+  resolveMx: defaultResolver.resolveMx.bind(defaultResolver),
+  resolveNs: defaultResolver.resolveNs.bind(defaultResolver),
+  resolveTxt: defaultResolver.resolveTxt.bind(defaultResolver),
+  resolveSrv: defaultResolver.resolveSrv.bind(defaultResolver),
+  resolvePtr: defaultResolver.resolvePtr.bind(defaultResolver),
+  resolveNaptr: defaultResolver.resolveNaptr.bind(defaultResolver),
+  resolveSoa: defaultResolver.resolveSoa.bind(defaultResolver),
+  reverse: defaultResolver.reverse.bind(defaultResolver),
 
   // uv_getaddrinfo flags
   ADDRCONFIG: cares.AI_ADDRCONFIG,
diff --git a/src/async-wrap.h b/src/async-wrap.h
index fa37ea13a65993..3a6bea276f59fc 100644
--- a/src/async-wrap.h
+++ b/src/async-wrap.h
@@ -35,6 +35,7 @@ namespace node {
 
 #define NODE_ASYNC_NON_CRYPTO_PROVIDER_TYPES(V)                               \
   V(NONE)                                                                     \
+  V(DNSCHANNEL)                                                               \
   V(FSEVENTWRAP)                                                              \
   V(FSREQWRAP)                                                                \
   V(GETADDRINFOREQWRAP)                                                       \
diff --git a/src/cares_wrap.cc b/src/cares_wrap.cc
index 41a5633ee022f1..327d947f3aa1cf 100644
--- a/src/cares_wrap.cc
+++ b/src/cares_wrap.cc
@@ -36,6 +36,7 @@
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
+#include <vector>
 
 #if defined(__ANDROID__) || \
     defined(__MINGW32__) || \
@@ -115,6 +116,72 @@ inline const char* ToErrorCodeString(int status) {
   return "UNKNOWN_ARES_ERROR";
 }
 
+class ChannelWrap;
+
+struct node_ares_task {
+  ChannelWrap* channel;
+  ares_socket_t sock;
+  uv_poll_t poll_watcher;
+  RB_ENTRY(node_ares_task) node;
+};
+
+RB_HEAD(node_ares_task_list, node_ares_task);
+
+class ChannelWrap : public AsyncWrap {
+ public:
+  ChannelWrap(Environment* env, Local<Object> object);
+  ~ChannelWrap();
+
+  static void New(const FunctionCallbackInfo<Value>& args);
+
+  void Setup();
+  void EnsureServers();
+
+  inline uv_timer_t* timer_handle() { return &timer_handle_; }
+  inline ares_channel cares_channel() { return channel_; }
+  inline bool query_last_ok() const { return query_last_ok_; }
+  inline void set_query_last_ok(bool ok) { query_last_ok_ = ok; }
+  inline bool is_servers_default() const { return is_servers_default_; }
+  inline void set_is_servers_default(bool is_default) {
+    is_servers_default_ = is_default;
+  }
+  inline node_ares_task_list* task_list() { return &task_list_; }
+
+  size_t self_size() const override { return sizeof(this); }
+
+  static void AresTimeout(uv_timer_t* handle);
+
+ private:
+  uv_timer_t timer_handle_;
+  ares_channel channel_;
+  bool query_last_ok_;
+  bool is_servers_default_;
+  bool library_inited_;
+  node_ares_task_list task_list_;
+};
+
+ChannelWrap::ChannelWrap(Environment* env,
+                         Local<Object> object)
+  : AsyncWrap(env, object, PROVIDER_DNSCHANNEL),
+    channel_(nullptr),
+    query_last_ok_(true),
+    is_servers_default_(true),
+    library_inited_(false) {
+  RB_INIT(&task_list_);
+
+  MakeWeak<ChannelWrap>(this);
+
+  Setup();
+}
+
+void ChannelWrap::New(const FunctionCallbackInfo<Value>& args) {
+  CHECK(args.IsConstructCall());
+  CHECK_EQ(args.Length(), 0);
+
+  Environment* env = Environment::GetCurrent(args);
+  new ChannelWrap(env, args.This());
+}
+
 class GetAddrInfoReqWrap : public ReqWrap<uv_getaddrinfo_t> {
  public:
   GetAddrInfoReqWrap(Environment* env, Local<Object> req_wrap_obj);
@@ -168,29 +235,29 @@ RB_GENERATE_STATIC(node_ares_task_list, node_ares_task, node, cmp_ares_tasks)
 
 /* This is called once per second by loop->timer. It is used to constantly */
 /* call back into c-ares for possibly processing timeouts. */
-void ares_timeout(uv_timer_t* handle) {
-  Environment* env = Environment::from_cares_timer_handle(handle);
-  CHECK_EQ(false, RB_EMPTY(env->cares_task_list()));
-  ares_process_fd(env->cares_channel(), ARES_SOCKET_BAD, ARES_SOCKET_BAD);
+void ChannelWrap::AresTimeout(uv_timer_t* handle) {
+  ChannelWrap* channel = ContainerOf(&ChannelWrap::timer_handle_, handle);
+  CHECK_EQ(false, RB_EMPTY(channel->task_list()));
+  ares_process_fd(channel->cares_channel(), ARES_SOCKET_BAD, ARES_SOCKET_BAD);
 }
 
 
 void ares_poll_cb(uv_poll_t* watcher, int status, int events) {
   node_ares_task* task = ContainerOf(&node_ares_task::poll_watcher, watcher);
-  Environment* env = task->env;
+  ChannelWrap* channel = task->channel;
 
   /* Reset the idle timer */
-  uv_timer_again(env->cares_timer_handle());
+  uv_timer_again(channel->timer_handle());
 
   if (status < 0) {
     /* An error happened. Just pretend that the socket is both readable and */
     /* writable. */
-    ares_process_fd(env->cares_channel(), task->sock, task->sock);
+    ares_process_fd(channel->cares_channel(), task->sock, task->sock);
     return;
   }
 
   /* Process DNS responses */
-  ares_process_fd(env->cares_channel(),
+  ares_process_fd(channel->cares_channel(),
                   events & UV_READABLE ? task->sock : ARES_SOCKET_BAD,
                   events & UV_WRITABLE ? task->sock : ARES_SOCKET_BAD);
 }
@@ -204,7 +271,7 @@ void ares_poll_close_cb(uv_handle_t* watcher) {
 
 
 /* Allocates and returns a new node_ares_task */
-node_ares_task* ares_task_create(Environment* env, ares_socket_t sock) {
+node_ares_task* ares_task_create(ChannelWrap* channel, ares_socket_t sock) {
   auto task = node::UncheckedMalloc<node_ares_task>(1);
 
   if (task == nullptr) {
@@ -212,10 +279,11 @@ node_ares_task* ares_task_create(Environment* env, ares_socket_t sock) {
     return nullptr;
   }
 
-  task->env = env;
+  task->channel = channel;
   task->sock = sock;
 
-  if (uv_poll_init_socket(env->event_loop(), &task->poll_watcher, sock) < 0) {
+  if (uv_poll_init_socket(channel->env()->event_loop(),
+                          &task->poll_watcher, sock) < 0) {
     /* This should never happen. */
     free(task);
     return nullptr;
@@ -230,25 +298,25 @@ void ares_sockstate_cb(void* data,
                        ares_socket_t sock,
                        int read,
                        int write) {
-  Environment* env = static_cast<Environment*>(data);
+  ChannelWrap* channel = static_cast<ChannelWrap*>(data);
   node_ares_task* task;
 
   node_ares_task lookup_task;
   lookup_task.sock = sock;
-  task = RB_FIND(node_ares_task_list, env->cares_task_list(), &lookup_task);
+  task = RB_FIND(node_ares_task_list, channel->task_list(), &lookup_task);
 
   if (read || write) {
     if (!task) {
       /* New socket */
 
       /* If this is the first socket then start the timer. */
-      uv_timer_t* timer_handle = env->cares_timer_handle();
+      uv_timer_t* timer_handle = channel->timer_handle();
       if (!uv_is_active(reinterpret_cast<uv_handle_t*>(timer_handle))) {
-        CHECK(RB_EMPTY(env->cares_task_list()));
-        uv_timer_start(timer_handle, ares_timeout, 1000, 1000);
+        CHECK(RB_EMPTY(channel->task_list()));
+        uv_timer_start(timer_handle, ChannelWrap::AresTimeout, 1000, 1000);
       }
 
-      task = ares_task_create(env, sock);
+      task = ares_task_create(channel, sock);
       if (task == nullptr) {
         /* This should never happen unless we're out of memory or something */
         /* is seriously wrong. The socket won't be polled, but the query will */
@@ -256,7 +324,7 @@ void ares_sockstate_cb(void* data,
         return;
       }
 
-      RB_INSERT(node_ares_task_list, env->cares_task_list(), task);
+      RB_INSERT(node_ares_task_list, channel->task_list(), task);
     }
 
     /* This should never fail. If it fails anyway, the query will eventually */
@@ -272,12 +340,12 @@ void ares_sockstate_cb(void* data,
     CHECK(task &&
           "When an ares socket is closed we should have a handle for it");
 
-    RB_REMOVE(node_ares_task_list, env->cares_task_list(), task);
+    RB_REMOVE(node_ares_task_list, channel->task_list(), task);
     uv_close(reinterpret_cast<uv_handle_t*>(&task->poll_watcher),
              ares_poll_close_cb);
 
-    if (RB_EMPTY(env->cares_task_list())) {
-      uv_timer_stop(env->cares_timer_handle());
+    if (RB_EMPTY(channel->task_list())) {
+      uv_timer_stop(channel->timer_handle());
     }
   }
 }
@@ -409,22 +477,53 @@ struct CaresAsyncData {
   uv_async_t async_handle;
 };
 
-void SetupCaresChannel(Environment* env) {
+void ChannelWrap::Setup() {
   struct ares_options options;
   memset(&options, 0, sizeof(options));
   options.flags = ARES_FLAG_NOCHECKRESP;
   options.sock_state_cb = ares_sockstate_cb;
-  options.sock_state_cb_data = env;
+  options.sock_state_cb_data = this;
+
+  int r;
+  if (!library_inited_) {
+    r = ares_library_init(ARES_LIB_INIT_ALL);
+    if (r != ARES_SUCCESS)
+      return env()->ThrowError(ToErrorCodeString(r));
+  }
 
   /* We do the call to ares_init_option for caller. */
-  int r = ares_init_options(env->cares_channel_ptr(),
-                            &options,
-                            ARES_OPT_FLAGS | ARES_OPT_SOCK_STATE_CB);
+  r = ares_init_options(&channel_,
+                        &options,
+                        ARES_OPT_FLAGS | ARES_OPT_SOCK_STATE_CB);
 
   if (r != ARES_SUCCESS) {
     ares_library_cleanup();
-    return env->ThrowError(ToErrorCodeString(r));
+    return env()->ThrowError(ToErrorCodeString(r));
   }
+
+  library_inited_ = true;
+
+  /* Initialize the timeout timer. The timer won't be started until the */
+  /* first socket is opened. */
+  uv_timer_init(env()->event_loop(), &timer_handle_);
+  env()->RegisterHandleCleanup(
+      reinterpret_cast<uv_handle_t*>(&timer_handle_),
+      [](Environment* env, uv_handle_t* handle, void* arg) {
+        uv_close(handle, [](uv_handle_t* handle) {
+          ChannelWrap* channel = ContainerOf(
+              &ChannelWrap::timer_handle_,
+              reinterpret_cast<uv_timer_t*>(handle));
+          channel->env()->FinishHandleCleanup(handle);
+        });
+      },
+      nullptr);
+}
+
+
+ChannelWrap::~ChannelWrap() {
+  if (library_inited_)
+    ares_library_cleanup();
+  ares_destroy(channel_);
 }
 
 
@@ -435,22 +534,21 @@ void SetupCaresChannel(Environment* env) {
  * The fallback servers of cares is [ "127.0.0.1" ] with no user additional
  * setting.
  */
-void AresEnsureServers(Environment* env) {
+void ChannelWrap::EnsureServers() {
   /* if last query is OK or servers are set by user self, do not check */
-  if (env->cares_query_last_ok() || !env->cares_is_servers_default()) {
+  if (query_last_ok_ || !is_servers_default_) {
     return;
   }
 
-  ares_channel channel = env->cares_channel();
   ares_addr_port_node* servers = nullptr;
 
-  ares_get_servers_ports(channel, &servers);
+  ares_get_servers_ports(channel_, &servers);
 
   /* if no server or multi-servers, ignore */
   if (servers == nullptr) return;
   if (servers->next != nullptr) {
     ares_free_data(servers);
-    env->set_cares_is_servers_default(false);
+    is_servers_default_ = false;
     return;
   }
 
@@ -460,7 +558,7 @@ void AresEnsureServers(Environment* env) {
       servers[0].tcp_port != 0 ||
       servers[0].udp_port != 0) {
     ares_free_data(servers);
-    env->set_cares_is_servers_default(false);
+    is_servers_default_ = false;
     return;
   }
 
@@ -468,19 +566,29 @@ void AresEnsureServers(Environment* env) {
   servers = nullptr;
 
   /* destroy channel and reset channel */
-  ares_destroy(channel);
+  ares_destroy(channel_);
 
-  SetupCaresChannel(env);
+  Setup();
 }
 
 
 class QueryWrap : public AsyncWrap {
  public:
-  QueryWrap(Environment* env, Local<Object> req_wrap_obj)
-      : AsyncWrap(env, req_wrap_obj, AsyncWrap::PROVIDER_QUERYWRAP) {
-    if (env->in_domain())
-      req_wrap_obj->Set(env->domain_string(), env->domain_array()->Get(0));
+  QueryWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
+      : AsyncWrap(channel->env(), req_wrap_obj, AsyncWrap::PROVIDER_QUERYWRAP),
+        channel_(channel) {
+    if (env()->in_domain()) {
+      req_wrap_obj->Set(env()->domain_string(),
+                        env()->domain_array()->Get(env()->context(), 0)
+                            .ToLocalChecked());
+    }
+
     Wrap(req_wrap_obj, this);
+
+    // Make sure the channel object stays alive during the query lifetime.
+    req_wrap_obj->Set(env()->context(),
+                      env()->channel_string(),
+                      channel->object()).FromJust();
   }
 
   ~QueryWrap() override {
@@ -501,15 +609,12 @@ class QueryWrap : public AsyncWrap {
   }
 
  protected:
-  void* GetQueryArg() {
-    return static_cast<void*>(this);
-  }
-
-  static void AresQuery(Environment* env, const char* name,
-                        int dnsclass, int type, ares_callback callback,
-                        void* arg) {
-    AresEnsureServers(env);
-    ares_query(env->cares_channel(), name, dnsclass, type, callback, arg);
+  void AresQuery(const char* name,
+                 int dnsclass,
+                 int type) {
+    channel_->EnsureServers();
+    ares_query(channel_->cares_channel(), name, dnsclass, type, Callback,
+               static_cast<void*>(this));
   }
 
   static void CaresAsyncClose(uv_handle_t* handle) {
@@ -563,7 +668,7 @@ class QueryWrap : public AsyncWrap {
                               async_handle,
                               CaresAsyncCb));
 
-    wrap->env()->set_cares_query_last_ok(status != ARES_ECONNREFUSED);
+    wrap->channel_->set_query_last_ok(status != ARES_ECONNREFUSED);
     async_handle->data = data;
     uv_async_send(async_handle);
   }
@@ -589,7 +694,7 @@ class QueryWrap : public AsyncWrap {
                               async_handle,
                               CaresAsyncCb));
 
-    wrap->env()->set_cares_query_last_ok(status != ARES_ECONNREFUSED);
+    wrap->channel_->set_query_last_ok(status != ARES_ECONNREFUSED);
     async_handle->data = data;
     uv_async_send(async_handle);
   }
@@ -624,6 +729,8 @@ class QueryWrap : public AsyncWrap {
   virtual void Parse(struct hostent* host) {
     UNREACHABLE();
   }
+
+  ChannelWrap* channel_;
 };
 
 
@@ -1063,17 +1170,12 @@ int ParseSoaReply(Environment* env,
 
 class QueryAnyWrap: public QueryWrap {
  public:
-  QueryAnyWrap(Environment* env, Local<Object> req_wrap_obj)
-    : QueryWrap(env, req_wrap_obj) {
+  QueryAnyWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
+    : QueryWrap(channel, req_wrap_obj) {
   }
 
   int Send(const char* name) override {
-    ares_query(env()->cares_channel(),
-               name,
-               ns_c_in,
-               ns_t_any,
-               Callback,
-               GetQueryArg());
+    AresQuery(name, ns_c_in, ns_t_any);
     return 0;
   }
 
@@ -1235,12 +1337,12 @@ class QueryAnyWrap: public QueryWrap {
 
 class QueryAWrap: public QueryWrap {
  public:
-  QueryAWrap(Environment* env, Local<Object> req_wrap_obj)
-      : QueryWrap(env, req_wrap_obj) {
+  QueryAWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
+      : QueryWrap(channel, req_wrap_obj) {
   }
 
   int Send(const char* name) override {
-    AresQuery(env(), name, ns_c_in, ns_t_a, Callback, GetQueryArg());
+    AresQuery(name, ns_c_in, ns_t_a);
     return 0;
   }
 
@@ -1279,12 +1381,12 @@ class QueryAWrap: public QueryWrap {
 
 class QueryAaaaWrap: public QueryWrap {
  public:
-  QueryAaaaWrap(Environment* env, Local<Object> req_wrap_obj)
-      : QueryWrap(env, req_wrap_obj) {
+  QueryAaaaWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
+      : QueryWrap(channel, req_wrap_obj) {
   }
 
   int Send(const char* name) override {
-    AresQuery(env(),  name, ns_c_in, ns_t_aaaa, Callback, GetQueryArg());
+    AresQuery(name, ns_c_in, ns_t_aaaa);
     return 0;
   }
 
@@ -1323,12 +1425,12 @@ class QueryAaaaWrap: public QueryWrap {
 
 class QueryCnameWrap: public QueryWrap {
  public:
-  QueryCnameWrap(Environment* env, Local<Object> req_wrap_obj)
-      : QueryWrap(env, req_wrap_obj) {
+  QueryCnameWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
+      : QueryWrap(channel, req_wrap_obj) {
   }
 
   int Send(const char* name) override {
-    AresQuery(env(), name, ns_c_in, ns_t_cname, Callback, GetQueryArg());
+    AresQuery(name, ns_c_in, ns_t_cname);
     return 0;
   }
 
@@ -1354,12 +1456,12 @@ class QueryCnameWrap: public QueryWrap {
 
 class QueryMxWrap: public QueryWrap {
  public:
-  QueryMxWrap(Environment* env, Local<Object> req_wrap_obj)
-      : QueryWrap(env, req_wrap_obj) {
+  QueryMxWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
+      : QueryWrap(channel, req_wrap_obj) {
   }
 
   int Send(const char* name) override {
-    AresQuery(env(), name, ns_c_in, ns_t_mx, Callback, GetQueryArg());
+    AresQuery(name, ns_c_in, ns_t_mx);
     return 0;
   }
 
@@ -1385,12 +1487,12 @@ class QueryMxWrap: public QueryWrap {
 
 class QueryNsWrap: public QueryWrap {
  public:
-  QueryNsWrap(Environment* env, Local<Object> req_wrap_obj)
-      : QueryWrap(env, req_wrap_obj) {
+  QueryNsWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
+      : QueryWrap(channel, req_wrap_obj) {
   }
 
   int Send(const char* name) override {
-    AresQuery(env(), name, ns_c_in, ns_t_ns, Callback, GetQueryArg());
+    AresQuery(name, ns_c_in, ns_t_ns);
     return 0;
   }
 
@@ -1416,12 +1518,12 @@ class QueryNsWrap: public QueryWrap {
 
 class QueryTxtWrap: public QueryWrap {
  public:
-  QueryTxtWrap(Environment* env, Local<Object> req_wrap_obj)
-      : QueryWrap(env, req_wrap_obj) {
+  QueryTxtWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
+      : QueryWrap(channel, req_wrap_obj) {
   }
 
   int Send(const char* name) override {
-    AresQuery(env(), name, ns_c_in, ns_t_txt, Callback, GetQueryArg());
+    AresQuery(name, ns_c_in, ns_t_txt);
     return 0;
   }
 
@@ -1446,12 +1548,12 @@ class QueryTxtWrap: public QueryWrap {
 
 class QuerySrvWrap: public QueryWrap {
  public:
-  explicit QuerySrvWrap(Environment* env, Local<Object> req_wrap_obj)
-      : QueryWrap(env, req_wrap_obj) {
+  explicit QuerySrvWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
+      : QueryWrap(channel, req_wrap_obj) {
   }
 
   int Send(const char* name) override {
-    AresQuery(env(), name, ns_c_in, ns_t_srv, Callback, GetQueryArg());
+    AresQuery(name, ns_c_in, ns_t_srv);
     return 0;
   }
 
@@ -1475,12 +1577,12 @@ class QuerySrvWrap: public QueryWrap {
 
 class QueryPtrWrap: public QueryWrap {
  public:
-  explicit QueryPtrWrap(Environment* env, Local<Object> req_wrap_obj)
-      : QueryWrap(env, req_wrap_obj) {
+  explicit QueryPtrWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
+      : QueryWrap(channel, req_wrap_obj) {
   }
 
   int Send(const char* name) override {
-    AresQuery(env(), name, ns_c_in, ns_t_ptr, Callback, GetQueryArg());
+    AresQuery(name, ns_c_in, ns_t_ptr);
     return 0;
   }
 
@@ -1506,12 +1608,12 @@ class QueryPtrWrap: public QueryWrap {
 
 class QueryNaptrWrap: public QueryWrap {
  public:
-  explicit QueryNaptrWrap(Environment* env, Local<Object> req_wrap_obj)
-      : QueryWrap(env, req_wrap_obj) {
+  explicit QueryNaptrWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
+      : QueryWrap(channel, req_wrap_obj) {
   }
 
   int Send(const char* name) override {
-    AresQuery(env(), name, ns_c_in, ns_t_naptr, Callback, GetQueryArg());
+    AresQuery(name, ns_c_in, ns_t_naptr);
     return 0;
   }
 
@@ -1536,12 +1638,12 @@ class QueryNaptrWrap: public QueryWrap {
 
 class QuerySoaWrap: public QueryWrap {
  public:
-  QuerySoaWrap(Environment* env, Local<Object> req_wrap_obj)
-      : QueryWrap(env, req_wrap_obj) {
+  QuerySoaWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
+      : QueryWrap(channel, req_wrap_obj) {
   }
 
   int Send(const char* name) override {
-    AresQuery(env(), name, ns_c_in, ns_t_soa, Callback, GetQueryArg());
+    AresQuery(name, ns_c_in, ns_t_soa);
     return 0;
   }
 
@@ -1597,8 +1699,8 @@ class QuerySoaWrap: public QueryWrap {
 
 class GetHostByAddrWrap: public QueryWrap {
  public:
-  explicit GetHostByAddrWrap(Environment* env, Local<Object> req_wrap_obj)
-      : QueryWrap(env, req_wrap_obj) {
+  explicit GetHostByAddrWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
+      : QueryWrap(channel, req_wrap_obj) {
   }
 
   int Send(const char* name) override {
@@ -1615,12 +1717,12 @@ class GetHostByAddrWrap: public QueryWrap {
       return UV_EINVAL;  // So errnoException() reports a proper error.
     }
 
-    ares_gethostbyaddr(env()->cares_channel(),
+    ares_gethostbyaddr(channel_->cares_channel(),
                        address_buffer,
                        length,
                        family,
                        Callback,
-                       GetQueryArg());
+                       static_cast<void*>(static_cast<QueryWrap*>(this)));
     return 0;
   }
 
@@ -1637,16 +1739,16 @@ class GetHostByAddrWrap: public QueryWrap {
 
 class GetHostByNameWrap: public QueryWrap {
  public:
-  explicit GetHostByNameWrap(Environment* env, Local<Object> req_wrap_obj)
-      : QueryWrap(env, req_wrap_obj) {
+  explicit GetHostByNameWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
+      : QueryWrap(channel, req_wrap_obj) {
   }
 
   int Send(const char* name, int family) override {
-    ares_gethostbyname(env()->cares_channel(),
+    ares_gethostbyname(channel_->cares_channel(),
                        name,
                        family,
                        Callback,
-                       GetQueryArg());
+                       static_cast<void*>(static_cast<QueryWrap*>(this)));
     return 0;
   }
 
@@ -1665,6 +1767,8 @@ class GetHostByNameWrap: public QueryWrap {
 template <class Wrap>
 static void Query(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
+  ChannelWrap* channel;
+  ASSIGN_OR_RETURN_UNWRAP(&channel, args.Holder());
 
   CHECK_EQ(false, args.IsConstructCall());
   CHECK(args[0]->IsObject());
@@ -1672,7 +1776,7 @@ static void Query(const FunctionCallbackInfo<Value>& args) {
 
   Local<Object> req_wrap_obj = args[0].As<Object>();
   Local<String> string = args[1].As<String>();
-  Wrap* wrap = new Wrap(env, req_wrap_obj);
+  Wrap* wrap = new Wrap(channel, req_wrap_obj);
 
   node::Utf8Value name(env->isolate(), string);
   int err = wrap->Send(*name);
@@ -1923,12 +2027,14 @@ void GetNameInfo(const FunctionCallbackInfo<Value>& args) {
 
 void GetServers(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
+  ChannelWrap* channel;
+  ASSIGN_OR_RETURN_UNWRAP(&channel, args.Holder());
 
   Local<Array> server_array = Array::New(env->isolate());
 
   ares_addr_port_node* servers;
 
-  int r = ares_get_servers_ports(env->cares_channel(), &servers);
+  int r = ares_get_servers_ports(channel->cares_channel(), &servers);
   CHECK_EQ(r, ARES_SUCCESS);
 
   ares_addr_port_node* cur = servers;
@@ -1955,6 +2061,8 @@ void GetServers(const FunctionCallbackInfo<Value>& args) {
 
 void SetServers(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
+  ChannelWrap* channel;
+  ASSIGN_OR_RETURN_UNWRAP(&channel, args.Holder());
 
   CHECK(args[0]->IsArray());
 
@@ -1963,11 +2071,11 @@ void SetServers(const FunctionCallbackInfo<Value>& args) {
   uint32_t len = arr->Length();
 
   if (len == 0) {
-    int rv = ares_set_servers(env->cares_channel(), nullptr);
+    int rv = ares_set_servers(channel->cares_channel(), nullptr);
     return args.GetReturnValue().Set(rv);
   }
 
-  ares_addr_port_node* servers = new ares_addr_port_node[len];
+  std::vector<ares_addr_port_node> servers(len);
   ares_addr_port_node* last = nullptr;
 
   int err;
@@ -2013,18 +2121,23 @@ void SetServers(const FunctionCallbackInfo<Value>& args) {
   }
 
   if (err == 0)
-    err = ares_set_servers_ports(env->cares_channel(), &servers[0]);
+    err = ares_set_servers_ports(channel->cares_channel(), &servers[0]);
   else
     err = ARES_EBADSTR;
 
-  delete[] servers;
-
   if (err == ARES_SUCCESS)
-    env->set_cares_is_servers_default(false);
+    channel->set_is_servers_default(false);
 
   args.GetReturnValue().Set(err);
 }
 
+void Cancel(const FunctionCallbackInfo<Value>& args) {
+  ChannelWrap* channel;
+  ASSIGN_OR_RETURN_UNWRAP(&channel, args.Holder());
+
+  ares_cancel(channel->cares_channel());
+}
+
 
 void StrError(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
@@ -2033,52 +2146,11 @@ void StrError(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-void CaresTimerCloseCb(uv_handle_t* handle) {
-  Environment* env = Environment::from_cares_timer_handle(
-      reinterpret_cast<uv_timer_t*>(handle));
-  env->FinishHandleCleanup(handle);
-}
-
-
-void CaresTimerClose(Environment* env,
-                     uv_handle_t* handle,
-                     void* arg) {
-  uv_close(handle, CaresTimerCloseCb);
-}
-
-
 void Initialize(Local<Object> target,
                 Local<Value> unused,
                 Local<Context> context) {
   Environment* env = Environment::GetCurrent(context);
 
-  int r = ares_library_init(ARES_LIB_INIT_ALL);
-  if (r != ARES_SUCCESS)
-    return env->ThrowError(ToErrorCodeString(r));
-
-  SetupCaresChannel(env);
-
-  /* Initialize the timeout timer. The timer won't be started until the */
-  /* first socket is opened. */
-  uv_timer_init(env->event_loop(), env->cares_timer_handle());
-  env->RegisterHandleCleanup(
-      reinterpret_cast<uv_handle_t*>(env->cares_timer_handle()),
-      CaresTimerClose,
-      nullptr);
-
-  env->SetMethod(target, "queryAny", Query<QueryAnyWrap>);
-  env->SetMethod(target, "queryA", Query<QueryAWrap>);
-  env->SetMethod(target, "queryAaaa", Query<QueryAaaaWrap>);
-  env->SetMethod(target, "queryCname", Query<QueryCnameWrap>);
-  env->SetMethod(target, "queryMx", Query<QueryMxWrap>);
-  env->SetMethod(target, "queryNs", Query<QueryNsWrap>);
-  env->SetMethod(target, "queryTxt", Query<QueryTxtWrap>);
-  env->SetMethod(target, "querySrv", Query<QuerySrvWrap>);
-  env->SetMethod(target, "queryPtr", Query<QueryPtrWrap>);
-  env->SetMethod(target, "queryNaptr", Query<QueryNaptrWrap>);
-  env->SetMethod(target, "querySoa", Query<QuerySoaWrap>);
-  env->SetMethod(target, "getHostByAddr", Query<GetHostByAddrWrap>);
-
   env->SetMethod(target, "getaddrinfo", GetAddrInfo);
   env->SetMethod(target, "getnameinfo", GetNameInfo);
   env->SetMethod(target, "isIP", IsIP);
@@ -2086,8 +2158,6 @@ void Initialize(Local<Object> target,
   env->SetMethod(target, "isIPv6", IsIPv6);
 
   env->SetMethod(target, "strerror", StrError);
-  env->SetMethod(target, "getServers", GetServers);
-  env->SetMethod(target, "setServers", SetServers);
 
   target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "AF_INET"),
               Integer::New(env->isolate(), AF_INET));
@@ -2131,6 +2201,33 @@ void Initialize(Local<Object> target,
       FIXED_ONE_BYTE_STRING(env->isolate(), "QueryReqWrap"));
   target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "QueryReqWrap"),
               qrw->GetFunction());
+
+  Local<FunctionTemplate> channel_wrap =
+      env->NewFunctionTemplate(ChannelWrap::New);
+  channel_wrap->InstanceTemplate()->SetInternalFieldCount(1);
+  env->SetProtoMethod(channel_wrap, "getAsyncId", AsyncWrap::GetAsyncId);
+
+  env->SetProtoMethod(channel_wrap, "queryAny", Query<QueryAnyWrap>);
+  env->SetProtoMethod(channel_wrap, "queryA", Query<QueryAWrap>);
+  env->SetProtoMethod(channel_wrap, "queryAaaa", Query<QueryAaaaWrap>);
+  env->SetProtoMethod(channel_wrap, "queryCname", Query<QueryCnameWrap>);
+  env->SetProtoMethod(channel_wrap, "queryMx", Query<QueryMxWrap>);
+  env->SetProtoMethod(channel_wrap, "queryNs", Query<QueryNsWrap>);
+  env->SetProtoMethod(channel_wrap, "queryTxt", Query<QueryTxtWrap>);
+  env->SetProtoMethod(channel_wrap, "querySrv", Query<QuerySrvWrap>);
+  env->SetProtoMethod(channel_wrap, "queryPtr", Query<QueryPtrWrap>);
+  env->SetProtoMethod(channel_wrap, "queryNaptr", Query<QueryNaptrWrap>);
+  env->SetProtoMethod(channel_wrap, "querySoa", Query<QuerySoaWrap>);
+  env->SetProtoMethod(channel_wrap, "getHostByAddr", Query<GetHostByAddrWrap>);
+
+  env->SetProtoMethod(channel_wrap, "getServers", GetServers);
+  env->SetProtoMethod(channel_wrap, "setServers", SetServers);
+  env->SetProtoMethod(channel_wrap, "cancel", Cancel);
+
+  channel_wrap->SetClassName(
+      FIXED_ONE_BYTE_STRING(env->isolate(), "ChannelWrap"));
+  target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "ChannelWrap"),
+              channel_wrap->GetFunction());
 }
 
 }  // anonymous namespace
diff --git a/src/env-inl.h b/src/env-inl.h
index e160fe27d8d5fc..6753979ef57bf5 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -292,8 +292,6 @@ inline Environment::Environment(IsolateData* isolate_data,
       isolate_data_(isolate_data),
       async_hooks_(context->GetIsolate()),
       timer_base_(uv_now(isolate_data->event_loop())),
-      cares_query_last_ok_(true),
-      cares_is_servers_default_(true),
       using_domains_(false),
       printed_error_(false),
       trace_sync_io_(false),
@@ -313,7 +311,6 @@ inline Environment::Environment(IsolateData* isolate_data,
   set_binding_cache_object(v8::Object::New(isolate()));
   set_module_load_list_array(v8::Array::New(isolate()));
 
-  RB_INIT(&cares_task_list_);
   AssignToContext(context);
 
   destroy_ids_list_.reserve(512);
@@ -490,43 +487,6 @@ inline void Environment::set_fs_stats_field_array(double* fields) {
   fs_stats_field_array_ = fields;
 }
 
-inline Environment* Environment::from_cares_timer_handle(uv_timer_t* handle) {
-  return ContainerOf(&Environment::cares_timer_handle_, handle);
-}
-
-inline uv_timer_t* Environment::cares_timer_handle() {
-  return &cares_timer_handle_;
-}
-
-inline ares_channel Environment::cares_channel() {
-  return cares_channel_;
-}
-
-// Only used in the call to ares_init_options().
-inline ares_channel* Environment::cares_channel_ptr() {
-  return &cares_channel_;
-}
-
-inline bool Environment::cares_query_last_ok() {
-  return cares_query_last_ok_;
-}
-
-inline void Environment::set_cares_query_last_ok(bool ok) {
-  cares_query_last_ok_ = ok;
-}
-
-inline bool Environment::cares_is_servers_default() {
-  return cares_is_servers_default_;
-}
-
-inline void Environment::set_cares_is_servers_default(bool is_default) {
-  cares_is_servers_default_ = is_default;
-}
-
-inline node_ares_task_list* Environment::cares_task_list() {
-  return &cares_task_list_;
-}
-
 inline IsolateData* Environment::isolate_data() const {
   return isolate_data_;
 }
diff --git a/src/env.h b/src/env.h
index a0f4c30e8dd4b9..e1375080d17f07 100644
--- a/src/env.h
+++ b/src/env.h
@@ -97,6 +97,7 @@ namespace node {
   V(cached_data_rejected_string, "cachedDataRejected")                        \
   V(callback_string, "callback")                                              \
   V(change_string, "change")                                                  \
+  V(channel_string, "channel")                                                \
   V(oncertcb_string, "oncertcb")                                              \
   V(onclose_string, "_onclose")                                               \
   V(code_string, "code")                                                      \
@@ -298,20 +299,11 @@ namespace node {
 
 class Environment;
 
-struct node_ares_task {
-  Environment* env;
-  ares_socket_t sock;
-  uv_poll_t poll_watcher;
-  RB_ENTRY(node_ares_task) node;
-};
-
 struct node_async_ids {
   double async_id;
   double trigger_id;
 };
 
-RB_HEAD(node_ares_task_list, node_ares_task);
-
 class IsolateData {
  public:
   inline IsolateData(v8::Isolate* isolate, uv_loop_t* event_loop,
@@ -557,15 +549,6 @@ class Environment {
   inline TickInfo* tick_info();
   inline uint64_t timer_base() const;
 
-  static inline Environment* from_cares_timer_handle(uv_timer_t* handle);
-  inline uv_timer_t* cares_timer_handle();
-  inline ares_channel cares_channel();
-  inline ares_channel* cares_channel_ptr();
-  inline bool cares_query_last_ok();
-  inline void set_cares_query_last_ok(bool ok);
-  inline bool cares_is_servers_default();
-  inline void set_cares_is_servers_default(bool is_default);
-  inline node_ares_task_list* cares_task_list();
   inline IsolateData* isolate_data() const;
 
   inline bool using_domains() const;
@@ -685,11 +668,6 @@ class Environment {
   DomainFlag domain_flag_;
   TickInfo tick_info_;
   const uint64_t timer_base_;
-  uv_timer_t cares_timer_handle_;
-  ares_channel cares_channel_;
-  bool cares_query_last_ok_;
-  bool cares_is_servers_default_;
-  node_ares_task_list cares_task_list_;
   bool using_domains_;
   bool printed_error_;
   bool trace_sync_io_;
diff --git a/test/parallel/test-async-wrap-getasyncid.js b/test/parallel/test-async-wrap-getasyncid.js
index a693f94efbb9d1..57d6f86ebe5ca8 100644
--- a/test/parallel/test-async-wrap-getasyncid.js
+++ b/test/parallel/test-async-wrap-getasyncid.js
@@ -51,6 +51,7 @@ function testInitialized(req, ctor_name) {
   testInitialized(dns.lookup('www.google.com', () => {}), 'GetAddrInfoReqWrap');
   testInitialized(dns.lookupService('::1', 22, () => {}), 'GetNameInfoReqWrap');
   testInitialized(dns.resolve6('::1', () => {}), 'QueryReqWrap');
+  testInitialized(new cares.ChannelWrap(), 'ChannelWrap');
 }
 
 
diff --git a/test/parallel/test-dns-channel-cancel.js b/test/parallel/test-dns-channel-cancel.js
new file mode 100644
index 00000000000000..797d61efb40653
--- /dev/null
+++ b/test/parallel/test-dns-channel-cancel.js
@@ -0,0 +1,29 @@
+'use strict';
+const common = require('../common');
+const dnstools = require('../common/dns');
+const { Resolver } = require('dns');
+const assert = require('assert');
+const dgram = require('dgram');
+
+const server = dgram.createSocket('udp4');
+const resolver = new Resolver();
+
+server.bind(0, common.mustCall(() => {
+  resolver.setServers([`127.0.0.1:${server.address().port}`]);
+  resolver.resolve4('example.org', common.mustCall((err, res) => {
+    assert.strictEqual(err.code, 'ECANCELLED');
+    assert.strictEqual(err.errno, 'ECANCELLED');
+    assert.strictEqual(err.syscall, 'queryA');
+    assert.strictEqual(err.hostname, 'example.org');
+    server.close();
+  }));
+}));
+
+server.on('message', common.mustCall((msg, { address, port }) => {
+  const parsed = dnstools.parseDNSPacket(msg);
+  const domain = parsed.questions[0].domain;
+  assert.strictEqual(domain, 'example.org');
+
+  // Do not send a reply.
+  resolver.cancel();
+}));
diff --git a/test/parallel/test-dns-multi-channel.js b/test/parallel/test-dns-multi-channel.js
new file mode 100644
index 00000000000000..63e82c3ed791a4
--- /dev/null
+++ b/test/parallel/test-dns-multi-channel.js
@@ -0,0 +1,53 @@
+'use strict';
+const common = require('../common');
+const dnstools = require('../common/dns');
+const { Resolver } = require('dns');
+const assert = require('assert');
+const dgram = require('dgram');
+
+const servers = [
+  {
+    socket: dgram.createSocket('udp4'),
+    reply: { type: 'A', address: '1.2.3.4', ttl: 123, domain: 'example.org' }
+  },
+  {
+    socket: dgram.createSocket('udp4'),
+    reply: { type: 'A', address: '5.6.7.8', ttl: 123, domain: 'example.org' }
+  }
+];
+
+let waiting = servers.length;
+for (const { socket, reply } of servers) {
+  socket.on('message', common.mustCall((msg, { address, port }) => {
+    const parsed = dnstools.parseDNSPacket(msg);
+    const domain = parsed.questions[0].domain;
+    assert.strictEqual(domain, 'example.org');
+
+    socket.send(dnstools.writeDNSPacket({
+      id: parsed.id,
+      questions: parsed.questions,
+      answers: [reply],
+    }), port, address);
+  }));
+
+  socket.bind(0, common.mustCall(() => {
+    if (0 === --waiting) ready();
+  }));
+}
+
+
+function ready() {
+  const resolvers = servers.map((server) => ({
+    server,
+    resolver: new Resolver()
+  }));
+
+  for (const { server: { socket, reply }, resolver } of resolvers) {
+    resolver.setServers([`127.0.0.1:${socket.address().port}`]);
+    resolver.resolve4('example.org', common.mustCall((err, res) => {
+      assert.ifError(err);
+      assert.deepStrictEqual(res, [reply.address]);
+      socket.close();
+    }));
+  }
+}