这是我看书上的一个存钱取钱的代码，至今都没明白为什么老是要在操作临界资源动作的前后加上强制线程切换，sleep()方法不是不释放锁吗，既然不释放锁，虽然线程暂停有什么用？为什么要强制转换线程？这样有什么好处？搞不懂！！

1. public class TakeSavingMoney {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6.         public static void main(String[] args) {
   
7.                 // TODO Auto-generated method stub
   
8.                 Account account=new Account("晋瑜", 5000000);
   
9.                 // 存入1000000
   
10.                 (new Saver(account, 1000000)).start();
    
11.                 // 取出30000
    
12.                 (new Fetcher(account, 30000)).start();
    
13.                 // 取出450000
    
14.                 (new Fetcher(account, 450000)).start();
    
15.                 // 存入50000
    
16.                 (new Saver(account, 50000)).start();
    
17.         }
    
18. 
    
19. }
    
20. class Account{        // 账户类
    
21.         private String name;        // 账户名
    
22.         private double money;        // 账户余额
    
23.         
    
24.         public Account(String name, double money) {
    
25.                 // TODO Auto-generated constructor stub
    
26.                 this.name=name;
    
27.                 this.money=money;
    
28.         }
    
29.         public String getName(){
    
30.                 return this.name;
    
31.         }
    
32.         public double getMoney(){
    
33.                 return this.money;
    
34.         }
    
35.         public void put(double money){        // 存钱
    
36.                 this.money+=money;
    
37.         }
    
38.         public void get(double money){        // 取钱
    
39.                 this.money-=money;
    
40.         }
    
41. }
    
42. 
    
43. class Saver extends Thread{        //存钱类
    
44.         private Account account;        // 存钱人拥有一个账户
    
45.         private double money;                // 将要存钱的数
    
46.         public Saver(Account account, double money) {
    
47.                 // TODO Auto-generated constructor stub
    
48.                 this.account=account;
    
49.                 this.money=money;
    
50.         }
    
51.         @Override
    
52.         public void run() {
    
53.                 // TODO Auto-generated method stub
    
54.                 synchronized (account) {        // account是临界资源
    
55.                         //临界区
    
56.                         System.out.println(account.getName()+"账户\n"+"现有："+account.getMoney()+"元\n"+"存入："+this.money+"元.");
    
57.                         try {                // 旨在强制发生线程切换
    
58.                                 sleep(1);
    
59.                         } catch (InterruptedException e) {
    
60.                                 // TODO Auto-generated catch block
    
61.                                 e.printStackTrace();
    
62.                         }
    
63.                         account.put(this.money);
    
64.                         try {
    
65.                                 sleep(1);
    
66.                         } catch (InterruptedException e) {
    
67.                                 // TODO Auto-generated catch block
    
68.                                 e.printStackTrace();
    
69.                         }
    
70.                         System.out.println("现有余额："+account.getMoney());
    
71.                 }
    
72.         }
    
73. }
    
74. 
    
75. class Fetcher extends Thread{        //取钱类
    
76.         private Account account;        // 取款人持有一个账户
    
77.         private double money;                // 将要取钱的数
    
78.         public Fetcher(Account account, double money) {
    
79.                 // TODO Auto-generated constructor stub
    
80.                 this.account=account;
    
81.                 this.money=money;
    
82.         }
    
83.         @Override
    
84.         public void run() {
    
85.                 // TODO Auto-generated method stub
    
86.                 synchronized (account) {        
    
87.                         //临界区
    
88.                         System.out.println(account.getName()+"账户\n"+"现有："+account.getMoney()+"元\n"+"取出："+this.money+"元.");
    
89.                         try {
    
90.                                 sleep(1);
    
91.                         } catch (InterruptedException e) {
    
92.                                 // TODO Auto-generated catch block
    
93.                                 e.printStackTrace();
    
94.                         }
    
95.                         account.get(this.money);
    
96.                         try {
    
97.                                 sleep(1);
    
98.                         } catch (InterruptedException e) {
    
99.                                 // TODO Auto-generated catch block
    
100.                                 e.printStackTrace();
     
101.                         }
     
102.                         System.out.println("现有余额："+account.getMoney());
     
103.                 }
     
104.         }
     
105. }

复制代码

   synchronized (account) {        // account是临界资源

55.                        //临界区

56.                        System.out.println(account.getName()+"账户\n"+"现有："+account.getMoney()+"元\n"+"存入："+this.money+"元.");

57.                        try {                // 旨在强制发生线程切换

58.                                sleep(1);

你说的是这里吗？
线程中 cpu做快速切换，以达到同时运行的结果，但是cpu切换的时候是不固定路线的。所以你不做强制发生线程转换的话，会很有可能发生并发现象，或者是先打印下面的代码然后再回头打印上面的代码。  然后就会发现存入的钱和余额不相等。
做 sleep之后代码就从上往下一一打印，这就是为什么要强制发生线程转换的原因。

愚见，请忽略。

sleep()是释放CPU资源，但是不释放锁
个人觉得用sleep的原因如下：
1，在同步代码块中加Sleep是为了更好的让程序员学习者理解cpu在切换
2，让线程切换来模拟现实情况看有什么异常发生，好在调试阶段就把问题就找出来
以免程序到用户那边出了问题就不好了

胥文 发表于 2013-2-21 19:22
sleep()是释放CPU资源，但是不释放锁
个人觉得用sleep的原因如下：
1，在同步代码块中加Sleep是为了更好的 ...

听起来挺有道理，其实我试过不用sleep()去强制切换其实运行结果也是正确的；
就是不知道以后要是写程序时都不用sleep()进行强制切换会不会造成什么严重后果？
因为我看到好几本书上人家作者都会去用sleep()强制切换，这样到底有什么好处？