   let _sema: DispatchSemaphore
   var _locking = makeLocking()
   let _bufferedPeriodics: QueueImpl<PeriodicValue>
-  let _channel: Channel<PeriodicValue, FinalValue>
+  let _producer: Producer<PeriodicValue, FinalValue>
   var _handler: ChannelHandler<PeriodicValue, FinalValue>?
   override var finalValue: Fallible<FinalValue>? {
     _locking.lock()

    }

    executor.execute {
      self._locking.lock()
      var iterator = self._bufferedPeriodics.makeIterator()
      while let periodic_ = iterator.next() {
        block(.periodic(periodic_))
      }
      self._locking.unlock()
    }

    return handler

  }
  var _finalValue: Fallible<FinalValue>?

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