diff --git a/Lib/asyncio/locks.py b/Lib/asyncio/locks.py
index f1ce7324785ba98..9c043d7457619e0 100644
--- a/Lib/asyncio/locks.py
+++ b/Lib/asyncio/locks.py
@@ -78,12 +78,14 @@ def __init__(self, *, loop=None):
         self._waiters = None
         self._locked = False
         if loop is None:
-            self._loop = events.get_event_loop()
+            self._loop = events._get_running_loop()
+            if self._loop is None:
+                warnings.warn("The creation of asyncio objects outside of a running "
+                              "event loop is deprecated as of Python 3.9.",
+                              DeprecationWarning, stacklevel=2)
+                self._loop = events.get_event_loop()
         else:
             self._loop = loop
-            warnings.warn("The loop argument is deprecated since Python 3.8, "
-                          "and scheduled for removal in Python 3.10.",
-                          DeprecationWarning, stacklevel=2)
 
     def __repr__(self):
         res = super().__repr__()
@@ -174,12 +176,14 @@ def __init__(self, *, loop=None):
         self._waiters = collections.deque()
         self._value = False
         if loop is None:
-            self._loop = events.get_event_loop()
+            self._loop = events._get_running_loop()
+            if self._loop is None:
+                warnings.warn("The creation of asyncio objects outside a running "
+                              "event loop is deprecated as of Python 3.9.",
+                              DeprecationWarning, stacklevel=2)
+                self._loop = events.get_event_loop()
         else:
             self._loop = loop
-            warnings.warn("The loop argument is deprecated since Python 3.8, "
-                          "and scheduled for removal in Python 3.10.",
-                          DeprecationWarning, stacklevel=2)
 
     def __repr__(self):
         res = super().__repr__()
@@ -241,12 +245,14 @@ class Condition(_ContextManagerMixin):
 
     def __init__(self, lock=None, *, loop=None):
         if loop is None:
-            self._loop = events.get_event_loop()
+            self._loop = events._get_running_loop()
+            if self._loop is None:
+                warnings.warn("The creation of asyncio objects outside a running "
+                              "event loop is deprecated as of Python 3.9.",
+                              DeprecationWarning, stacklevel=2)
+                self._loop = events.get_event_loop()
         else:
             self._loop = loop
-            warnings.warn("The loop argument is deprecated since Python 3.8, "
-                          "and scheduled for removal in Python 3.10.",
-                          DeprecationWarning, stacklevel=2)
 
         if lock is None:
             lock = Lock(loop=loop)
@@ -372,12 +378,14 @@ def __init__(self, value=1, *, loop=None):
         self._value = value
         self._waiters = collections.deque()
         if loop is None:
-            self._loop = events.get_event_loop()
+            self._loop = events._get_running_loop()
+            if self._loop is None:
+                warnings.warn("The creation of asyncio objects outside a running "
+                              "event loop is deprecated as of Python 3.9.",
+                              DeprecationWarning, stacklevel=2)
+                self._loop = events.get_event_loop()
         else:
             self._loop = loop
-            warnings.warn("The loop argument is deprecated since Python 3.8, "
-                          "and scheduled for removal in Python 3.10.",
-                          DeprecationWarning, stacklevel=2)
 
     def __repr__(self):
         res = super().__repr__()
diff --git a/Lib/asyncio/queues.py b/Lib/asyncio/queues.py
index cd3f7c6a5678915..eb8cb51bb49cdb8 100644
--- a/Lib/asyncio/queues.py
+++ b/Lib/asyncio/queues.py
@@ -32,12 +32,15 @@ class Queue:
 
     def __init__(self, maxsize=0, *, loop=None):
         if loop is None:
-            self._loop = events.get_event_loop()
+            self._loop = events._get_running_loop()
+            if self._loop is None:
+                warnings.warn("The creation of asyncio objects outside a running "
+                              "event loop is deprecated as of Python 3.9.",
+                              DeprecationWarning, stacklevel=2)
+                self._loop = events.get_event_loop()
         else:
             self._loop = loop
-            warnings.warn("The loop argument is deprecated since Python 3.8, "
-                          "and scheduled for removal in Python 3.10.",
-                          DeprecationWarning, stacklevel=2)
+
         self._maxsize = maxsize
 
         # Futures.
diff --git a/Lib/test/test_asyncio/test_locks.py b/Lib/test/test_asyncio/test_locks.py
index 8c93fae2b51c6c8..dad6b52919f7aa9 100644
--- a/Lib/test/test_asyncio/test_locks.py
+++ b/Lib/test/test_asyncio/test_locks.py
@@ -28,12 +28,10 @@ def setUp(self):
 
     def test_ctor_loop(self):
         loop = mock.Mock()
