How to use

org.glassfish.grizzly.nio.DefaultSelectorHandler$RunnableTask

constructor

@Override
public void enque(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  
  if (isSelectorRunnerThread(selectorRunner)) {
    // If this is Selector thread - put the task to postponed queue
    // it's faster than using pending task queue, which is thread-safe
    final Queue<SelectorHandlerTask> postponedTasks =
        selectorRunner.getPostponedTasks();
    postponedTasks.offer(new RunnableTask(task, completionHandler));
    
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void enque(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  
  if (isSelectorRunnerThread(selectorRunner)) {
    // If this is Selector thread - put the task to postponed queue
    // it's faster than using pending task queue, which is thread-safe
    final Queue<SelectorHandlerTask> postponedTasks =
        selectorRunner.getPostponedTasks();
    postponedTasks.offer(new RunnableTask(task, completionHandler));
    
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void enque(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  
  if (isSelectorRunnerThread(selectorRunner)) {
    // If this is Selector thread - put the task to postponed queue
    // it's faster than using pending task queue, which is thread-safe
    final Queue<SelectorHandlerTask> postponedTasks =
        selectorRunner.getPostponedTasks();
    postponedTasks.offer(new RunnableTask(task, completionHandler));
    
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void execute(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  if (isSelectorRunnerThread(selectorRunner)) {
    try {
      task.run();
      if (completionHandler != null) {
        completionHandler.completed(task);
      }
    } catch (Exception e) {
      if (completionHandler != null) {
        completionHandler.failed(e);
      }
    }            
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void execute(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  if (isSelectorRunnerThread(selectorRunner)) {
    try {
      task.run();
      if (completionHandler != null) {
        completionHandler.completed(task);
      }
    } catch (Exception e) {
      if (completionHandler != null) {
        completionHandler.failed(e);
      }
    }            
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void execute(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  if (isSelectorRunnerThread(selectorRunner)) {
    try {
      task.run();
      if (completionHandler != null) {
        completionHandler.completed(task);
      }
    } catch (Exception e) {
      if (completionHandler != null) {
        completionHandler.failed(e);
      }
    }            
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void execute(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  if (isSelectorRunnerThread(selectorRunner)) {
    try {
      task.run();
      if (completionHandler != null) {
        completionHandler.completed(task);
      }
    } catch (Exception e) {
      if (completionHandler != null) {
        completionHandler.failed(e);
      }
    }            
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void execute(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  if (isSelectorRunnerThread(selectorRunner)) {
    try {
      task.run();
      if (completionHandler != null) {
        completionHandler.completed(task);
      }
    } catch (Exception e) {
      if (completionHandler != null) {
        completionHandler.failed(e);
      }
    }            
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void execute(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  if (isSelectorRunnerThread(selectorRunner)) {
    try {
      task.run();
      if (completionHandler != null) {
        completionHandler.completed(task);
      }
    } catch (Exception e) {
      if (completionHandler != null) {
        completionHandler.failed(e);
      }
    }            
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void execute(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  if (isSelectorRunnerThread(selectorRunner)) {
    try {
      task.run();
      if (completionHandler != null) {
        completionHandler.completed(task);
      }
    } catch (Exception e) {
      if (completionHandler != null) {
        completionHandler.failed(e);
      }
    }            
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void execute(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  if (isSelectorRunnerThread(selectorRunner)) {
    try {
      task.run();
      if (completionHandler != null) {
        completionHandler.completed(task);
      }
    } catch (Exception e) {
      if (completionHandler != null) {
        completionHandler.failed(e);
      }
    }            
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void enque(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  
  if (isSelectorRunnerThread(selectorRunner)) {
    // If this is Selector thread - put the task to postponed queue
    // it's faster than using pending task queue, which is thread-safe
    final Queue<SelectorHandlerTask> postponedTasks =
        selectorRunner.getPostponedTasks();
    postponedTasks.offer(new RunnableTask(task, completionHandler));
    
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void enque(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  
  if (isSelectorRunnerThread(selectorRunner)) {
    // If this is Selector thread - put the task to postponed queue
    // it's faster than using pending task queue, which is thread-safe
    final Queue<SelectorHandlerTask> postponedTasks =
        selectorRunner.getPostponedTasks();
    postponedTasks.offer(new RunnableTask(task, completionHandler));
    
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void enque(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  
  if (isSelectorRunnerThread(selectorRunner)) {
    // If this is Selector thread - put the task to postponed queue
    // it's faster than using pending task queue, which is thread-safe
    final Queue<SelectorHandlerTask> postponedTasks =
        selectorRunner.getPostponedTasks();
    postponedTasks.offer(new RunnableTask(task, completionHandler));
    
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void enque(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  
  if (isSelectorRunnerThread(selectorRunner)) {
    // If this is Selector thread - put the task to postponed queue
    // it's faster than using pending task queue, which is thread-safe
    final Queue<SelectorHandlerTask> postponedTasks =
        selectorRunner.getPostponedTasks();
    postponedTasks.offer(new RunnableTask(task, completionHandler));
    
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void enque(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  
  if (isSelectorRunnerThread(selectorRunner)) {
    // If this is Selector thread - put the task to postponed queue
    // it's faster than using pending task queue, which is thread-safe
    final Queue<SelectorHandlerTask> postponedTasks =
        selectorRunner.getPostponedTasks();
    postponedTasks.offer(new RunnableTask(task, completionHandler));
    
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void enque(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  
  if (isSelectorRunnerThread(selectorRunner)) {
    // If this is Selector thread - put the task to postponed queue
    // it's faster than using pending task queue, which is thread-safe
    final Queue<SelectorHandlerTask> postponedTasks =
        selectorRunner.getPostponedTasks();
    postponedTasks.offer(new RunnableTask(task, completionHandler));
    
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void enque(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  
  if (isSelectorRunnerThread(selectorRunner)) {
    // If this is Selector thread - put the task to postponed queue
    // it's faster than using pending task queue, which is thread-safe
    final Queue<SelectorHandlerTask> postponedTasks =
        selectorRunner.getPostponedTasks();
    postponedTasks.offer(new RunnableTask(task, completionHandler));
    
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void enque(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  
  if (isSelectorRunnerThread(selectorRunner)) {
    // If this is Selector thread - put the task to postponed queue
    // it's faster than using pending task queue, which is thread-safe
    final Queue<SelectorHandlerTask> postponedTasks =
        selectorRunner.getPostponedTasks();
    postponedTasks.offer(new RunnableTask(task, completionHandler));
    
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}

@Override
public void enque(
    final SelectorRunner selectorRunner, final Task task,
    final CompletionHandler<Task> completionHandler) {
  
  if (isSelectorRunnerThread(selectorRunner)) {
    // If this is Selector thread - put the task to postponed queue
    // it's faster than using pending task queue, which is thread-safe
    final Queue<SelectorHandlerTask> postponedTasks =
        selectorRunner.getPostponedTasks();
    postponedTasks.offer(new RunnableTask(task, completionHandler));
    
  } else {
    addPendingTask(selectorRunner, new RunnableTask(task,
        completionHandler));
  }
}