1. import java.util.concurrent.locks.*;
   
2. class Account
   
3. {
   
4.         private String name;
   
5.        
   
6.         private int count;
   
7.         private final Lock lock = new ReentrantLock();
   
8.         private Condition condition_drawer = lock.newCondition();//将取钱的动作绑定到锁上
   
9.         private Condition condition_deposite = lock.newCondition();//将存钱的动作绑定到锁上
   
10. 
    
11.         private boolean flag = false;
    
12. 
    
13.         Account(String name){
    
14.                 this.name = name;       
    
15.         }
    
16.         public String getName(){
    
17.                 return name;
    
18.         }
    
19. 
    
20.         public void draw()throws InterruptedException{
    
21.                         lock.lock();
    
22.                        
    
23.                         try{
    
24.                                 if(!flag)//在此处判断旗标为真时等待，保证账户有钱才能取
    
25.                                         condition_drawer.await();
    
26.                                 else{
    
27.                                         System.out.println(Thread.currentThread().getName()+"---取钱-->>"+count);
    
28.                                         try{Thread.sleep(100);}catch(InterruptedException e){}
    
29.                                         flag = false;
    
30.                                         condition_deposite.signalAll();
    
31.                                 }
    
32.                         }finally{
    
33.                                 lock.unlock();//释放锁定义在finally块里，锁一定被释放，以免线程阻塞
    
34.                         }
    
35. 
    
36.         }
    
37.         public void deposite()throws InterruptedException{
    
38.                 lock.lock();
    
39.                 try{
    
40.                         if(flag)
    
41.                                 condition_deposite.await();//方法await()会抛出InterruptedException异常
    
42.                         else{
    
43.                                 //因为账户必须先有钱才能取钱，因此count在此处自增，并且使用前自增，先增后用，保证存取数目一致
    
44.                                 System.out.println(Thread.currentThread().getName()+"-----------存钱----->>"+(++count));
    
45.                                 try{Thread.sleep(100);}catch(InterruptedException e){}
    
46.                                 flag = true;
    
47.                                 condition_drawer.signalAll();
    
48.                         }
    
49.                 }finally{
    
50.                         lock.unlock();//释放锁定义在finally块里，锁一定被释放，以免线程阻塞
    
51.                 }
    
52.         }
    
53. }
    
54. class Draw extends Thread
    
55. {
    
56.         private Account account;
    
57.        
    
58.         Draw(String name,Account account){
    
59.                 super(name);
    
60.                 this.account = account;
    
61.                
    
62.         }
    
63.         public void run()//覆盖Thread类的run方法，不能抛出异常
    
64.         {
    
65.                 while(true){
    
66.                         try
    
67.                         {
    
68.                                 account.draw();
    
69.                         }
    
70.                         catch (InterruptedException e)
    
71.                         {
    
72.                         }
    
73.                 }
    
74.                
    
75.         }
    
76.        
    
77. }
    
78. class Deposite extends Thread
    
79. {
    
80.         private Account account;
    
81.        
    
82.         Deposite(String name,Account account){
    
83.                 super(name);
    
84.                 this.account = account;
    
85.                
    
86.         }
    
87.         public void run()//覆盖Thread类的run方法，不能抛出异常
    
88.         {
    
89.                 while (true)
    
90.                 {
    
91.                         try
    
92.                         {
    
93.                                 account.deposite();
    
94.                         }
    
95.                         catch (InterruptedException e)
    
96.                         {
    
97.                         }       
    
98.                 }
    
99.         }
    
100. }
     
101. class  DrawThread01
     
102. {
     
103.         public static void main(String[] args)
     
104.         {
     
105.                 Account account = new Account("中国银行");
     
106. 
     
107.                 Draw dr1 = new Draw("顾客张三******",account);
     
108.                 Draw dr2 = new Draw("顾客梅梅******",account);
     
109. 
     
110.                 Deposite de1 = new Deposite("*****顾客李四",account);
     
111.                 Deposite de2 = new Deposite("*****顾客陈留",account);
     
112.                
     
113.                 dr1.start();
     
114.                 dr2.start();
     
115.                
     
116.                 de1.start();
     
117.                 de2.start();
     
118.         }
     
119. }

复制代码

这个代码不难好不         ，关键是思路问题

为什么用继承Thread。实现runable不好吗，

落幕繁华 发表于 2014-8-17 18:29
为什么用继承Thread。实现runable不好吗，

实现Runnable接口，我不知道在打印语句中怎么打印出自定义的线程名字

这标题。。。。

初学者看到100行以上的代码都觉得好牛B