-        with self.assertWarns(DeprecationWarning):
-            lock = asyncio.Lock(loop=loop)
+        lock = asyncio.Lock(loop=loop)
         self.assertIs(lock._loop, loop)
 
-        with self.assertWarns(DeprecationWarning):
-            lock = asyncio.Lock(loop=self.loop)
+        lock = asyncio.Lock(loop=self.loop)
         self.assertIs(lock._loop, self.loop)
 
     def test_ctor_noloop(self):
@@ -42,8 +40,7 @@ def test_ctor_noloop(self):
         self.assertIs(lock._loop, self.loop)
 
     def test_repr(self):
-        with self.assertWarns(DeprecationWarning):
-            lock = asyncio.Lock(loop=self.loop)
+        lock = asyncio.Lock(loop=self.loop)
         self.assertTrue(repr(lock).endswith('[unlocked]>'))
         self.assertTrue(RGX_REPR.match(repr(lock)))
 
@@ -95,8 +92,7 @@ def test(lock):
             self.assertFalse(primitive.locked())
 
     def test_acquire(self):
-        with self.assertWarns(DeprecationWarning):
-            lock = asyncio.Lock(loop=self.loop)
+        lock = asyncio.Lock(loop=self.loop)
         result = []
 
         self.assertTrue(self.loop.run_until_complete(lock.acquire()))
@@ -147,8 +143,7 @@ async def c3(result):
         self.assertTrue(t3.result())
 
     def test_acquire_cancel(self):
-        with self.assertWarns(DeprecationWarning):
-            lock = asyncio.Lock(loop=self.loop)
+        lock = asyncio.Lock(loop=self.loop)
         self.assertTrue(self.loop.run_until_complete(lock.acquire()))
 
         task = self.loop.create_task(lock.acquire())
@@ -173,8 +168,7 @@ def test_cancel_race(self):
         # B's waiter; instead, it should move on to C's waiter.
 
         # Setup: A has the lock, b and c are waiting.
-        with self.assertWarns(DeprecationWarning):
-            lock = asyncio.Lock(loop=self.loop)
+        lock = asyncio.Lock(loop=self.loop)
 
         async def lockit(name, blocker):
             await lock.acquire()
@@ -210,8 +204,7 @@ def test_cancel_release_race(self):
         # Issue 32734
         # Acquire 4 locks, cancel second, release first
         # and 2 locks are taken at once.
-        with self.assertWarns(DeprecationWarning):
-            lock = asyncio.Lock(loop=self.loop)
+        lock = asyncio.Lock(loop=self.loop)
         lock_count = 0
         call_count = 0
 
@@ -256,8 +249,7 @@ def trigger():
         self.assertTrue(t3.cancelled())
 
     def test_finished_waiter_cancelled(self):
-        with self.assertWarns(DeprecationWarning):
-            lock = asyncio.Lock(loop=self.loop)
+        lock = asyncio.Lock(loop=self.loop)
 
         ta = self.loop.create_task(lock.acquire())
         test_utils.run_briefly(self.loop)
@@ -279,14 +271,12 @@ def test_finished_waiter_cancelled(self):
         self.assertTrue(tb.cancelled())
 
     def test_release_not_acquired(self):
-        with self.assertWarns(DeprecationWarning):
-            lock = asyncio.Lock(loop=self.loop)
+        lock = asyncio.Lock(loop=self.loop)
 
         self.assertRaises(RuntimeError, lock.release)
 
     def test_release_no_waiters(self):
-        with self.assertWarns(DeprecationWarning):
-            lock = asyncio.Lock(loop=self.loop)
+        lock = asyncio.Lock(loop=self.loop)
         self.loop.run_until_complete(lock.acquire())
         self.assertTrue(lock.locked())
 
@@ -314,12 +304,10 @@ def setUp(self):
 
     def test_ctor_loop(self):
         loop = mock.Mock()
-        with self.assertWarns(DeprecationWarning):
-            ev = asyncio.Event(loop=loop)
+        ev = asyncio.Event(loop=loop)
         self.assertIs(ev._loop, loop)
 
-        with self.assertWarns(DeprecationWarning):
-            ev = asyncio.Event(loop=self.loop)
+        ev = asyncio.Event(loop=self.loop)
         self.assertIs(ev._loop, self.loop)
 
     def test_ctor_noloop(self):
@@ -328,8 +316,7 @@ def test_ctor_noloop(self):
         self.assertIs(ev._loop, self.loop)
 
     def test_repr(self):
-        with self.assertWarns(DeprecationWarning):
-            ev = asyncio.Event(loop=self.loop)
+        ev = asyncio.Event(loop=self.loop)
         self.assertTrue(repr(ev).endswith('[unset]>'))
         match = RGX_REPR.match(repr(ev))
         self.assertEqual(match.group('extras'), 'unset')
