暂停/恢复线程中的任意计算

Question

I'm making a programming game where the player can program their allies' behavior. The player writes the body of the decide() function for a given ally, which can be filled out with any java code but has to return an action. I would like to give each ally a set, restricted amount of computation per tick so 1) adding more entities doesn't slow down the game too much, and 2) The time an entity spends computing is reflected in game, so if an ally spends more time "thinking" it will act less often. My inspiration for how this should work is Battlecode , which gives units a set amount of bytecode per turn, then just pauses the computation and makes the programmer deal with noticing when things have changed.

My question is how I can pause and resume an entity which is executing the decision function in a thread. I understand the 'proper' way to do this is to set a flag telling the thread to pause and have it check occasionally, but since I can't force the player to check for a flag within the decide() function, I'm not sure how to pause the thread. The entities are only looking at a fixed representation of the world and just have to return an enum value, so I don't think they should have locks on anything, but I'm hoping there's a better way to do this than using the deprecated thread pausing methods. I'm open to changing how the player has to write code, but I can't think of a way to do it while still hiding the pause flag checks from the user without making writing the decision loop confusing and onerous. There must be some way to do this, since Battlecode does it, but I'm at a loss searching online for details as to how.

Answer 1

If you want to 'pause' the current thread, java.util.concurrent.locks.LockSupport may helps you. If you want to pause other threads, I thinks it's not in the scope of java design, you can only interrupt another thread, or set a flag, not pause.

Answer 2

You can't "pause a thread", and you can't expect players to abide by your request to "play nice" and check for flags etc. You can interrupt another thread, but the code running in the thread can easily recover from this. So, you need a way for the controlling thread to retain control.

Instead of worrying about what threads are doing, you could:

• give the player threads a maximum time to return the action, and if they don't return in time, execute a "default action"
• keep a record of how much time they spent calculating and call them more often is they use less time etc

Most of these types of concerns are catered for by java.util.concurrent library. Check out:

• ExecutorService
• Executors for creating handy instances of ExecutorService
• Callable for what the players will implement
• Future for getting the result, especially Future.get(timeout) for limiting the time the thread has to return a result