   }
   var _finalValue: Fallible<FinalValue>?
 
-  init(channel: Channel<PeriodicValue, FinalValue>, bufferedPeriodics: QueueImpl<PeriodicValue>) {
-    _channel = channel
+  init(channel: Producer<PeriodicValue, FinalValue>, bufferedPeriodics: QueueImpl<PeriodicValue>) {
+    _producer = channel
     _bufferedPeriodics = bufferedPeriodics
-    _sema = DispatchSemaphore(value: bufferedPeriodics.count)
+    _sema = DispatchSemaphore(value: 0)
+    for _ in 0..<_bufferedPeriodics.count {
+      _sema.signal()
+    }
     super.init()
-    _handler = channel.makeHandler(executor: .immediate) { [weak self] (value) in
+    _handler = channel._makeHandler(executor: .immediate, avoidLocking: true) { [weak self] (value) in
       self?.handle(value)
     }
   }

  /// **internal use only**
  override public func makeHandler(executor: Executor,
                                   block: @escaping (Value) -> Void) -> Handler? {
    let handler = Handler(executor: executor, block: block)
    _container.updateHead {
      switch $0 {

    _locking.lock()
    defer { _locking.unlock() }

    if let periodic = _bufferedPeriodics.pop() {
      return periodic
    } else {
      _sema.signal()
      return nil
    }
  }

  override func clone() -> ChannelIteratorImpl<PeriodicValue, FinalValue> {
    return ProducerIteratorImpl(channel: _producer, bufferedPeriodics: _bufferedPeriodics.clone())
  }

  func handle(_ value: ChannelValue<PeriodicValue, FinalValue>) {