@@ -343,8 +330,7 @@ def test_repr(self):
         self.assertTrue(RGX_REPR.match(repr(ev)))
 
     def test_wait(self):
-        with self.assertWarns(DeprecationWarning):
-            ev = asyncio.Event(loop=self.loop)
+        ev = asyncio.Event(loop=self.loop)
         self.assertFalse(ev.is_set())
 
         result = []
@@ -381,16 +367,14 @@ async def c3(result):
         self.assertIsNone(t3.result())
 
     def test_wait_on_set(self):
-        with self.assertWarns(DeprecationWarning):
-            ev = asyncio.Event(loop=self.loop)
+        ev = asyncio.Event(loop=self.loop)
         ev.set()
 
         res = self.loop.run_until_complete(ev.wait())
         self.assertTrue(res)
 
     def test_wait_cancel(self):
-        with self.assertWarns(DeprecationWarning):
-            ev = asyncio.Event(loop=self.loop)
+        ev = asyncio.Event(loop=self.loop)
 
         wait = self.loop.create_task(ev.wait())
         self.loop.call_soon(wait.cancel)
@@ -400,8 +384,7 @@ def test_wait_cancel(self):
         self.assertFalse(ev._waiters)
 
     def test_clear(self):
-        with self.assertWarns(DeprecationWarning):
-            ev = asyncio.Event(loop=self.loop)
+        ev = asyncio.Event(loop=self.loop)
         self.assertFalse(ev.is_set())
 
         ev.set()
@@ -411,8 +394,7 @@ def test_clear(self):
         self.assertFalse(ev.is_set())
 
     def test_clear_with_waiters(self):
-        with self.assertWarns(DeprecationWarning):
-            ev = asyncio.Event(loop=self.loop)
+        ev = asyncio.Event(loop=self.loop)
         result = []
 
         async def c1(result):
@@ -448,12 +430,11 @@ def setUp(self):
 
     def test_ctor_loop(self):
         loop = mock.Mock()
-        with self.assertWarns(DeprecationWarning):
-            cond = asyncio.Condition(loop=loop)
-            self.assertIs(cond._loop, loop)
+        cond = asyncio.Condition(loop=loop)
+        self.assertIs(cond._loop, loop)
 
-            cond = asyncio.Condition(loop=self.loop)
-            self.assertIs(cond._loop, self.loop)
+        cond = asyncio.Condition(loop=self.loop)
+        self.assertIs(cond._loop, self.loop)
 
     def test_ctor_noloop(self):
         asyncio.set_event_loop(self.loop)
@@ -461,8 +442,7 @@ def test_ctor_noloop(self):
         self.assertIs(cond._loop, self.loop)
 
     def test_wait(self):
-        with self.assertWarns(DeprecationWarning):
-            cond = asyncio.Condition(loop=self.loop)
+        cond = asyncio.Condition(loop=self.loop)
         result = []
 
         async def c1(result):
@@ -525,8 +505,7 @@ async def c3(result):
         self.assertTrue(t3.result())
 
     def test_wait_cancel(self):
-        with self.assertWarns(DeprecationWarning):
-            cond = asyncio.Condition(loop=self.loop)
+        cond = asyncio.Condition(loop=self.loop)
         self.loop.run_until_complete(cond.acquire())
 
         wait = self.loop.create_task(cond.wait())
@@ -538,8 +517,7 @@ def test_wait_cancel(self):
         self.assertTrue(cond.locked())
 
     def test_wait_cancel_contested(self):
-        with self.assertWarns(DeprecationWarning):
-            cond = asyncio.Condition(loop=self.loop)
+        cond = asyncio.Condition(loop=self.loop)
 
         self.loop.run_until_complete(cond.acquire())
         self.assertTrue(cond.locked())
@@ -565,8 +543,7 @@ def test_wait_cancel_contested(self):
 
     def test_wait_cancel_after_notify(self):
         # See bpo-32841
-        with self.assertWarns(DeprecationWarning):
-            cond = asyncio.Condition(loop=self.loop)
+        cond = asyncio.Condition(loop=self.loop)
         waited = False
 
         async def wait_on_cond():
@@ -590,15 +567,13 @@ async def wait_on_cond():
         self.assertTrue(waited)
 
     def test_wait_unacquired(self):
-        with self.assertWarns(DeprecationWarning):
-            cond = asyncio.Condition(loop=self.loop)
+        cond = asyncio.Condition(loop=self.loop)
         self.assertRaises(
             RuntimeError,
             self.loop.run_until_complete, cond.wait())
 
     def test_wait_for(self):
