Параллельный поток, не позволяющий мне исключать [duplicate]

Вы можете обернуть и развернуть исключения таким образом.

class A {
    void foo() throws Exception {
        throw new Exception();
    }
};

interface Task {
    void run() throws Exception;
}

static class TaskException extends RuntimeException {
    private static final long serialVersionUID = 1L;
    public TaskException(Exception e) {
        super(e);
    }
}

void bar() throws Exception {
      Stream<A> as = Stream.generate(()->new A());
      try {
        as.forEach(a -> wrapException(() -> a.foo())); // or a::foo instead of () -> a.foo()
    } catch (TaskException e) {
        throw (Exception)e.getCause();
    }
}

static void wrapException(Task task) {
    try {
        task.run();
    } catch (Exception e) {
        throw new TaskException(e);
    }
}

Этот вопрос может быть немного старым, но поскольку я думаю, что «правильный» ответ здесь - это только один способ, который может привести к некоторым проблемам, скрытым в дальнейшем в вашем коде. Даже если есть небольшая споры , по каким-то причинам существуют проверенные исключения.

Самый элегантный способ, на мой взгляд, вы можете найти здесь, здесь Миша . Агрегатные исключения времени выполнения в Java 8 потоках , просто выполнив действия в «фьючерсах». Таким образом, вы можете запускать все рабочие части и собирать неработающие Исключения как один. В противном случае вы можете собрать их все в списке и обработать их позже.

Аналогичный подход исходит из Benji Weber . Он предлагает создать собственный тип для сбора рабочих и нерабочих частей.

В зависимости от того, что вы действительно хотите достичь простого сопоставления между входными значениями и выходными значениями, произошли исключения. Исключения могут также работать для вас.

Если вам не нравится какой-либо из этих способов, рассмотрите возможность использования (в зависимости от Исходного Исключения) как минимум собственного исключения.

Я предлагаю использовать класс Google Guava Throwables

распространять (Throwable throwable)

Распространяет throwable as-is, если это экземпляр из RuntimeException или Error, или в качестве последнего средства, обертывает его в RuntimeException и затем распространяется. **

void bar() {
    Stream<A> as = ...
    as.forEach(a -> {
        try {
            a.foo()
        } catch(Exception e) {
            throw Throwables.propagate(e);
        }
    });
}

Более читаемый способ:

class A {
  void foo() throws MyException() {
    ...
  }
}

Просто спрячьте его в RuntimeException, чтобы пройти его forEach()

  void bar() throws MyException {
      Stream<A> as = ...
      try {
          as.forEach(a -> {
              try {
                  a.foo();
              } catch(MyException e) {
                  throw new RuntimeException(e);
              }
          });
      } catch(RuntimeException e) {
          throw (MyException) e.getCause();
      }
  }

Хотя на данный момент я не буду держитесь против кого-то, если они говорят, что пропускают потоки и идут с циклом for, если:

• вы не создаете свой поток, используя Collection.stream(), т. е. не прямолинейный перевод в цикл for.
• вы пытаетесь использовать parallelstream()

Возможно, вы захотите выполнить одно из следующих действий:

• распространить проверенное исключение,
• обернуть его и развернуть исключенное исключение или
• catch распространение исключений и остановок.

Несколько библиотек позволяют делать это легко. Пример ниже написан с использованием библиотеки NoException .

// Propagate checked exception
as.forEach(Exceptions.sneak().consumer(A::foo));

// Wrap and propagate unchecked exception
as.forEach(Exceptions.wrap().consumer(A::foo));
as.forEach(Exceptions.wrap(MyUncheckedException::new).consumer(A::foo));

// Catch the exception and stop propagation (using logging handler for example)
as.forEach(Exceptions.log().consumer(Exceptions.sneak().consumer(A::foo)));