Реализована возможность удобного тестирования

gradlew.bat

@@ -22,7 +22,7 @@
 @rem ##########################################################################
 
 @rem Set local scope for the variables with windows NT shell
-if "%OrtOS%"=="Windows_NT" setlocal
+if "%OS.OrtOS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
 if "%DIRNAME%" == "" set DIRNAME=.
@@ -84,6 +84,6 @@ if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
 exit /b 1
 
 :mainEnd
-if "%OrtOS%"=="Windows_NT" endlocal
+if "%OS.OrtOS%"=="Windows_NT" endlocal
 
 :omega

src/main/java/EventGenerators/CustomGenerator.java

@@ -0,0 +1,24 @@
+package EventGenerators;
+
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+
+public class CustomGenerator extends EventGenerator {
+    public CustomGenerator(Consumer<OsEvent> eventConsumer) {
+        // Тест на обработку прерываний:
+        // Ждём 1 секунду, пока выполнится начальная задача в ОС.
+        // Затем объявляем задачу с приоритетом 5. Ждём 200 мс.
+        // Объявляем задачу с высшим приоритетом и ожидаем, что она вытеснит предыдущую.
+        super(
+                Stream.of(
+                        1000L,
+                        200L
+                ).iterator(),
+                Stream.of(
+                        OsEvent.declareTaskEvent(123, 5),
+                        OsEvent.declareTaskEvent(1234, 10)
+                ).iterator(),
+                eventConsumer
+        );
+    }
+}

src/main/java/EventGenerators/EventGenerator.java

@@ -0,0 +1,83 @@
+package EventGenerators;
+
+import Resources.Resource;
+
+import java.util.Iterator;
+import java.util.function.Consumer;
+
+public class EventGenerator extends Thread {
+
+    public static class OsEvent {
+        public final EventType eventType;
+        public final Integer taskId;
+        public final Integer taskPriority;
+        public final Integer resourceId;
+        public final Integer globalResourceIndex;
+
+        private OsEvent(EventType eventType, Integer taskId, Integer taskPriority, Integer resourceId, Integer globalResourceIndex) {
+            this.eventType = eventType;
+            this.taskId = taskId;
+            this.taskPriority = taskPriority;
+            this.resourceId = resourceId;
+            this.globalResourceIndex = globalResourceIndex;
+        }
+
+        public static OsEvent declareTaskEvent(final int taskId, final int taskPriority) {
+            return new OsEvent(EventType.declareTask, taskId, taskPriority, null, null);
+        }
+
+        public static OsEvent declareResourceEvent(final int resourceId) {
+            return new OsEvent(EventType.declareResource, null, null, resourceId, null);
+        }
+
+        public static OsEvent getGlobalResource(final int globalResourceIndex) {
+            return new OsEvent(EventType.getRecourse, null, null, null, globalResourceIndex);
+        }
+    }
+
+    public enum EventType {
+        // добавь задачу в очередь
+        declareTask,
+        // создай ресурс внутри текущей задачи
+        declareResource,
+        // выдай рандомный ресурс текущей задаче (не может быть выдана локальная переменная!)
+        getRecourse,
+    }
+
+    final Consumer<OsEvent> eventConsumer;
+    final Iterator<Long> sleepGenerator;
+    final Iterator<OsEvent> typeGenerator;
+
+    public EventGenerator(
+            final Iterator<Long> sleepIterator,
+            final Iterator<OsEvent> eventIterator,
+            final Consumer<OsEvent> eventConsumer
+    ) {
+        this.sleepGenerator = sleepIterator;
+        this.typeGenerator = eventIterator;
+        this.eventConsumer = eventConsumer;
+        this.setName("OS");
+    }
+
+    @Override
+    public void run() {
+        while (true) {
+            if (isInterrupted()) {
+                break;
+            }
+            try {
+                if (!sleepGenerator.hasNext()) {
+                    return;
+                }
+                sleep(sleepGenerator.next());
+            } catch (final InterruptedException e) {
+                break;
+            }
+            if (!typeGenerator.hasNext()) {
+                return;
+            }
+            final OsEvent randomEvent = typeGenerator.next();
+            eventConsumer.accept(randomEvent);
+        }
+    }
+}

src/main/java/EventGenerators/InfinityEventGenerator.java

