Refactored modules system

src/main/java/ru/windcorp/progressia/ProgressiaLauncher.java

@@ -31,7 +31,6 @@ public class ProgressiaLauncher {
 		arguments = args.clone();
 		setupCrashReports();
 		proxy.initialize();
-		TaskManager.getInstance().startLoading();
 	}
 
 	private static void setupCrashReports() {

src/main/java/ru/windcorp/progressia/client/ClientProxy.java

@@ -28,6 +28,7 @@ import ru.windcorp.progressia.client.graphics.font.Typefaces;
 import ru.windcorp.progressia.client.graphics.texture.Atlases;
 import ru.windcorp.progressia.client.graphics.world.WorldRenderProgram;
 import ru.windcorp.progressia.client.localization.Localizer;
+import ru.windcorp.progressia.common.modules.TaskManager;
 import ru.windcorp.progressia.common.resource.ResourceManager;
 import ru.windcorp.progressia.common.util.crash.CrashReports;
 import ru.windcorp.progressia.server.ServerState;
@@ -57,6 +58,8 @@ public class ClientProxy implements Proxy {
 		Atlases.loadAllAtlases();
 
 		AudioSystem.initialize();
+		TaskManager.getInstance().startLoading();
+
 
 		ServerState.startServer();
 		ClientState.connectToLocalServer();

src/main/java/ru/windcorp/progressia/client/audio/AudioSystem.java

@@ -18,15 +18,26 @@
  
 package ru.windcorp.progressia.client.audio;
 
+import ru.windcorp.progressia.common.modules.Module;
+import ru.windcorp.progressia.common.modules.Task;
+import ru.windcorp.progressia.common.modules.TaskManager;
 import ru.windcorp.progressia.common.resource.ResourceManager;
 
 public class AudioSystem {
 	static public void initialize() {
+		Module audioModule = new Module("AudioModule:System");
 		AudioManager.initAL();
 		Thread shutdownHook = new Thread(AudioManager::closeAL, "AL Shutdown Hook");
 		Runtime.getRuntime().addShutdownHook(shutdownHook);
+		Task t = new Task("Task:InitializeAudio") {
+			@Override
+			protected void perform() {
 				loadAudioData();
 			}
+		};
+		audioModule.addTask(t);
+		TaskManager.getInstance().registerModule(audioModule);
+	}
 
 	static void loadAudioData() {
 		AudioManager.loadSound(

src/main/java/ru/windcorp/progressia/common/modules/Module.java

@@ -9,9 +9,9 @@ import ru.windcorp.progressia.common.util.namespaces.Namespaced;
 
 public class Module extends Namespaced {
 
-	private List<Task> tasks = new ArrayList<>();
+	private final List<Task> tasks = new ArrayList<>();
-	private Map<String, String> meta = new HashMap<>();
+	private final Map<String, String> meta = new HashMap<>();
-	private boolean done = false;
+	private final boolean done = false;
 	
 	
 	public Module(String id) {

src/main/java/ru/windcorp/progressia/common/modules/ModuleBuilder.java

@@ -0,0 +1,14 @@
+package ru.windcorp.progressia.common.modules;
+
+public class ModuleBuilder {
+    private final Module module;
+
+    public ModuleBuilder(String id) {
+        module = new Module(id);
+    }
+
+    public ModuleBuilder AddTask(Task task) {
+        module.addTask(task);
+        return this;
+    }
+}

src/main/java/ru/windcorp/progressia/common/modules/Task.java

@@ -1,12 +1,10 @@
 package ru.windcorp.progressia.common.modules;
 
+import ru.windcorp.progressia.common.util.namespaces.Namespaced;
+
 import java.util.ArrayList;
 import java.util.List;
 
-import ru.windcorp.jputil.chars.StringUtil;
-import ru.windcorp.progressia.common.util.crash.CrashReports;
-import ru.windcorp.progressia.common.util.namespaces.Namespaced;
-
 public abstract class Task 
 	extends Namespaced
 	implements Runnable
@@ -23,24 +21,10 @@ public abstract class Task
 
 	@Override
 	public void run() {
-		if (!canRun()) {
-			
-			ArrayList<Task> undoneTasks = new ArrayList<>();
-			for (Task j : requiredTasks) {
-				if (!j.isDone()) {
-					undoneTasks.add(j);
-				}
-			}
-			
-			throw CrashReports.report(new Throwable(),
-					"The following required Tasks are not done:\n%s",
-					StringUtil.iterableToString(undoneTasks, "\n"));
-		} else {
 		isActive = true;
 		perform();
 		isDone = true;
 	}
-	}
 
 	// This method will be invoked by Run()
 	protected abstract void perform();

src/main/java/ru/windcorp/progressia/common/modules/TaskManager.java

@@ -1,100 +1,101 @@
 package ru.windcorp.progressia.common.modules;
 
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import ru.windcorp.progressia.common.state.StateFieldBuilder;
-import ru.windcorp.progressia.common.util.crash.CrashReports;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.concurrent.ExecutorService;
+import java.util.concurrent.*;
-import java.util.concurrent.Executors;
+
-import java.util.concurrent.ThreadFactory;
+import static java.util.concurrent.Executors.newFixedThreadPool;
-import java.util.concurrent.TimeUnit;
 
 public class TaskManager {
     private static final TaskManager instance = new TaskManager();
     private final List<Task> tasks = new ArrayList<>();
     private final List<Module> modules = new ArrayList<>();
-    private final ThreadFactory threadFactory = new ThreadFactoryBuilder()
+    private boolean loadingDone;
-            .setNameFormat("LogicCore-%d")
+    private int activeThreadsCount;
-            .build();
-    private boolean wakeUpFlag = false;
 
-    private TaskManager() {}
+    private  final ExecutorService executorService;
+
+    private TaskManager() {
+        loadingDone = false;
+        activeThreadsCount = 0;
+        executorService = newFixedThreadPool(
+                Runtime.getRuntime().availableProcessors(), Thread::new);
+    }
     
     public static TaskManager getInstance() {
         return instance;
     }
 
-    //Thread pool with size of logical cores of CPU
-    private final ExecutorService executorService =
-            Executors.newFixedThreadPool(
-                    Runtime.getRuntime().availableProcessors()
-                    , threadFactory);
-
     public void registerModule(Module module) {
         tasks.addAll(module.getTasks());
         modules.add(module);
     }
 
+    public boolean isLoadingDone() {
+        return loadingDone;
+    }
+
     public void startLoading() {
-        System.out.println("Loader is started");
+
-        for (int i = 0; i < Runtime.getRuntime().availableProcessors(); i++) {
+        for(int i = 0; i < Runtime.getRuntime().availableProcessors(); i++) {
             executorService.submit(() -> {
-                while (!tasks.isEmpty()) {
+                while(!loadingDone) {
                     Task t = getRunnableTask();
-                    if (t == null) {
+                    if (t != null) {
-                        while (!wakeUpFlag) {
+                        synchronized (this) {
+                            activeThreadsCount++;
+                        }
+                        t.run();
+                        synchronized (this) {
+                            activeThreadsCount--;
+                            notifyAll();
+                        }
+                    } else if (activeThreadsCount > 0) {
                         try {
-                                synchronized (tasks) {
+                            synchronized (this) {
-                                    tasks.wait();
+                                this.wait();
                             }
                         } catch (InterruptedException e) {
                             e.printStackTrace();
                         }
-                        }
+                    } else {
-                        wakeUpFlag = false;
+                        synchronized (this) {
-                    }
+                            loadingDone = true;
-                    else if (!t.isActive()) {
-                        t.run();
-                        removeTask(t);
-                        wakeUpFlag = true;
-                        synchronized (tasks) {
-                            tasks.notifyAll();
                         }
                     }
                 }
             });
         }
 
-        for (Module m : modules) {
+        waitForLoadingEnd();
-            if (!m.done()) {
+        executorService.shutdownNow();
-                throw CrashReports.crash(new Exception("Modules loading failed"),
-                        null);
-            }
-        }
-        while(true) {
-            try {
-                executorService.shutdown();
-                if (executorService.awaitTermination(5, TimeUnit.SECONDS)) break;
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-        };
-        System.out.println("Loader has completed its job");
     }
 
-    private void removeTask(Task task) {
+    public synchronized Task getRunnableTask() {
-        synchronized (tasks) {
+        if(!tasks.isEmpty()) {
-            tasks.remove(task);
+            for (Task t :
+                 tasks) {
+                if(t.canRun()) {
+                    tasks.remove(t);
+                    return t;
                 }
             }
-
-    public Task getRunnableTask() {
-        synchronized (tasks) {
-            for (Task t : tasks) {
-                if (t.canRun()) return t;
         }
         return null;
     }
+
+    private void waitForLoadingEnd() {
+        synchronized (this) {
+            while(!loadingDone) {
+                try {
+                    this.wait();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
                 }
+            }
+        }
+    }
+
 }