Incrementing time in a discrete-event simulation of a supermarket queue
if (probK &lt;= prob) { // increment k until cumulative probability, prob, reached
             k++;
             prob -= probK;
          } else {
             break;
          }



With this pattern, it's often better to write 

          if (probK &gt; prob) {
              break;
          }

          k++;
          prob -= probK;


This saves some indent and makes it clear what is happening.  We check for the end condition and then proceed normally if it was not reached.  The other way, it's not obvious what the end condition is, since it is hidden in an else.  

But I would actually rewrite the whole loop.  

      int k = 0;
      for (double probabilityOfK = Math.exp(-lambda);
              probabilityOfK &lt;= targetProbability; 
              probabilityOfK *= lambda / k) {
          targetProbability -= probabilityOfK;
          k++;
      }


The for loop declaration is on three lines to eliminate side scroll on this site.  It might fit on one line in actual code.  

I prefer probabilityOfK to probK as being more readable.  I prefer targetProbablity to prob as being more descriptive.  

I stopped using Math.pow as a rather expensive calculation.  It is replaced with a simple multiplication.  And you were multiplying anyway, so that's effectively free.  

Now it doesn't use a loop forever pattern with a break.  It just loops normally until the condition fails.  

This works because you never use cumulativeProbability outside the loop, but each value relates to the previous one.  

The result may change slightly due to double rounding.  It's up to you if that matters.  And if it does matter, if the original was better.  


    for (int i = 0; i &lt; lines.length; i++) {



I would do this with a range-based for loop.  Something like 

    for (Queue&lt;?&gt; line : lines) {


Then you could replace all the lines[i] with just line.  Replace Queue&lt;?&gt; as necessary.  


       while (!lines[i].isEmpty() &amp;&amp; k &gt; 0) {



Consider something like 

        if (k &gt;= line.size()) {
            line.clear();
            continue;
        }

        while (k &gt; 0) {


Now you don't have to check if line is empty, as you'll run out of k before you run out of line.  

You could move that check into the previous loop.  Then if you reach the maximum possible k, you can stop immediately rather than continuing.  That might be more efficient.  Something like 

        for (Queue&lt;?&gt; line : lines) {
            if (line.isEmpty()) {
                continue;
            }

            updateLine(line);
        }


and 

    public void updateLine(Queue&lt;?&gt; line) {
        int k = 0;
        for (double probabilityOfK = Math.exp(-lambda);
                probabilityOfK &lt;= targetProbability; 
                probabilityOfK *= lambda / k) {

            targetProbability -= probabilityOfK;
            k++;

            if (k &gt;= line.size()) {
                line.clear();
                return;
            }
        }

        while (k &gt; 0) {
            line.decrement();
            k--;
        }
    }