-        with self.assertWarns(DeprecationWarning):
-            cond = asyncio.Condition(loop=self.loop)
+        cond = asyncio.Condition(loop=self.loop)
         presult = False
 
         def predicate():
@@ -635,8 +610,7 @@ async def c1(result):
         self.assertTrue(t.result())
 
     def test_wait_for_unacquired(self):
-        with self.assertWarns(DeprecationWarning):
-            cond = asyncio.Condition(loop=self.loop)
+        cond = asyncio.Condition(loop=self.loop)
 
         # predicate can return true immediately
         res = self.loop.run_until_complete(cond.wait_for(lambda: [1, 2, 3]))
@@ -648,8 +622,7 @@ def test_wait_for_unacquired(self):
             cond.wait_for(lambda: False))
 
     def test_notify(self):
-        with self.assertWarns(DeprecationWarning):
-            cond = asyncio.Condition(loop=self.loop)
+        cond = asyncio.Condition(loop=self.loop)
         result = []
 
         async def c1(result):
@@ -701,8 +674,7 @@ async def c3(result):
         self.assertTrue(t3.result())
 
     def test_notify_all(self):
-        with self.assertWarns(DeprecationWarning):
-            cond = asyncio.Condition(loop=self.loop)
+        cond = asyncio.Condition(loop=self.loop)
 
         result = []
 
@@ -738,18 +710,15 @@ async def c2(result):
         self.assertTrue(t2.result())
 
     def test_notify_unacquired(self):
-        with self.assertWarns(DeprecationWarning):
-            cond = asyncio.Condition(loop=self.loop)
+        cond = asyncio.Condition(loop=self.loop)
         self.assertRaises(RuntimeError, cond.notify)
 
     def test_notify_all_unacquired(self):
-        with self.assertWarns(DeprecationWarning):
-            cond = asyncio.Condition(loop=self.loop)
+        cond = asyncio.Condition(loop=self.loop)
         self.assertRaises(RuntimeError, cond.notify_all)
 
     def test_repr(self):
-        with self.assertWarns(DeprecationWarning):
-            cond = asyncio.Condition(loop=self.loop)
+        cond = asyncio.Condition(loop=self.loop)
         self.assertTrue('unlocked' in repr(cond))
         self.assertTrue(RGX_REPR.match(repr(cond)))
 
@@ -775,9 +744,8 @@ async def f():
         self.loop.run_until_complete(f())
 
     def test_explicit_lock(self):
-        with self.assertWarns(DeprecationWarning):
-            lock = asyncio.Lock(loop=self.loop)
-            cond = asyncio.Condition(lock, loop=self.loop)
+        lock = asyncio.Lock(loop=self.loop)
+        cond = asyncio.Condition(lock, loop=self.loop)
 
         self.assertIs(cond._lock, lock)
         self.assertIs(cond._loop, lock._loop)
@@ -785,10 +753,9 @@ def test_explicit_lock(self):
     def test_ambiguous_loops(self):
         loop = self.new_test_loop()
         self.addCleanup(loop.close)
-        with self.assertWarns(DeprecationWarning):
-            lock = asyncio.Lock(loop=self.loop)
-            with self.assertRaises(ValueError):
-                asyncio.Condition(lock, loop=loop)
+        lock = asyncio.Lock(loop=self.loop)
+        with self.assertRaises(ValueError):
+            asyncio.Condition(lock, loop=loop)
 
     def test_timeout_in_block(self):
         loop = asyncio.new_event_loop()
@@ -800,8 +767,7 @@ async def task_timeout():
                 with self.assertRaises(asyncio.TimeoutError):
                     await asyncio.wait_for(condition.wait(), timeout=0.5)
 
-        with self.assertWarns(DeprecationWarning):
-            loop.run_until_complete(task_timeout())
+        loop.run_until_complete(task_timeout())
 
 
 class SemaphoreTests(test_utils.TestCase):
@@ -812,12 +778,10 @@ def setUp(self):
 
     def test_ctor_loop(self):
         loop = mock.Mock()
-        with self.assertWarns(DeprecationWarning):
-            sem = asyncio.Semaphore(loop=loop)
+        sem = asyncio.Semaphore(loop=loop)
         self.assertIs(sem._loop, loop)
 
-        with self.assertWarns(DeprecationWarning):
-            sem = asyncio.Semaphore(loop=self.loop)
+        sem = asyncio.Semaphore(loop=self.loop)
         self.assertIs(sem._loop, self.loop)
 
     def test_ctor_noloop(self):
@@ -826,13 +790,11 @@ def test_ctor_noloop(self):
         self.assertIs(sem._loop, self.loop)
 
     def test_initial_value_zero(self):
