JAVA多线程实现Runnable方式

（一）

步骤：

 1.定义实现Runnable接口

 2.覆盖Runnable接口中的run方法，将线程要运行的代码存放在run方法中。

3.通过Thread类建立线程对象。

4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。

  为什么要讲Runnable接口的子类对象传递给Thread的构造方法。因为自定义的方法的所属的对象是Runnable接口的子类对象。

5.调用Thread类的start方法开启线程并调用Runnable接口子类run方法。

（二）线程安全的共享代码块问题

  目的：程序是否存在安全问题，如果有，如何解决？

如何找问题：

1.明确哪些代码是多线程运行代码。

2.明确共享数据

3.明确多线程运行代码中哪些语句是操作共享数据的。

[java]  view plain  copy

1. class Bank{  
2.   
3.     private int sum;  
4.     public void add(int n){  
5.       
6.          sum+=n;  
7.          System.out.println("sum="+sum);  
8.       
9.     }  
10.   
11. }  
12.  class Cus implements Runnable{  
13.   
14.    private Bank b=new Bank();  
15.    public void run(){  
16.      synchronized(b){     
17.          for(int x=0;x<3;x++)  
18.          {  
19.             b.add(100);  
20.            
21.          }  
22.      }  
23.    }  
24.   
25. }  
26. public class BankDemo{  
27.     public static void main(String []args){  
28.         Cus c=new Cus();  
29.         Thread t1=new Thread(c);  
30.         Thread t2=new Thread(c);  
31.         t1.start();  
32.         t2.start();  
33.       
34.       
35.     }  
36.   
37.   
38. }  

[java]  view plain  copy

1. 或者第二种方式，将同步代码synchronized放在修饰方法中。  

[java]  view plain  copy

1. <pre name="code" class="java">class Bank{  
2.   
3.     private int sum;  
4.     public synchronized void add(int n){  
5.         Object obj=new Object();  
6.            
7.           sum+=n;  
8.          try{  
9.               Thread.sleep(10);  
10.          }catch(Exception e){  
11.            e.printStackTrace();  
12.          }  
13.          System.out.println("sum="+sum);  
14.           
15.     }  
16.   
17. }  
18.  class Cus implements Runnable{  
19.   
20.    private Bank b=new Bank();  
21.    public void run(){  
22.          
23.          for(int x=0;x<3;x++)  
24.          {  
25.             b.add(100);  
26.            
27.          }  
28.        
29.    }  
30.   
31. }  
32. public class BankDemo{  
33.     public static void main(String []args){  
34.         Cus c=new Cus();  
35.         Thread t1=new Thread(c);  
36.         Thread t2=new Thread(c);  
37.         t1.start();  
38.         t2.start();  
39.       
40.       
41.     }  
42.   
43.   
44. }  
45. </pre><br>  
46. <br>  
47. <pre></pre>  
48. 总结：  
49. <p></p>  
50. <p>1.在一个类中定义要处理的问题，方法。</p>  
51. <p>2.在实现Runnable的类中重写run方法中去调用已经定义的类中的要处理问题的方法。</p>  
52. <p>在synchronized块中接受要处理问题那个类的对象。</p>  
53. <p>3.在main方法中去定义多个线程去执行。</p>  
54.