@@ -0,0 +1,50 @@
+package EventGenerators;
+
+import OS.OrtOS;
+
+import java.util.Iterator;
+import java.util.Random;
+import java.util.function.Consumer;
+
+public class InfinityEventGenerator extends EventGenerator {
+
+    private static final Random RANDOM = new Random(1L);
+
+    public InfinityEventGenerator(final Consumer<OsEvent> eventConsumer) {
+        super(
+                new Iterator<>() {
+                    @Override
+                    public boolean hasNext() {
+                        return true;
+                    }
+
+                    @Override
+                    public Long next() {
+                        return RANDOM.nextInt(100) + 100L;
+                    }
+                },
+                new Iterator<>() {
+                    @Override
+                    public boolean hasNext() {
+                        return true;
+                    }
+
+                    @Override
+                    public OsEvent next() {
+                        final EventType eventType = EventType.values()[RANDOM.nextInt(EventGenerator.EventType.values().length)];
+                        switch (eventType) {
+                            case declareTask:
+                                return OsEvent.declareTaskEvent(RANDOM.nextInt(), RANDOM.nextInt(MAX_PRIORITY));
+                            case declareResource:
+                                return OsEvent.declareResourceEvent(RANDOM.nextInt());
+                            case getRecourse:
+                                return OsEvent.getGlobalResource(RANDOM.nextInt(OrtOS.GLOBAL_RESOURCES_COUNT));
+                            default:
+                                throw new IllegalStateException("Неизвестный тип события: " + eventType);
+                        }
+                    }
+                },
+                eventConsumer
+        );
+    }
+}

src/main/java/Main.java

@@ -1,66 +1,25 @@
+import EventGenerators.CustomGenerator;
+import EventGenerators.InfinityEventGenerator;
+import OS.OrtOS;
+import Tasks.Task;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
+import static OS.OrtOS.MAX_PRIORITY;
 
 public class Main {
 
-    static final Random RANDOM = new Random(0L);
-    static final int MAX_PRIORITY = 10;
-
     private static final Logger log = LoggerFactory.getLogger(Main.class);
 
-    private static final int GLOBAL_RESOURCES_COUNT = 4;
-    private static final List<Resource> globalResources = new ArrayList<>(GLOBAL_RESOURCES_COUNT);
-
     public static void main(String[] args) {
         final OrtOS ortOs = new OrtOS();
-
-        final Thread eventsGenerator = new EventGenerator((eventType) -> {
-            switch (eventType) {
-                case declareTask:
-                    log.debug("Событие: создание новой задачи.");
-                    ortOs.declareTask(
-                            RANDOM.nextInt(),
-                            RANDOM.nextInt(MAX_PRIORITY)
-                    );
-                    break;
-                case declareResource:
-                    ortOs.withCurrentTask((task) -> {
-                        log.debug("Событие: создание локального ресурса.");
-                        final Resource resource = ortOs.declareResource(RANDOM.nextInt(), true);
-                        ortOs.getResource(resource);
-                    });
-                    break;
-                case getRecourse:
-                    ortOs.withCurrentTask((task) -> {
-                        log.debug("Событие: попытка захвата глобального ресурса.");
-                        ortOs.getResource(globalResources.get(RANDOM.nextInt(GLOBAL_RESOURCES_COUNT) ));
-                    });
-                    break;
-                default:
-                    throw new IllegalStateException("Событие: генератор вышел из чата.");
-            }
-        }
-        );
-
-        final Task taskToStart = new Task(
-                666,
-                MAX_PRIORITY,
-                ortOs
-        );
-
+        final Thread eventsGenerator = new InfinityEventGenerator(ortOs::interpretEvent);
+//        final Thread eventsGenerator = new CustomGenerator(ortOs::interpretEvent);
+        final Task taskToStart = new Task(0, MAX_PRIORITY, ortOs);
         try {
-            for (int i = 0; i < 4; ++i) {
-                globalResources.add(ortOs.declareResource(RANDOM.nextInt(), false));
-            }
             ortOs.startOS(taskToStart);
-            // Объявляем 4 глобальных ресурса. Задачи могут запрашивать к ним доступ или создавать свои ЛОКАЛЬНЫЕ переменные.
-            // Локальные переменные удаляются после вызова releaseResource().
             eventsGenerator.start();
-            Thread.sleep(10000);
+            Thread.sleep(5000);
         } catch (final InterruptedException e) {
             e.printStackTrace();
         } finally {

src/main/java/Dispatcher.java → src/main/java/OS/Dispatcher.java

@@ -1,23 +1,26 @@
+package OS;
+
+import Tasks.Task;
+import Tasks.TaskPriorityQueue;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Queue;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Consumer;
 
 public class Dispatcher extends Thread {
 
-    final TaskPriorityQueue taskQueue;
-    final Consumer<Task> currentTaskCallback;
+    public final TaskPriorityQueue taskQueue;
+    public final Consumer<Task> currentTaskCallback;
 
     private static final Logger log = LoggerFactory.getLogger(Dispatcher.class);
 
     private final AtomicBoolean isFree = new AtomicBoolean(true);
 
     public Dispatcher(final TaskPriorityQueue taskQueue, final Consumer<Task> currentTaskCallback) {
-        this.setName("Dispatcher");
+        this.setName("OS.Dispatcher");
         this.taskQueue = taskQueue;
         this.currentTaskCallback = currentTaskCallback;
         log.debug("Диспетчер готов к работе!");