-        with self.assertWarns(DeprecationWarning):
-            sem = asyncio.Semaphore(0, loop=self.loop)
+        sem = asyncio.Semaphore(0, loop=self.loop)
         self.assertTrue(sem.locked())
 
     def test_repr(self):
-        with self.assertWarns(DeprecationWarning):
-            sem = asyncio.Semaphore(loop=self.loop)
+        sem = asyncio.Semaphore(loop=self.loop)
         self.assertTrue(repr(sem).endswith('[unlocked, value:1]>'))
         self.assertTrue(RGX_REPR.match(repr(sem)))
 
@@ -850,9 +812,7 @@ def test_repr(self):
         self.assertTrue(RGX_REPR.match(repr(sem)))
 
     def test_semaphore(self):
-        with self.assertWarns(DeprecationWarning):
-            sem = asyncio.Semaphore(loop=self.loop)
-        self.assertEqual(1, sem._value)
+        sem = asyncio.Semaphore(loop=self.loop)
 
         with self.assertWarns(DeprecationWarning):
             @asyncio.coroutine
@@ -872,8 +832,7 @@ def test_semaphore_value(self):
         self.assertRaises(ValueError, asyncio.Semaphore, -1)
 
     def test_acquire(self):
-        with self.assertWarns(DeprecationWarning):
-            sem = asyncio.Semaphore(3, loop=self.loop)
+        sem = asyncio.Semaphore(3, loop=self.loop)
         result = []
 
         self.assertTrue(self.loop.run_until_complete(sem.acquire()))
@@ -934,8 +893,8 @@ async def c4(result):
         self.loop.run_until_complete(asyncio.gather(*race_tasks))
 
     def test_acquire_cancel(self):
-        with self.assertWarns(DeprecationWarning):
-            sem = asyncio.Semaphore(loop=self.loop)
+        sem = asyncio.Semaphore(loop=self.loop)
+
         self.loop.run_until_complete(sem.acquire())
 
         acquire = self.loop.create_task(sem.acquire())
@@ -947,8 +906,7 @@ def test_acquire_cancel(self):
                         all(waiter.done() for waiter in sem._waiters))
 
     def test_acquire_cancel_before_awoken(self):
-        with self.assertWarns(DeprecationWarning):
-            sem = asyncio.Semaphore(value=0, loop=self.loop)
+        sem = asyncio.Semaphore(value=0, loop=self.loop)
 
         t1 = self.loop.create_task(sem.acquire())
         t2 = self.loop.create_task(sem.acquire())
@@ -970,8 +928,7 @@ def test_acquire_cancel_before_awoken(self):
         test_utils.run_briefly(self.loop)
 
     def test_acquire_hang(self):
-        with self.assertWarns(DeprecationWarning):
-            sem = asyncio.Semaphore(value=0, loop=self.loop)
+        sem = asyncio.Semaphore(value=0, loop=self.loop)
 
         t1 = self.loop.create_task(sem.acquire())
         t2 = self.loop.create_task(sem.acquire())
@@ -991,8 +948,7 @@ def test_release_not_acquired(self):
         self.assertRaises(ValueError, sem.release)
 
     def test_release_no_waiters(self):
-        with self.assertWarns(DeprecationWarning):
-            sem = asyncio.Semaphore(loop=self.loop)
+        sem = asyncio.Semaphore(loop=self.loop)
         self.loop.run_until_complete(sem.acquire())
         self.assertTrue(sem.locked())
 
@@ -1000,5 +956,34 @@ def test_release_no_waiters(self):
         self.assertFalse(sem.locked())
 
 
+class LockLoopTests:
+    """Tests the deprecation of creating asyncio objects outside a
+    running event loop."""
+
+    def setUp(self):
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self.loop)
+
+    def tearDown(self):
+        asyncio.set_event_loop(None)
+        self.loop.close()
+
+    def test_lock_loop_not_running(self):
+        with self.assertWarns(DeprecationWarning):
+            asyncio.Lock()
+
+    def test_event_loop_not_running(self):
+        with self.assertWarns(DeprecationWarning):
+            asyncio.Event()
+
+    def test_condition_loop_not_running(self):
+        with self.assertWarns(DeprecationWarning):
+            asyncio.Condition()
+
+    def test_semaphore_loop_not_running(self):
+        with self.assertWarns(DeprecationWarning):
+            asyncio.Semaphore()
+
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_asyncio/test_queues.py b/Lib/test/test_asyncio/test_queues.py
index 5c9aaa82c311a54..48bf21037bb1572 100644
--- a/Lib/test/test_asyncio/test_queues.py
+++ b/Lib/test/test_asyncio/test_queues.py
@@ -35,8 +35,7 @@ def gen():
 
         loop = self.new_test_loop(gen)
 
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=loop)
+        q = asyncio.Queue(loop=loop)
         self.assertTrue(fn(q).startswith('<Queue'), fn(q))
         id_is_present = hex(id(q)) in fn(q)
         self.assertEqual(expect_id, id_is_present)
