io.netty.util.concurrent.DefaultPromise.notifyListener0 java code examples

Common ways to obtain DefaultPromise

private void myMethod () {
     DefaultPromise d =EventExecutor executor;new DefaultPromise<>(executor)
Smart code suggestions by Codota
}

private void notifyListeners0(DefaultFutureListeners listeners) {
  GenericFutureListener<?>[] a = listeners.listeners();
  int size = listeners.size();
  for (int i = 0; i < size; i ++) {
    notifyListener0(this, a[i]);
  }
}

/**
 * The logic in this method should be identical to {@link #notifyListeners()} but
 * cannot share code because the listener(s) cannot be cached for an instance of {@link DefaultPromise} since the
 * listener(s) may be changed and is protected by a synchronized operation.
 */
private static void notifyListenerWithStackOverFlowProtection(final EventExecutor executor,
                               final Future<?> future,
                               final GenericFutureListener<?> listener) {
  if (executor.inEventLoop()) {
    final InternalThreadLocalMap threadLocals = InternalThreadLocalMap.get();
    final int stackDepth = threadLocals.futureListenerStackDepth();
    if (stackDepth < MAX_LISTENER_STACK_DEPTH) {
      threadLocals.setFutureListenerStackDepth(stackDepth + 1);
      try {
        notifyListener0(future, listener);
      } finally {
        threadLocals.setFutureListenerStackDepth(stackDepth);
      }
      return;
    }
  }
  safeExecute(executor, new Runnable() {
    @Override
    public void run() {
      notifyListener0(future, listener);
    }
  });
}

private void notifyListenersNow() {
  Object listeners;
  synchronized (this) {
    // Only proceed if there are listeners to notify and we are not already notifying listeners.
    if (notifyingListeners || this.listeners == null) {
      return;
    }
    notifyingListeners = true;
    listeners = this.listeners;
    this.listeners = null;
  }
  for (;;) {
    if (listeners instanceof DefaultFutureListeners) {
      notifyListeners0((DefaultFutureListeners) listeners);
    } else {
      notifyListener0(this, (GenericFutureListener<?>) listeners);
    }
    synchronized (this) {
      if (this.listeners == null) {
        // Nothing can throw from within this method, so setting notifyingListeners back to false does not
        // need to be in a finally block.
        notifyingListeners = false;
        return;
      }
      listeners = this.listeners;
      this.listeners = null;
    }
  }
}

private void notifyListeners0(DefaultFutureListeners listeners) {
  GenericFutureListener<?>[] a = listeners.listeners();
  int size = listeners.size();
  for (int i = 0; i < size; i ++) {
    notifyListener0(this, a[i]);
  }
}

private void notifyListeners0(DefaultFutureListeners listeners) {
  GenericFutureListener<?>[] a = listeners.listeners();
  int size = listeners.size();
  for (int i = 0; i < size; i ++) {
    notifyListener0(this, a[i]);
  }
}

/**
 * The logic in this method should be identical to {@link #notifyListeners()} but
 * cannot share code because the listener(s) cannot be cached for an instance of {@link DefaultPromise} since the
 * listener(s) may be changed and is protected by a synchronized operation.
 */
private static void notifyListenerWithStackOverFlowProtection(final EventExecutor executor,
                               final Future<?> future,
                               final GenericFutureListener<?> listener) {
  if (executor.inEventLoop()) {
    final InternalThreadLocalMap threadLocals = InternalThreadLocalMap.get();
    final int stackDepth = threadLocals.futureListenerStackDepth();
    if (stackDepth < MAX_LISTENER_STACK_DEPTH) {
      threadLocals.setFutureListenerStackDepth(stackDepth + 1);
      try {
        notifyListener0(future, listener);
      } finally {
        threadLocals.setFutureListenerStackDepth(stackDepth);
      }
      return;
    }
  }
  safeExecute(executor, new Runnable() {
    @Override
    public void run() {
      notifyListener0(future, listener);
    }
  });
}

private void notifyListenersNow() {
  Object listeners;
  synchronized (this) {
    // Only proceed if there are listeners to notify and we are not already notifying listeners.
    if (notifyingListeners || this.listeners == null) {
      return;
    }
    notifyingListeners = true;
    listeners = this.listeners;
    this.listeners = null;
  }
  for (;;) {
    if (listeners instanceof DefaultFutureListeners) {
      notifyListeners0((DefaultFutureListeners) listeners);
    } else {
      notifyListener0(this, (GenericFutureListener<?>) listeners);
    }
    synchronized (this) {
      if (this.listeners == null) {
        // Nothing can throw from within this method, so setting notifyingListeners back to false does not
        // need to be in a finally block.
        notifyingListeners = false;
        return;
      }
      listeners = this.listeners;
      this.listeners = null;
    }
  }
}

/**
 * The logic in this method should be identical to {@link #notifyListeners()} but
 * cannot share code because the listener(s) cannot be cached for an instance of {@link DefaultPromise} since the
 * listener(s) may be changed and is protected by a synchronized operation.
 */
