Btukfyl

Theoretical construct:

I have a very big lounge there are working about 64 baristi (Threads).

There are comming about 1000 customers at once to get a coffee .

The customers are germans so they stay in 64 chains in front of 64 baristi.

Every baristi will have about 15-16 customers in his queue.

The baristi are very fast, the fastest is about 10ms fast, and the slowest is a maximum of 50ms fast.

Every barista work by first-in-first-out.

I simulate this in a Program and its a Unit-Test.

public class MassiveWorkTest {



    private int timeFac = 10;

    private int worksFinished = 0;

    private boolean endCalled = false;



    public void testBarista() {

        byte baristi = (byte) 64;

        BaristiQueuePool b = new BaristiQueuePool(baristi, "TestBarista", new Runnable() {



            @Override

            public void run() {

                endCalled = true;

            }

        });

        Random r = new SecureRandom();

        long theoreticalWorkTime = 0;

        for (int i = 0; i < 10000; i++) {

            final int time = 10+r.nextInt(40);

            theoreticalWorkTime += time;

            b.execute(new Runnable() {

                @Override

                public void run() {

                    try {

                        Thread.currentThread().sleep(time);

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

            });

        }

        theoreticalWorkTime /= baristi;



        long theoreticalOverallTime = theoreticalWorkTime + theoreticalWorkTime / 5;

        assert b.awaitTermination((int) theoreticalOverallTime, TimeUnit.MILLISECONDS);

        assert endCalled;

        assert worksFinished == 0;

    }

}

Now, my computer is pretty fast, but others might not. I increase the timeout by 20%.

Sometimes 20% is not enough and the test fails. This is bad because someone can not build.

How to calculate the perfect not-working-time of the baristi?