Java multi-thread synchronization tutorial-BusyFlag or Lock (on)

The Java language has built-in synchronized keywords for multi-threaded synchronization, which greatly facilitates the compilation of multi-threaded programs in Java. However, the use of the synchronized keyword alone cannot meet all the requirements for multi-thread synchronization. As you know, synchronized can only synchronize methods or code blocks. If an application needs to synchronize across multiple methods, synchroinzed cannot be used. There are many synchronization mechanisms in C ++, such as semaphores, mutex, and temporary zone. In Java, we can also build such a synchronization tool at a higher level based on synchronized features to facilitate our use.
Currently, a Java synchronization toolkit compiled by Doug Lea is widely used. You can learn more about this package here:
Http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html
This toolkit is under the control of JCP as JSR166 and will be a formal component of JDK1.5. This article does not describe this toolkit in detail, but introduces a variety of synchronization mechanisms, and provides examples of implementation of such synchronization mechanisms, which is not an industrial implementation. However, we will refer to some code snippets of industrial implementation in this synchronization package of Doug Lea.
In this example, we still use the Account class in the previous article. However, we will write a new ATM class to simulate the ATM. Using an ATM tester class, we will generate 10 ATM threads, john's account is also queried, withdrawn, and deposited. The Account class has been modified to meet the needs of this article:

1. ImportJava. util.HashMap;
2. ImportJava. util.Map;
4. ClassAccount {
5. StringName;
6. // Float amount;
8. // Use a Map to simulate persistent Storage
9. Static MapStorage =New HashMap();
10. Static{
11. Storage. put ("John ",New Float(1000.0f ));
12. Storage. put ("Mike ",New Float(8000000f ));
13. }
16. PublicAccount (StringName ){
17. // System. out. println ("new account:" + name );
18. This. Name = name;
19. // This. amount = (Float) storage. get (name). floatValue ();
20. }
22. Public Synchronized VoidDeposit (FloatAmt ){
23. FloatAmount = ((Float) Storage. get (name). floatValue ();
24. Storage. put (name,New Float(Amount + amt ));
25. }
27. Public Synchronized VoidWithdraw (FloatAmt)ThrowsInsufficientBalanceException {
28. FloatAmount = ((Float) Storage. get (name). floatValue ();
29. If(Amount> = amt)
30. Amount-= amt;
31. Else 
32. Throw NewInsufficientBalanceException ();
34. Storage. put (name,New Float(Amount ));
35. }
37. Public FloatGetBalance (){
38. FloatAmount = ((Float) Storage. get (name). floatValue ();
39. ReturnAmount;
40. }
41. }

In the new Account class, we use a HashMap to store Account information. The Account is used by the ATM class after logging on through login:

1. Public ClassATM {
2. Account acc;
4. // As a demo, password verification is omitted
5. Public BooleanLogin (StringName ){
6. If(Acc! =Null)
7. Throw New Html "target =" _ blank ">IllegalArgument