private static void notifyListenerWithStackOverFlowProtection(final EventExecutor executor,
                               final Future<?> future,
                               final GenericFutureListener<?> listener) {
  if (executor.inEventLoop()) {
    final InternalThreadLocalMap threadLocals = InternalThreadLocalMap.get();
    final int stackDepth = threadLocals.futureListenerStackDepth();
    if (stackDepth < MAX_LISTENER_STACK_DEPTH) {
      threadLocals.setFutureListenerStackDepth(stackDepth + 1);
      try {
        notifyListener0(future, listener);
      } finally {
        threadLocals.setFutureListenerStackDepth(stackDepth);
      }
      return;
    }
  }
  safeExecute(executor, new Runnable() {
    @Override
    public void run() {
      notifyListener0(future, listener);
    }
  });
}

private void notifyListenersNow() {
  Object listeners;
  synchronized (this) {
    // Only proceed if there are listeners to notify and we are not already notifying listeners.
    if (notifyingListeners || this.listeners == null) {
      return;
    }
    notifyingListeners = true;
    listeners = this.listeners;
    this.listeners = null;
  }
  for (;;) {
    if (listeners instanceof DefaultFutureListeners) {
      notifyListeners0((DefaultFutureListeners) listeners);
    } else {
      notifyListener0(this, (GenericFutureListener<?>) listeners);
    }
    synchronized (this) {
      if (this.listeners == null) {
        // Nothing can throw from within this method, so setting notifyingListeners back to false does not
        // need to be in a finally block.
        notifyingListeners = false;
        return;
      }
      listeners = this.listeners;
      this.listeners = null;
    }
  }
}

private void notifyListeners0(DefaultFutureListeners listeners) {
  GenericFutureListener<?>[] a = listeners.listeners();
  int size = listeners.size();
  for (int i = 0; i < size; i ++) {
    notifyListener0(this, a[i]);
  }
}

/**
 * The logic in this method should be identical to {@link #notifyListeners()} but
 * cannot share code because the listener(s) cannot be cached for an instance of {@link DefaultPromise} since the
 * listener(s) may be changed and is protected by a synchronized operation.
 */
private static void notifyListenerWithStackOverFlowProtection(final EventExecutor executor,
                               final Future<?> future,
                               final GenericFutureListener<?> listener) {
  if (executor.inEventLoop()) {
    final InternalThreadLocalMap threadLocals = InternalThreadLocalMap.get();
    final int stackDepth = threadLocals.futureListenerStackDepth();
    if (stackDepth < MAX_LISTENER_STACK_DEPTH) {
      threadLocals.setFutureListenerStackDepth(stackDepth + 1);
      try {
        notifyListener0(future, listener);
      } finally {
        threadLocals.setFutureListenerStackDepth(stackDepth);
      }
      return;
    }
  }
  safeExecute(executor, new Runnable() {
    @Override
    public void run() {
      notifyListener0(future, listener);
    }
  });
}

private void notifyListenersNow() {
  Object listeners;
  synchronized (this) {
    // Only proceed if there are listeners to notify and we are not already notifying listeners.
    if (notifyingListeners || this.listeners == null) {
      return;
    }
    notifyingListeners = true;
    listeners = this.listeners;
    this.listeners = null;
  }
  for (;;) {
    if (listeners instanceof DefaultFutureListeners) {
      notifyListeners0((DefaultFutureListeners) listeners);
    } else {
      notifyListener0(this, (GenericFutureListener<?>) listeners);
    }
    synchronized (this) {
      if (this.listeners == null) {
        // Nothing can throw from within this method, so setting notifyingListeners back to false does not
        // need to be in a finally block.
        notifyingListeners = false;
        return;
      }
      listeners = this.listeners;
      this.listeners = null;
    }
  }
}

private void notifyListeners0(DefaultFutureListeners listeners) {
  GenericFutureListener<?>[] a = listeners.listeners();
  int size = listeners.size();
  for (int i = 0; i < size; i ++) {
    notifyListener0(this, a[i]);
  }
}

private void notifyListeners0(DefaultFutureListeners listeners) {
  GenericFutureListener<?>[] a = listeners.listeners();
  int size = listeners.size();
  for (int i = 0; i < size; i ++) {
    notifyListener0(this, a[i]);
  }
}

private void notifyListeners0(DefaultFutureListeners listeners) {
  GenericFutureListener<?>[] a = listeners.listeners();
  int size = listeners.size();
  for (int i = 0; i < size; i ++) {
    notifyListener0(this, a[i]);
  }
}

Popular methods of DefaultPromise

<init>
Creates a new instance. It is preferable to use EventExecutor#newPromise() to create a new promise
setSuccess
setFailure
await
addListener
addListeners
awaitUninterruptibly
checkDeadLock
removeListener
removeListeners
sync
syncUninterruptibly

Popular in Java

Creating JSON documents from java classes using gson
requestLocationUpdates (LocationManager)
onRequestPermissionsResult (Fragment)
setRequestProperty (URLConnection)
Sets the general request property. If a property with the key already exists, overwrite its value wi
ArrayList (java.util)
ArrayList is an implementation of List, backed by an array. All optional operations including adding
BitSet (java.util)
The BitSet class implements abit array [http://en.wikipedia.org/wiki/Bit_array]. Each element is eit
Executor (java.util.concurrent)
An object that executes submitted Runnable tasks. This interface provides a way of decoupling task s
Reference (javax.naming)
JCheckBox (javax.swing)
Loader (org.hibernate.loader)
Abstract superclass of object loading (and querying) strategies. This class implements useful common

Best code snippets using io.netty.util.concurrent.DefaultPromise.notifyListener0(Showing top 15 results out of 315)