1. public class ThreadTest1 {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          *            储户存钱问题，分清楚哪些是共享数据，哪些代码是可能出现问题的，哪些代码需要被同步
   
6.          */
   
7.         public static void main(String[] args) {
   
8.                 Bank b = new Bank();
   
9.                 new Thread(new Customer(b)).start();
   
10.                 new Thread(new Customer(b)).start();
    
11.                 new Thread(new Customer(b)).start();
    
12.         }
    
13. }
    
14. 
    
15. class Bank {
    
16.         private int sum = 0;
    
17. 
    
18.         Bank() {
    
19.         }
    
20. 
    
21.         public void add(int n) throws InterruptedException {// 这里操作了共享数据，但是有多句话，
    
22.                 // 所以可能会出现安全问题，可让单个线程sleep的方式使问题突出
    
23.                 sum = sum + n;
    
24.                 Thread.sleep(100);
    
25.                 System.out.println(Thread.currentThread().getName() + "..." + sum);
    
26.         }
    
27. }
    
28. 
    
29. class Customer implements Runnable {
    
30.         private Bank b;
    
31. 
    
32.         Customer(Bank b) {
    
33.                 this.b = b;
    
34.         }
    
35. 
    
36.         @Override
    
37.         public void run() {
    
38.                 for (int x = 0; x < 3; x++) {// 这里操作了共享数据，但是只有一句话，不会出现安全问题，
    
39.                         // 但是如果在这里加一把锁的话也是可以的，但是对问题的处理阅读性较差
    
40.                         try {
    
41.                                 synchronized (Customer.class) {
    
42.                                         b.add(100);
    
43.                                 }
    
44.                         } catch (InterruptedException e) {
    
45.                                 e.printStackTrace();
    
46.                         }// 上面线程sleep会出现异常，那里抛出了异常，这里也接着把异常抛给虚拟机不行吗，为什么一定要处理？
    
47.                 }
    
48.         }
    
49. }

复制代码

{:2_30:}上面线程sleep会出现异常，那里抛出了异常，这里也接着把异常抛给虚拟机不行吗，为什么一定要处理？

　　1：当子类覆盖父类的方法时，如果父类的方法抛出了异常，那么子类的方法要么不抛出异常要么抛出父类异常或者该异常的子类，不能抛出其他异常。
　　2：如果父类抛出了多个异常，那么子类在覆盖时只能抛出父类的异常的子集。
       3：如果父类或者接口中的方法没有抛出过异常，那么子类是不可以抛出异常的，如果子类的覆盖的方法中出现了异常，只能try不能throws。

因为在多线程中Thread和 Runnable接口的run方法没有抛出异常，
所以实现或继承Thread和 Runnable接口之后，覆盖run方法时，也不能够抛出异常，必须要try{}catch（）{}处理
下面是我的笔记，你可以看看

1. import java.util.Scanner;
   
2. 
   
3. /*创建线程的两种方法：
   
4. *
   
5. * 一：继承Thread类
   
6. *                 1.定义类并继承Thread类；
   
7. *                 2.覆盖Thread类中的run方法；
   
8. *                 3.建立Thread子类对象；
   
9. *                 4.使用start方法开启线程，并调用run方法。
   
10. *
    
11. * 二：实现Runnable接口
    
12. *                 1.定义类实现Runnable接口；
    
13. *                 2.覆盖Runnable接口的run方法；
    
14. *                         将线程所要运行的代码存放在该run方法中；
    
15. *                 3.通过Thread类建立线程对象；
    
16. *                 4.将Runnable接口的子类对象传递给Thread类的构造函数。
    
17. *                         为什么要将Runnable接口的子类对象传递给Thread的构造函数：
    
18. *                                 因为，自定的run方法所属对象是Runnable接口的子类对象，所以
    
19. *                                 要让线程去指定对象的run方法，就必须明确该run方法的所属对象。
    
20. *                 5.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
    
21. *
    
22. * 实现方式和继承方式有什么区别：
    
23. *
    
24. * 继承Thread:线程运行的代码存放在Thread子类run方法中。
    
25. * 实现Runnable:线程运行的代码存放在接口的子类的run方法中。
    
26. *
    
27. * 实现方式的好处：避免了单继承的局限性。
    
28. * 在定义线程是，建议使用实现方式。
    
29. *
    
30. * 多线程的安全问题：
    
31. * 同步代码块：
    
32. * synchronized(对象)
    
33. * {
    
34. *                 需要同步的代码。
    
35. * }
    
36. *
    
37. * 同步的前提：
    
38. * 1.必须要有两个或者两个以上的线程；
    
39. * 2.必须是多个线程使用同一个锁；
    
40. *
    
41. * 好处：解决了多线程的安全问题
    
42. * 弊端：多个线程需要判定，消耗资源。
    
43. * */
    
44. class xiancheng implements Runnable
    
45. {
    
46.         int x,y;
    
47.         private int sum = 0;
    
48.         xiancheng(int x,int y)
    
49.         {
    
50.                 this.x=x;
    
51.                 this.y=y;
    
52.         }
    
53. 
    
54.         Object obj=new Object();
    
55.         public void run()
    
56.         {
    
57.                 for(int a=0;a<x;a++)
    
58.                 {
    
59.                         synchronized(obj)
    
60.                         {
    
61.                                 sum+=y;
    
62.                                 System.out.println(Thread.currentThread().getName() + "x=" +sum);
    
63.                         }
    
64.                 }
    
65.         }
    
66. }
    
67. 
    
68. public class DuoXianCheng
    
69. {
    
70. 
    
71.         public static void main(String[] args)
    
72.         {
    
73.                 Scanner in=new Scanner(System.in);
    
74.                 System.out.println("请输入要存储的次数：");
    
75.                 int x=in.nextInt();
    
76.                 System.out.println("请输入要存储的数目：");
    
77.                 int y=in.nextInt();
    
78.                 xiancheng a = new xiancheng(x,y);
    
79.                 Thread t=new Thread(a);
    
80.                 Thread tt=new Thread(a);
    
81.                
    
82.                 t.start();
    
83.                 tt.start();
    
84. 
    
85.         }
    
86. }

复制代码

skill20 发表于 2014-5-5 10:37
　　1：当子类覆盖父类的方法时，如果父类的方法抛出了异常，那么子类的方法要么不抛出异常要么抛出父类异 ...

谢谢，问题解决

fei_xiong 发表于 2014-5-5 10:37
因为在多线程中Thread和 Runnable接口的run方法没有抛出异常，
所以实现或继承Thread和 Runnable接口之后， ...

3q，看来很多只是还得自己遇到了才记得牢固