# License for the specific language governing permissions and limitations
# under the License.
-"""
-.. testsetup:: *
-
- from tornado import ioloop, gen, locks
- io_loop = ioloop.IOLoop.current()
-"""
-
from __future__ import absolute_import, division, print_function, with_statement
__all__ = ['Condition', 'Event', 'Semaphore', 'BoundedSemaphore', 'Lock']
.. testcode::
- condition = locks.Condition()
+ from tornado import gen
+ from tornado.ioloop import IOLoop
+ from tornado.locks import Condition
+
+ condition = Condition()
@gen.coroutine
def waiter():
# Yield two Futures; wait for waiter() and notifier() to finish.
yield [waiter(), notifier()]
- io_loop.run_sync(runner)
+ IOLoop.current().run_sync(runner)
.. testoutput::
`wait` takes an optional ``timeout`` argument, which is either an absolute
timestamp::
- io_loop = ioloop.IOLoop.current()
+ io_loop = IOLoop.current()
# Wait up to 1 second for a notification.
yield condition.wait(timeout=io_loop.time() + 1)
.. testcode::
- event = locks.Event()
+ from tornado import gen
+ from tornado.ioloop import IOLoop
+ from tornado.locks import Event
+
+ event = Event()
@gen.coroutine
def waiter():
def runner():
yield [waiter(), setter()]
- io_loop.run_sync(runner)
+ IOLoop.current().run_sync(runner)
.. testoutput::
def clear(self):
"""Reset the internal flag to ``False``.
-
+
Calls to `.wait` will block until `.set` is called.
"""
if self._future.done():
from collections import deque
- from tornado import gen, ioloop
+ from tornado import gen
+ from tornado.ioloop import IOLoop
from tornado.concurrent import Future
# Ensure reliable doctest output: resolve Futures one at a time.
yield gen.moment
f.set_result(None)
- ioloop.IOLoop.current().add_callback(simulator, list(futures_q))
+ IOLoop.current().add_callback(simulator, list(futures_q))
def use_some_resource():
return futures_q.popleft()
.. testcode:: semaphore
- sem = locks.Semaphore(2)
+ from tornado import gen
+ from tornado.ioloop import IOLoop
+ from tornado.locks import Semaphore
+
+ sem = Semaphore(2)
@gen.coroutine
def worker(worker_id):
# Join all workers.
yield [worker(i) for i in range(3)]
- io_loop.run_sync(runner)
+ IOLoop.current().run_sync(runner)
.. testoutput:: semaphore
.. testcode::
- q = queues.Queue(maxsize=2)
+ from tornado import gen
+ from tornado.ioloop import IOLoop
+ from tornado.queues import Queue
+
+ q = Queue(maxsize=2)
@gen.coroutine
def consumer():
@gen.coroutine
def main():
- consumer() # Start consumer.
+ # Start consumer without waiting (since it never finishes).
+ IOLoop.current().spawn_callback(consumer)
yield producer() # Wait for producer to put all tasks.
yield q.join() # Wait for consumer to finish all tasks.
print('Done')
- io_loop.run_sync(main)
+ IOLoop.current().run_sync(main)
.. testoutput::
Put 0
Put 1
- Put 2
Doing work on 0
+ Put 2
Doing work on 1
Put 3
Doing work on 2
.. testcode::
- q = queues.PriorityQueue()
+ from tornado.queues import PriorityQueue
+
+ q = PriorityQueue()
q.put((1, 'medium-priority item'))
q.put((0, 'high-priority item'))
q.put((10, 'low-priority item'))
.. testcode::
- q = queues.LifoQueue()
+ from tornado.queues import LifoQueue
+
+ q = LifoQueue()
q.put(3)
q.put(2)
q.put(1)