刚刚复习到字符串的时候，听毕老师讲到StringBuffer的同步性。
突然就有了疑惑，然后敲代码，验证真实性。
以StringBuffer.appappend()为例
本来先想到的是StringBuffer的实现接口Appendable，
因为StringBuffer, StringBuilder都实现了该接口
所以想从此处证明是否安全，结果，加锁安全，不加乱码
然后直接证实StringBuffer是否安全，结果，加锁安全，不加乱码
这是为什么呢？难道真的不安全吗？
（转载）线程安全 并不是说他的一系列操作是同步的 只是对于他执行某个方法的时候不允许别的线程去改变。针对一个类来说是不是线程安全就要看，多个线程在同时在运行，这些线程可能会同时执行某个方法。但是每次运行结果和单线程执行的结果一样，那么就可以说是线程安全的。
到这里，我才明白，添加代码时的安全不是指顺序添加，而是可不可添加上。

举个例子，地铁排队进站，你力气大你可以先进去，或者去插队(美女和纹身猛男占优)
但是你不能把我打一顿，然后替换我。(某些暴力除外，也许给我钱也可以)


这时，如果加上锁(Lock)，那么就是真正的“安全”了，
就像一队特警维护进站秩序，插队，打架，不服从管理的一律拉出去枪毙五分钟(手持核弹的不算)
这样才会按顺序进站，也就是真正的同步安全了。

1. import java.io.IOException;
   
2. import java.util.concurrent.locks.Lock;
   
3. import java.util.concurrent.locks.ReentrantLock;
   
4.   
   
5. public class Test {  
   
6.         public static void main(String[] args) throws InterruptedException{
   
7. 
   
8.       Test2 t = new Test2();
   
9.       Test1 t1 = new Test1(t);
   
10.      Thread d1 = new Thread(t1);  Thread d2 = new Thread(t1);
    
11.      Thread d3 = new Thread(t1);  Thread d4 = new Thread(t1);
    
12.      Thread d5 = new Thread(t1);  Thread d6 = new Thread(t1);      
    
13.      d1.start(); d2.start(); d3.start(); d4.start(); d5.start(); d6.start();     
    
14.      d1.join(); d2.join(); d3.join(); d4.join(); d5.join(); d6.join();
    
15. 
    
16.                 new TPrint().me(t1.str);
    
17.                 //new TPrint().me(t.ap);
    
18.         }
    
19. }
    
20. 
    
21. class Test1 implements Runnable {
    
22.         StringBuffer str = new StringBuffer();
    
23.         private Test2 t;
    
24.         private int count = 0;
    
25. 
    
26.         public Test1(Test2 t) {
    
27.                 this.t = t;
    
28.         }
    
29. 
    
30.         public void run() {
    
31.                 while (count++ < 100000)
    
32.                         try {
    
33.                                 // t.fun();
    
34.                                 // t.fun(str);
    
35.                                 //t.fun1(str);
    
36.                                 t.fun2(str);
    
37.                         } catch (Exception e) {
    
38.                                 e.printStackTrace();
    
39.                         }
    
40.         }
    
41. }
    
42. class TPrint{
    
43.         public void me(StringBuffer str) {
    
44.                 String str1 = new String(str);
    
45.                 //切割验证是否顺序添加
    
46.                 String[] st = str1.split("abcdefghijklmnopqrstuvwxyz");
    
47.                 // String[] st = str1.split("0");
    
48.                 for (int x = 0; x < st.length; x++)
    
49.                         System.out.println(x + "*****\t" + st[x]);
    
50.         }
    
51. }
    
52. class Test2 {
    
53.         private Lock lock = new ReentrantLock();
    
54.         StringBuffer ap = new StringBuffer();
    
55.         char x = 'a';
    
56.         int count = 0;
    
57. 
    
58.         public void fun(StringBuffer ap) throws Exception {
    
59.                 method(ap);
    
60.         }
    
61. 
    
62.         public void fun1(Appendable ap) throws Exception {
    
63.                 method(ap);
    
64.         }
    
65.        
    
66.         public void fun2(Appendable ap) throws Exception {
    
67.                 lock.lock();
    
68.                 try {
    
69.                         method(ap);
    
70.                 } finally {
    
71.                         lock.unlock();
    
72.                 }
    
73.         }
    
74.         public void fun() throws Exception {
    
75.                 lock.lock();
    
76.                 try {
    
77.                         method(ap);
    
78.                 } finally {
    
79.                         lock.unlock();
    
80.                 }
    
81.         }
    
82. 
    
83. 
    
84.         private void method(Appendable ap) throws IOException {
    
85.                 //添加字符a到z
    
86.                 if (x > 'z') {
    
87.                         x = 'a';
    
88.                         ap.append("0");
    
89.                 }
    
90.                 ap.append(x++);
    
91.                 System.out.println(Thread.currentThread() + "****" + count++ + x);
    
92.         }
    
93. }

复制代码

理解的已经很深入了。

不明觉厉!                 

真心很强大

看起来很厉害的样子

完全不知道怎么证明是不是同步和安全的

飘过，，，，，

{:2_31:}{:2_31:}{:2_31:}{:2_31:}{:2_31:}{:2_31:}

学习学习！

看起来很厉害的样子,理解的不如你