What is the best solution for the following problem:

Two different processes (e.g. applications) are accessing the same record via
hibernate. Both processes are reading, modifing, and writing back the modified value.

Via the transaction isolation level I can ensure that the changes
are only visible after the commit.

But how can I ensure that both processes are not reading stale data.

E.g. that the following won't happen:

Process A and B reading the same value (e.g. 10)
Process A is increasing the value to 11
Process A is committing
Process B is decreasing the value to 9
Process B is committing

Just transactions aren't enough.

The last wins, the value is now 9, instead of 10.

What would be the "best hibernate practice"?

Thanks in advance,
Dieter Bogdoll

Hibernate can help with locking, but it is more about shema design.
All OLTP systems I have ever saw are implemented without locking.

http://forum.hibernate.org/viewtopic.ph ... 5&start=15

This problem becomes more "interesting" if your app moves something like money in bank.

Forget "nice" OOP style persistence with "saveorupdate" sometimes.

Use a Hibernate <version> property, whcih avoids this kind of problem.

Hi Gavin,

[quote="gavin"]Use a Hibernate <version> property, whcih avoids this kind of problem.[/quote]

That's a good solution to my problem.

Did I overlooked this problem in the FAQs?
If it is missing in the FAQ, this topic should really be mentioned there.

You overlooked the reference guide section 14.3