Recently I am building a REST api as part of an assignment where I am suppose to increment a counter in the database table, assuming the table has only one column, I am suppose to fire like 1000 requests per second to this REST api to increment the counter and at the end the data should be consistent i.e. if initially the counter value in DB is 0 then after the succesful run of 1000 requests concurrently it should be 1000.

No worries so far I achieved it via database row-level locking, other way could be the use of transaction(with highest isolation) around the code which increment the counter, but what I have observed is though this is achievable to maintain consistency but it comes at the cost of high latency for example I run a Jmeter test with 1000 req/sec for 5 seconds and all requests full-filled in around 26 seconds which is really a huge latency.

This now created a lot of questions in my mind - 

1. There must be some real time scenarios or apps where this level of
high concurrency is handled with low latency, isn't there ?
2. Is it always the limitation with Relational database and could be
 solved non-relational nosql database in some way ?
3. I thought like queuing such concurrent requests with some message
 queue but again that will be non-realtime behavior if user is
 waiting on some response

Thanks in advance,
any help appreciated.