diff --git a/src/net/tcp/listener.rs b/src/net/tcp/listener.rs
index a9f4d52b..69340db4 100644
--- a/src/net/tcp/listener.rs
+++ b/src/net/tcp/listener.rs
@@ -252,6 +252,16 @@ impl From<std::net::TcpListener> for TcpListener {
     }
 }
 
+impl std::convert::TryFrom<TcpListener> for std::net::TcpListener {
+    type Error = io::Error;
+    /// Converts a `TcpListener` into its synchronous equivalent.
+    fn try_from(listener: TcpListener) -> io::Result<std::net::TcpListener> {
+        let inner = listener.watcher.into_inner()?;
+        inner.set_nonblocking(false)?;
+        Ok(inner)
+    }
+}
+
 cfg_unix! {
     use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
 
diff --git a/src/net/tcp/stream.rs b/src/net/tcp/stream.rs
index c2a6277b..f30e4714 100644
--- a/src/net/tcp/stream.rs
+++ b/src/net/tcp/stream.rs
@@ -378,6 +378,21 @@ impl From<std::net::TcpStream> for TcpStream {
     }
 }
 
+impl std::convert::TryFrom<TcpStream> for std::net::TcpStream {
+    type Error = io::Error;
+    /// Converts a `TcpStream` into its synchronous equivalent.
+    fn try_from(stream: TcpStream) -> io::Result<std::net::TcpStream> {
+        let inner = Arc::try_unwrap(stream.watcher)
+            .map_err(|_| io::Error::new(
+                io::ErrorKind::Other,
+                "Cannot convert TcpStream to synchronous: multiple references",
+            ))?
+            .into_inner()?;
+        inner.set_nonblocking(false)?;
+        Ok(inner)
+    }
+}
+
 cfg_unix! {
     use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
 
diff --git a/src/net/udp/mod.rs b/src/net/udp/mod.rs
index 377e300f..e216af43 100644
--- a/src/net/udp/mod.rs
+++ b/src/net/udp/mod.rs
@@ -532,6 +532,16 @@ impl From<std::net::UdpSocket> for UdpSocket {
     }
 }
 
+impl std::convert::TryFrom<UdpSocket> for std::net::UdpSocket {
+    type Error = io::Error;
+    /// Converts a `UdpSocket` into its synchronous equivalent.
+    fn try_from(listener: UdpSocket) -> io::Result<std::net::UdpSocket> {
+        let inner = listener.watcher.into_inner()?;
+        inner.set_nonblocking(false)?;
+        Ok(inner)
+    }
+}
+
 cfg_unix! {
     use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
 
diff --git a/src/os/unix/net/datagram.rs b/src/os/unix/net/datagram.rs
index 99a9e8d2..7b0fc32e 100644
--- a/src/os/unix/net/datagram.rs
+++ b/src/os/unix/net/datagram.rs
@@ -311,6 +311,16 @@ impl From<StdUnixDatagram> for UnixDatagram {
     }
 }
 
+impl std::convert::TryFrom<UnixDatagram> for StdUnixDatagram {
+    type Error = io::Error;
+    /// Converts a `UnixDatagram` into its synchronous equivalent.
+    fn try_from(listener: UnixDatagram) -> io::Result<StdUnixDatagram> {
+        let inner = listener.watcher.into_inner()?;
+        inner.set_nonblocking(false)?;
+        Ok(inner)
+    }
+}
+
 impl AsRawFd for UnixDatagram {
     fn as_raw_fd(&self) -> RawFd {
         self.watcher.as_raw_fd()
diff --git a/src/os/unix/net/listener.rs b/src/os/unix/net/listener.rs
index e86502b5..1f983656 100644
--- a/src/os/unix/net/listener.rs
+++ b/src/os/unix/net/listener.rs
@@ -205,6 +205,16 @@ impl From<StdUnixListener> for UnixListener {
     }
 }
 
+impl std::convert::TryFrom<UnixListener> for StdUnixListener {
+    type Error = io::Error;
+    /// Converts a `UnixListener` into its synchronous equivalent.
+    fn try_from(listener: UnixListener) -> io::Result<StdUnixListener> {
+        let inner = listener.watcher.into_inner()?;
+        inner.set_nonblocking(false)?;
+        Ok(inner)
+    }
+}
+
 impl AsRawFd for UnixListener {
     fn as_raw_fd(&self) -> RawFd {
         self.watcher.as_raw_fd()
diff --git a/src/os/unix/net/stream.rs b/src/os/unix/net/stream.rs
index 9e8dbe74..8674e7c3 100644
--- a/src/os/unix/net/stream.rs
+++ b/src/os/unix/net/stream.rs
@@ -231,6 +231,21 @@ impl From<StdUnixStream> for UnixStream {
     }
 }
 
+impl std::convert::TryFrom<UnixStream> for StdUnixStream {
+    type Error = io::Error;
+    /// Converts a `UnixStream` into its synchronous equivalent.
+    fn try_from(stream: UnixStream) -> io::Result<StdUnixStream> {
+        let inner = Arc::try_unwrap(stream.watcher)
+            .map_err(|_| io::Error::new(
+                io::ErrorKind::Other,
+                "Cannot convert UnixStream to synchronous: multiple references",
+            ))?
+            .into_inner()?;
+        inner.set_nonblocking(false)?;
+        Ok(inner)
+    }
+}
+
 impl AsRawFd for UnixStream {
     fn as_raw_fd(&self) -> RawFd {
         self.watcher.as_raw_fd()