Question

This is a general question. Suppose server has a concurrency issue. Client can send multiple requests at the same time to trigger the issue. Then how to make the issue happen more frequently?

1. Client need to be fast enough to send more request at the same time

2. Server need to be fast enough

Will they help recreate the issue? Or whether it is the other way around? Server need to be slow?

EDIT 1:
I think it is a race conditions concurrency issue. Multiple thread using the same object but that object is not thread safe.

My main concern is suppose we have a client that send some amount of request per second, would is be easier to recreate the issue with faster server or slower server?

Answer 1

If you are talking about lock contention concurrency issues then I would say fast (or multiple) clients and a slow server. The more time spent in the locks the better.

If you are talking about race conditions when you want a high level of randomness — different server performance levels. A large number of connections on the server would help with this as well but you will need to try various different server loads. Start with some clients to insure concurrency and then to increase the throughput until you are flooding the server.

It is going to be hit and miss to recreate your problem I suspect. Be careful of adding System.out or logging messages because that will change the synchronized patterns.

Edit:

If you are talking about read/write race-conditions on an object that is not thread-safe, then I would say you want as many different performance levels as you can get. Race-conditions are all about when a thread time-slice finishes and the thread is swapped out, cached memory flush timing, when other threads run the same time the writer thread runs, and the order of operations.

Again, I would write your clients so that they start slow and then build up so the server will be hit with varying degrees of load.