@@ -51,8 +50,7 @@ async def add_getter():
             # resume q.get coroutine to finish generator
             q.put_nowait(0)
 
-        with self.assertWarns(DeprecationWarning):
-            loop.run_until_complete(add_getter())
+        loop.run_until_complete(add_getter())
 
         async def add_putter():
             q = asyncio.Queue(maxsize=1, loop=loop)
@@ -65,20 +63,17 @@ async def add_putter():
             # resume q.put coroutine to finish generator
             q.get_nowait()
 
-        with self.assertWarns(DeprecationWarning):
-            loop.run_until_complete(add_putter())
-            q = asyncio.Queue(loop=loop)
+        loop.run_until_complete(add_putter())
+        q = asyncio.Queue(loop=loop)
         q.put_nowait(1)
         self.assertTrue('_queue=[1]' in fn(q))
 
     def test_ctor_loop(self):
         loop = mock.Mock()
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=loop)
+        q = asyncio.Queue(loop=loop)
         self.assertIs(q._loop, loop)
 
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=self.loop)
+        q = asyncio.Queue(loop=self.loop)
         self.assertIs(q._loop, self.loop)
 
     def test_ctor_noloop(self):
@@ -93,8 +88,7 @@ def test_str(self):
         self._test_repr_or_str(str, False)
 
     def test_empty(self):
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=self.loop)
+        q = asyncio.Queue(loop=self.loop)
         self.assertTrue(q.empty())
         q.put_nowait(1)
         self.assertFalse(q.empty())
@@ -102,18 +96,15 @@ def test_empty(self):
         self.assertTrue(q.empty())
 
     def test_full(self):
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=self.loop)
+        q = asyncio.Queue(loop=self.loop)
         self.assertFalse(q.full())
 
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(maxsize=1, loop=self.loop)
+        q = asyncio.Queue(maxsize=1, loop=self.loop)
         q.put_nowait(1)
         self.assertTrue(q.full())
 
     def test_order(self):
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=self.loop)
+        q = asyncio.Queue(loop=self.loop)
         for i in [1, 3, 2]:
             q.put_nowait(i)
 
@@ -131,8 +122,7 @@ def gen():
 
         loop = self.new_test_loop(gen)
 
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(maxsize=2, loop=loop)
+        q = asyncio.Queue(maxsize=2, loop=loop)
         self.assertEqual(2, q.maxsize)
         have_been_put = []
 
@@ -166,8 +156,7 @@ async def test():
 class QueueGetTests(_QueueTestBase):
 
     def test_blocking_get(self):
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=self.loop)
+        q = asyncio.Queue(loop=self.loop)
         q.put_nowait(1)
 
         async def queue_get():
@@ -177,8 +166,7 @@ async def queue_get():
         self.assertEqual(1, res)
 
     def test_get_with_putters(self):
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(1, loop=self.loop)
+        q = asyncio.Queue(1, loop=self.loop)
         q.put_nowait(1)
 
         waiter = self.loop.create_future()
@@ -198,9 +186,8 @@ def gen():
 
         loop = self.new_test_loop(gen)
 
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=loop)
-            started = asyncio.Event(loop=loop)
+        q = asyncio.Queue(loop=loop)
+        started = asyncio.Event(loop=loop)
         finished = False
 
         async def queue_get():
@@ -224,14 +211,12 @@ async def queue_put():
         self.assertAlmostEqual(0.01, loop.time())
 
     def test_nonblocking_get(self):
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=self.loop)
+        q = asyncio.Queue(loop=self.loop)
         q.put_nowait(1)
         self.assertEqual(1, q.get_nowait())
 
     def test_nonblocking_get_exception(self):
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=self.loop)
+        q = asyncio.Queue(loop=self.loop)
         self.assertRaises(asyncio.QueueEmpty, q.get_nowait)
 
     def test_get_cancelled(self):
@@ -245,8 +230,7 @@ def gen():
 
         loop = self.new_test_loop(gen)
 
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=loop)
+        q = asyncio.Queue(loop=loop)
 
         async def queue_get():
             return await asyncio.wait_for(q.get(), 0.051)
@@ -261,8 +245,7 @@ async def test():
         self.assertAlmostEqual(0.06, loop.time())
 
     def test_get_cancelled_race(self):
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=self.loop)
+        q = asyncio.Queue(loop=self.loop)
 
         t1 = self.loop.create_task(q.get())
         t2 = self.loop.create_task(q.get())
