Windcorp/JavaProgressia
Windcorp/JavaProgressia
Archived
3
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

TaskManager bug fixes and code cleanup

Browse Source
This commit is contained in:
Евгений Смирнов 2021-07-07 17:02:38 +03:00
parent 5a06788652
commit f520d4b2c6
4 changed files with 120 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/main/java/ru/windcorp/progressia/client/audio/AudioSystem.java
View File

@ -18,6 +18,7 @@
package ru.windcorp.progressia.client.audio; package ru.windcorp.progressia.client.audio;
import org.apache.logging.log4j.LogManager;
import ru.windcorp.progressia.common.modules.Module; import ru.windcorp.progressia.common.modules.Module;
import ru.windcorp.progressia.common.modules.Task; import ru.windcorp.progressia.common.modules.Task;
import ru.windcorp.progressia.common.modules.TaskManager; import ru.windcorp.progressia.common.modules.TaskManager;
@ -29,10 +30,12 @@ public class AudioSystem {
AudioManager.initAL(); AudioManager.initAL();
Thread shutdownHook = new Thread(AudioManager::closeAL, "AL Shutdown Hook"); Thread shutdownHook = new Thread(AudioManager::closeAL, "AL Shutdown Hook");
Runtime.getRuntime().addShutdownHook(shutdownHook); Runtime.getRuntime().addShutdownHook(shutdownHook);
Task t = new Task("Task:InitializeAudio") {
Task t = new Task("AudioSystem:Initialize") {
@Override @Override
protected void perform() { protected void perform() {
loadAudioData(); loadAudioData();
LogManager.getLogger().info("Audio data is loaded");
} }
}; };
audioModule.addTask(t); audioModule.addTask(t);
@ -41,9 +44,9 @@ public class AudioSystem {
static void loadAudioData() { static void loadAudioData() {
AudioManager.loadSound( AudioManager.loadSound(
ResourceManager.getResource("assets/sounds/block_destroy_clap.ogg"), ResourceManager.getResource("assets/sounds/block_destroy_clap.ogg"),
"Progressia:BlockDestroy", "Progressia:BlockDestroy",
AudioFormat.MONO AudioFormat.MONO
); );
} }
} }

5
src/main/java/ru/windcorp/progressia/common/modules/Module.java
View File

