Great questions—event scheduling in AnyLogic can be tricky when default behavior doesn't align with your needs, so let's break this down clearly:

Can You Manually Schedule Events in AnyLogic? #

Absolutely. AnyLogic provides several ways to take full control over when and how events execute:

• Scheduling functions: Use scheduleEvent(), scheduleEventIn(), or scheduleEventAt() to trigger custom actions at specific times. The key here is you can assign a priority parameter to dictate execution order when multiple events are set to run at the same time. For example:

  // Schedule an event to run 1.5 time units from now with priority 3 (higher = runs earlier)
  scheduleEvent( () -> {
      executeCriticalTask();
  }, time() + 1.5, 3 );
  

• Event objects: Drag an Event from the Palette into your model, then configure its trigger time dynamically (e.g., time() + processDelay) and set its priority in the properties panel. You can manually start it with myEvent.start() or cancel it with myEvent.cancel() if needed.

This lets you completely bypass the default implicit event order and define exactly the sequence you need.

Does Model Creation Order Affect Event Scheduling? #

Yes, but only in edge cases: when multiple events are scheduled for the same time and have the same priority. AnyLogic resolves these ties using the order in which the events (or the objects that contain them) were added to the model. The event created earlier will run first.

If you want to avoid relying on creation order, just assign different priorities to your events. Higher priority values mean the event executes first, regardless of when you added it to the model. This is almost always a cleaner solution than rearranging your model objects just to fix execution order.

How Valid Is Your Proposed Solution? #

Your plan to use a FIFO mechanism, state charts with guard conditions, and manual time parameters is totally feasible—here's a breakdown of its strengths and possible optimizations:

• State charts with guards: This is a robust way to enforce sequential execution when actions depend on prior steps finishing. Guards that check if all prerequisite operations are complete ensure your workflow only moves forward when it's ready—this is perfect for dependency-driven sequencing.
• Manual time parameters: Controlling time manually works for highly controlled scenarios, but it might limit flexibility if you later need to simulate variable or dynamic timing. Consider combining this with scheduled events that use dynamic time calculations (like time() + randomNormal(2,0.5)) instead of fixed values, if your use case allows.
• FIFO mechanism: Managing a FIFO queue of actions can work, but AnyLogic's built-in event priorities might simplify this. Instead of maintaining a queue manually, you can schedule events with consistent priorities (or incrementing ones) to ensure they run in the order you intend.

A hybrid approach could be even more effective: use state charts to manage high-level workflow stages, and within each stage, use manually scheduled events with explicit priorities to control the order of individual actions. This combines the clarity of state charts with the precision of manual event scheduling.

内容的提问来源于stack exchange，提问作者Altuwariki