@@ -276,8 +259,7 @@ def test_get_cancelled_race(self):
         self.assertEqual(t2.result(), 'a')
 
     def test_get_with_waiting_putters(self):
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=self.loop, maxsize=1)
+        q = asyncio.Queue(loop=self.loop, maxsize=1)
         self.loop.create_task(q.put('a'))
         self.loop.create_task(q.put('b'))
         test_utils.run_briefly(self.loop)
@@ -298,8 +280,7 @@ async def producer(queue, num_items):
         queue_size = 1
         producer_num_items = 5
 
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(queue_size, loop=self.loop)
+        q = asyncio.Queue(queue_size, loop=self.loop)
 
         self.loop.run_until_complete(
             asyncio.gather(producer(q, producer_num_items),
@@ -320,8 +301,7 @@ async def consumer(queue):
             except asyncio.TimeoutError:
                 pass
 
-        with self.assertWarns(DeprecationWarning):
-            queue = asyncio.Queue(loop=self.loop, maxsize=5)
+        queue = asyncio.Queue(loop=self.loop, maxsize=5)
         self.loop.run_until_complete(self.loop.create_task(consumer(queue)))
         self.assertEqual(len(queue._getters), 0)
 
@@ -329,8 +309,7 @@ async def consumer(queue):
 class QueuePutTests(_QueueTestBase):
 
     def test_blocking_put(self):
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=self.loop)
+        q = asyncio.Queue(loop=self.loop)
 
         async def queue_put():
             # No maxsize, won't block.
@@ -347,9 +326,8 @@ def gen():
 
         loop = self.new_test_loop(gen)
 
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(maxsize=1, loop=loop)
-            started = asyncio.Event(loop=loop)
+        q = asyncio.Queue(maxsize=1, loop=loop)
+        started = asyncio.Event(loop=loop)
         finished = False
 
         async def queue_put():
@@ -371,8 +349,7 @@ async def queue_get():
         self.assertAlmostEqual(0.01, loop.time())
 
     def test_nonblocking_put(self):
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=self.loop)
+        q = asyncio.Queue(loop=self.loop)
         q.put_nowait(1)
         self.assertEqual(1, q.get_nowait())
 
@@ -383,8 +360,7 @@ def gen():
 
         loop = self.new_test_loop(gen)
 
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=loop)
+        q = asyncio.Queue(loop=loop)
 
         reader = loop.create_task(q.get())
 
@@ -413,8 +389,7 @@ def gen():
         loop = self.new_test_loop(gen)
         loop.set_debug(True)
 
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=loop)
+        q = asyncio.Queue(loop=loop)
 
         reader1 = loop.create_task(q.get())
         reader2 = loop.create_task(q.get())
@@ -444,8 +419,7 @@ def gen():
 
         loop = self.new_test_loop(gen)
 
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(1, loop=loop)
+        q = asyncio.Queue(1, loop=loop)
 
         q.put_nowait(1)
 
@@ -469,21 +443,18 @@ def gen():
         self.assertEqual(q.qsize(), 0)
 
     def test_nonblocking_put_exception(self):
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(maxsize=1, loop=self.loop)
+        q = asyncio.Queue(maxsize=1, loop=self.loop)
         q.put_nowait(1)
         self.assertRaises(asyncio.QueueFull, q.put_nowait, 2)
 
     def test_float_maxsize(self):
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(maxsize=1.3, loop=self.loop)
+        q = asyncio.Queue(maxsize=1.3, loop=self.loop)
         q.put_nowait(1)
         q.put_nowait(2)
         self.assertTrue(q.full())
         self.assertRaises(asyncio.QueueFull, q.put_nowait, 3)
 
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(maxsize=1.3, loop=self.loop)
+        q = asyncio.Queue(maxsize=1.3, loop=self.loop)
 
         async def queue_put():
             await q.put(1)
@@ -492,8 +463,7 @@ async def queue_put():
         self.loop.run_until_complete(queue_put())
 
     def test_put_cancelled(self):
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=self.loop)
+        q = asyncio.Queue(loop=self.loop)
 
         async def queue_put():
             await q.put(1)
@@ -508,8 +478,7 @@ async def test():
         self.assertTrue(t.result())
 
     def test_put_cancelled_race(self):
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=self.loop, maxsize=1)
+        q = asyncio.Queue(loop=self.loop, maxsize=1)
 
         put_a = self.loop.create_task(q.put('a'))
         put_b = self.loop.create_task(q.put('b'))
@@ -529,8 +498,7 @@ def test_put_cancelled_race(self):
         self.loop.run_until_complete(put_b)
 
     def test_put_with_waiting_getters(self):
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.Queue(loop=self.loop)
+        q = asyncio.Queue(loop=self.loop)
         t = self.loop.create_task(q.get())
         test_utils.run_briefly(self.loop)
         self.loop.run_until_complete(q.put('a'))