@ -1,12 +1,12 @@
package ru.windcorp.progressia.common.modules; package ru.windcorp.progressia.common.modules;
import ru.windcorp.progressia.common.util.namespaces.Namespaced;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import ru.windcorp.progressia.common.util.namespaces.Namespaced;
public class Module extends Namespaced { public class Module extends Namespaced {
private final List<Task> tasks = new ArrayList<>(); private final List<Task> tasks = new ArrayList<>();
@ -25,6 +25,7 @@ public class Module extends Namespaced {
public List<Task> getTasks() { public List<Task> getTasks() {
return tasks; return tasks;
} }
public void addTask(Task task) { public void addTask(Task task) {
tasks.add(task); tasks.add(task);
} }

18
src/main/java/ru/windcorp/progressia/common/modules/Task.java
View File

@ -6,14 +6,12 @@ import java.util.ArrayList;
import java.util.List; import java.util.List;
public abstract class Task public abstract class Task
extends Namespaced extends Namespaced
implements Runnable implements Runnable {
{
private boolean isDone = false;
private boolean isActive = false;
List<Task> requiredTasks = new ArrayList<>(); List<Task> requiredTasks = new ArrayList<>();
private boolean isDone = false;
private boolean isActive = false;
protected Task(String id) { protected Task(String id) {
super(id); super(id);
@ -33,7 +31,9 @@ public abstract class Task
return isDone; return isDone;
} }
public boolean isActive() { return isActive; } public boolean isActive() {
return isActive;
}
public boolean canRun() { public boolean canRun() {
if (this.isActive) return false; if (this.isActive) return false;
@ -46,4 +46,8 @@ public abstract class Task
public List<Task> getRequiredTasks() { public List<Task> getRequiredTasks() {
return requiredTasks; return requiredTasks;
} }
public void addRequiredTask(Task task) {
requiredTasks.add(task);
}
} }

170
src/main/java/ru/windcorp/progressia/common/modules/TaskManager.java
View File

@ -1,101 +1,107 @@
package ru.windcorp.progressia.common.modules; package ru.windcorp.progressia.common.modules;
import ru.windcorp.progressia.common.state.StateFieldBuilder;
import org.apache.logging.log4j.LogManager;
import ru.windcorp.progressia.common.util.crash.CrashReports;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.concurrent.*; import java.util.concurrent.ExecutorService;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import static java.util.concurrent.Executors.newFixedThreadPool; import static java.util.concurrent.Executors.newFixedThreadPool;
public class TaskManager { public class TaskManager {
private static final TaskManager instance = new TaskManager(); private static final TaskManager instance = new TaskManager();
private final List<Task> tasks = new ArrayList<>(); private final List<Task> tasks = new ArrayList<>();
private final List<Module> modules = new ArrayList<>(); private final List<Module> modules = new ArrayList<>();
private boolean loadingDone; private final ExecutorService executorService;
private int activeThreadsCount; private final AtomicBoolean loadingDone;
private final AtomicInteger activeThreadsCount;
private final ExecutorService executorService; private TaskManager() {
loadingDone = new AtomicBoolean(false);
activeThreadsCount = new AtomicInteger(0);
executorService = newFixedThreadPool(
Runtime.getRuntime().availableProcessors(), Thread::new);
}
private TaskManager() { public static TaskManager getInstance() {
loadingDone = false; return instance;
activeThreadsCount = 0; }
executorService = newFixedThreadPool(
Runtime.getRuntime().availableProcessors(), Thread::new);
}
public static TaskManager getInstance() { public void registerModule(Module module) {
return instance; tasks.addAll(module.getTasks());
} modules.add(module);
}
public void registerModule(Module module) { public boolean isLoadingDone() {
tasks.addAll(module.getTasks()); return loadingDone.get();
modules.add(module); }
}
public boolean isLoadingDone() { public void startLoading() {
return loadingDone; LogManager.getLogger().info("Loading is started");
} for (int i = 0; i < Runtime.getRuntime().availableProcessors(); i++) {
executorService.submit(() -> {
while (!loadingDone.get()) {
Task t = getRunnableTask();
if (t != null) {
activeThreadsCount.incrementAndGet();
t.run();
activeThreadsCount.decrementAndGet();
synchronized (this) {
notifyAll();
}
} else if (activeThreadsCount.get() > 0) {
try {
synchronized (this) {
this.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
loadingDone.set(true);
synchronized (this) {
notifyAll();
}
}
}
});
}
public void startLoading() { waitForLoadingEnd();
if (!tasks.isEmpty()) {
throw CrashReports.crash(new Exception("Loading is failed"), "");
}
LogManager.getLogger().info("Loading is finished");
executorService.shutdownNow();
}
for(int i = 0; i < Runtime.getRuntime().availableProcessors(); i++) { public synchronized Task getRunnableTask() {
executorService.submit(() -> { if (!tasks.isEmpty()) {
while(!loadingDone) { for (Task t :
Task t = getRunnableTask(); tasks) {
if (t != null) { if (t.canRun()) {
synchronized (this) { tasks.remove(t);
activeThreadsCount++; return t;
} }
t.run(); }
synchronized (this) { }
activeThreadsCount--; return null;
notifyAll(); }
}
} else if (activeThreadsCount > 0) {
try {
synchronized (this) {
this.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
synchronized (this) {
loadingDone = true;
}
}
}
});
}
waitForLoadingEnd(); private void waitForLoadingEnd() {
executorService.shutdownNow(); synchronized (this) {
} while (!loadingDone.get()) {
try {
public synchronized Task getRunnableTask() { this.wait();
if(!tasks.isEmpty()) { } catch (InterruptedException e) {
for (Task t : e.printStackTrace();
tasks) { }
if(t.canRun()) { }
tasks.remove(t); }
return t; }
}
}
}
return null;
}
private void waitForLoadingEnd() {
synchronized (this) {
while(!loadingDone) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
} }