Имитация сбоя потока в Java

Question

Я работаю над чем-то, как часть задания колледжа, часть того, о чем меня просят, - это симуляция сбоев потоков. для контекста, я использую службу executor из Java SE

Я немного осмотрел SO и Google, но так и не смог найти что-то конкретное или конкретное в этом.

Кто-нибудь знает или имеет какие-либо хорошие источники для информации или руководства о том, как подходить к этому?

Answer 1

Если вы хотите проверить, как потоки "терпят неудачу", когда они сталкиваются с исключением, вы можете реализовать Runnable который вы можете дать команду на провал:

public class FailingRunnable implements Runnable {

    private volatile boolean doFail = false;

    @Override
    public void run() {
        while(!doFail && ! Thread.interrupted())
        {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        throw new RuntimeException("failed");
    }

    public void failOnNextOccasion() {
        doFail = true;
    }

}

Вы должны сохранить ссылку на исполняемый файл после добавления его к исполнителю, а затем в любой момент вызвать метод failOnNextOccasion() вашего работоспособного. Как это:

    ExecutorService execSrv = Executors.newFixedThreadPool(2);

    FailingRunnable one = new FailingRunnable();
    FailingRunnable two = new FailingRunnable();

    execSrv.submit(one);
    execSrv.submit(two);

    try {
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        e.printStackTrace();
        Thread.currentThread().interrupt();
    }

    one.failOnNextOccasion();
    two.failOnNextOccasion();

Answer 2

Немного более сложный поток с ошибкой, не столь очевидной:

public class Test {

  static class FailerThread implements Runnable {

    final Object[] objects;
    final Random random;
    final int number;

    public FailerThread(final Object[] objects, final int number) {
      this.objects = objects;
      this.random = new Random();
      this.number = number;
    }

    @Override
    public void run() {
      final boolean isWriter = number % 2 == 0;
      int index = random.nextInt(objects.length);
      try {
        while (Thread.interrupted() == false) {
          synchronized (objects) {
            if (isWriter) {
              while (objects[index] == null) {
                System.out.println(number + ": Index " + index + " is null, waiting...");
                objects.wait();
              }
              for (int copyIndex = 0; copyIndex < objects.length; ++copyIndex) {
                if (objects[copyIndex] == null) {
                  objects[copyIndex] = this.objects[index];
                }
              }
              objects.notifyAll();
            } else {
              objects[index] = null;
            }
          }

          ++index;
          if (index >= objects.length) {
            index = 0;
          }
        }
      } catch (InterruptedException e) {
      }
    }
  }

  public static void main(String[] args) throws InterruptedException {
    final Object[] objects = new Object[10];
    for (int i = 0; i < objects.length; ++i) {
      objects[i] = new Object();
    }

    final int NUM_THREADS = 32;
    final ExecutorService executor = Executors.newFixedThreadPool(NUM_THREADS);
    for (int i = 0; i < NUM_THREADS; ++i) {
      executor.execute(new FailerThread(objects, i));
    }
  }
}

Это должно немедленно потерпеть неудачу, однако причина этого - совсем не тривиальная.