@@ -538,9 +506,7 @@ def test_put_with_waiting_getters(self):
 
     def test_why_are_putters_waiting(self):
         # From issue #265.
-
-        with self.assertWarns(DeprecationWarning):
-            queue = asyncio.Queue(2, loop=self.loop)
+        queue = asyncio.Queue(2, loop=self.loop)
 
         async def putter(item):
             await queue.put(item)
@@ -566,8 +532,7 @@ def a_generator():
         loop = self.new_test_loop(a_generator)
 
         # Full queue.
-        with self.assertWarns(DeprecationWarning):
-            queue = asyncio.Queue(loop=loop, maxsize=1)
+        queue = asyncio.Queue(loop=loop, maxsize=1)
         queue.put_nowait(1)
 
         # Task waiting for space to put an item in the queue.
@@ -590,8 +555,7 @@ def gen():
         loop = self.new_test_loop(gen)
 
         # Full Queue.
-        with self.assertWarns(DeprecationWarning):
-            queue = asyncio.Queue(1, loop=loop)
+        queue = asyncio.Queue(1, loop=loop)
         queue.put_nowait(1)
 
         # Task waiting for space to put a item in the queue.
@@ -614,8 +578,7 @@ def gen():
 class LifoQueueTests(_QueueTestBase):
 
     def test_order(self):
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.LifoQueue(loop=self.loop)
+        q = asyncio.LifoQueue(loop=self.loop)
         for i in [1, 3, 2]:
             q.put_nowait(i)
 
@@ -626,8 +589,7 @@ def test_order(self):
 class PriorityQueueTests(_QueueTestBase):
 
     def test_order(self):
-        with self.assertWarns(DeprecationWarning):
-            q = asyncio.PriorityQueue(loop=self.loop)
+        q = asyncio.PriorityQueue(loop=self.loop)
         for i in [1, 3, 2]:
             q.put_nowait(i)
 
@@ -640,13 +602,11 @@ class _QueueJoinTestMixin:
     q_class = None
 
     def test_task_done_underflow(self):
-        with self.assertWarns(DeprecationWarning):
-            q = self.q_class(loop=self.loop)
+        q = self.q_class(loop=self.loop)
         self.assertRaises(ValueError, q.task_done)
 
     def test_task_done(self):
-        with self.assertWarns(DeprecationWarning):
-            q = self.q_class(loop=self.loop)
+        q = self.q_class(loop=self.loop)
         for i in range(100):
             q.put_nowait(i)
 
@@ -681,8 +641,7 @@ async def test():
         self.loop.run_until_complete(asyncio.wait(tasks))
 
     def test_join_empty_queue(self):
-        with self.assertWarns(DeprecationWarning):
-            q = self.q_class(loop=self.loop)
+        q = self.q_class(loop=self.loop)
 
         # Test that a queue join()s successfully, and before anything else
         # (done twice for insurance).
@@ -694,8 +653,7 @@ async def join():
         self.loop.run_until_complete(join())
 
     def test_format(self):
-        with self.assertWarns(DeprecationWarning):
-            q = self.q_class(loop=self.loop)
+        q = self.q_class(loop=self.loop)
         self.assertEqual(q._format(), 'maxsize=0')
 
         q._unfinished_tasks = 2
@@ -714,5 +672,22 @@ class PriorityQueueJoinTests(_QueueJoinTestMixin, _QueueTestBase):
     q_class = asyncio.PriorityQueue
 
 
+class QueueLoopTests:
+    """Tests the deprecation of creating asyncio objects outside a
+    running event loop."""
+
+    def setUp(self):
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self.loop)
+
+    def tearDown(self):
+        asyncio.set_event_loop(None)
+        self.loop.close()
+
+    def test_queue_loop_not_running(self):
+        with self.assertWarns(DeprecationWarning):
+            asyncio.Queue()
+
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Misc/NEWS.d/next/Library/2020-01-26-20-54-04.bpo-38599.0PObOD.rst b/Misc/NEWS.d/next/Library/2020-01-26-20-54-04.bpo-38599.0PObOD.rst
new file mode 100644
index 000000000000000..6636fbbe3a10f9d
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2020-01-26-20-54-04.bpo-38599.0PObOD.rst
@@ -0,0 +1,4 @@
+The creation of :class:`asyncio.Queue`, :class:`asyncio.Lock`,
+:class:`asyncio.Event`, :class:`asyncio.Condition`,
+:class:`asyncio.Semaphore`, and :class:`asyncio.BoundedSemaphore`
+objects outside of a running event loop has been deprecated.