Question

I would like to simulate a distributed system and how machines do their works, the topology adopted is a centralized one, I have many little systems in which each sub systems adopts this topology, I mean I suppose that my distributed system constitutes of many centralized systems.
I have created a simple discrete event simulator, which simulates the work in side One centralized system, the code is like:

public class SimuleOnesystem { 
// a set of parameters
class Arrival{// here we simulate the arrival of works to a server
 // the code..
}
class Service{// here we simulate the services  }
class Departure{// means that the work is well done
 }
}

My question is, how could I multithreaded this code, I mean I would like to execute for example 5 Centralized systems at the same time in which each system has its own simulation clock, eventList and so on, and these systems can communicate between each other in term of sending and receiving request and executing jobs etc…

Thanks in advance.

Answer 1

Besides the introduction of threads, as already pointed out in the other answers, your comment to ring bearer’s answer is true: you have to take care of the event list and the simulation clock.

As far as I can see it, your example is a fairly typical discrete-event simulation. Trying to parallelize those, even just across threads, i.e. in a single address space (executed by the same JVM on a single machine, which may have multiple cores etc.), is not quite trivial. I would suggest you start with reading some introductory material on the matter (I would recommend this book).

Your basic problem is that you cannot prevent some threads of executing faster than others (e.g. because they have to handle less load), and hence their local clocks may advance into the simulated ‘future’. If one of the other threads, i.e. a thread that is lagging behind, now issues a new event/message that would have to be processed by one thread that is advanced too far in time, everything will break (or fail quietly and be invalid). Think of opening your mailbox today and receiving a message from last year, to which you also should have responded immediately…

Algorithms that prevent such situations from happening are called synchronization algorithms. There are basically two flavors of those: optimistic methods allows such straggler events (messages from the past) to happen, but detect them and clean up any inconsistencies if necessary. In your case, though, it seems advisable to look at conservative algorithms first, which avoid such methods altogether. They are (usually) easier to implement, but only work well if there are certain delays between the sender of an event and the time the event has to be executed (e.g. see this classical paper for details, or this more recent one detailing a Java-based simulation system that uses conservative synchronization).
If you have a synchronization algorithm in place, it will also manage your local simulation time clocks.

As implementing these algorithms is rather time-consuming, you may also consider to use some Java-based simulation framework or library that already provides the methods (it’s a well-known problem).