Java多线程---简单的安全问题_JAVA_编程开发_程序员俱乐部

转自：http://josh-persistence.iteye.com/blog/1923191

　　由于很多优秀的Java Web容器或者是J2EE容器的涌现，作为一个java web程序员，很少或者不需要去处理线程的问题，因为服务器或者是框架（如Spring，Struts）等都帮我们处理好了。但当我们查看JDK的API的时候，我们总会看到一些类写着：线程安全或者线程不安全。最简单的例子，比如说StringBuilder这个类中，有这么一句：“将StringBuilder的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用StringBuffer.
        为了说明线程的不安全会带来什么问题，下面手动创建一个线程不安全的类，然后在多个线程中去测试使用这个类，看看有什么效果。

class="java">
/** 
 *  
 */  
package com.wsheng.thread.simlesafe;  
  
/** 
 * 在这个类中的Count方法是计算1一直加到10的和，并输出当前线程名和最后的总和， 
 * 我们期望的结果应该是每一个线程都会输出55 
 *  
 * @author Wang Sheng(Josh) 
 * 
 */  
public class Count {  
  
    private int num;  
      
    // 我们想查看Count类的对象在内存中有几个, 以判断是否有资源共享和竞争  
    private int objectNum;  
      
    public Count(int objectNum) {  
        this.objectNum = objectNum;  
    }  
      
    public void count() {  
        for (int i = 1; i <= 10; i++) {  
            num += i;  
        }  
 // Object Number一值都是1，说明只有一个Count对象，保证多个线程共享一个Count对象。  
        System.out.println(Thread.currentThread().getName() + " : " + num + " Object Number: "  + objectNum);  
          
    }  
  
}  

            在这个类中的count方法是计算1一直加到10的和，并输出当前线程名，还有共享的对象(Count)的个数和数字的总和，我们期望的是每个线程都会输出55。

/** 
 *  
 */  
package com.wsheng.thread.simlesafe;  
  
/** 
 * @author Wang Sheng(Josh) 
 * 
 */  
public class ThreadTest {  
  
    public static void main(String[] args) {  
        Runnable run = new Runnable() {  
            int i = 1, j = 1;  
              
            // 只会new一次，即10个线程共享1个对象  
            Count count = new Count(i++);  
            public void run() {  
                System.out.println(" ----- Thread running " + j++ + " times");  
                count.count();  
            }  
        };  
          
        for (int i = 0; i < 10; i++) {  
            new Thread(run).start();  
        }  
    }  
  
}  

这里启动了10个线程，我们先看下输出的结果是不是我们预期的那样

----- Thread running 3 times 
----- Thread running 8 times 
Thread-8 : 110 Object Number: 1 
----- Thread running 10 times 
Thread-9 : 165 Object Number: 1 
----- Thread running 7 times 
----- Thread running 6 times 
Thread-7 : 275 Object Number: 1 
----- Thread running 5 times 
----- Thread running 2 times 
----- Thread running 4 times 
----- Thread running 1 times 
Thread-3 : 440 Object Number: 1 
Thread-1 : 385 Object Number: 1 
Thread-4 : 330 Object Number: 1 
Thread-5 : 220 Object Number: 1 
----- Thread running 9 times 
Thread-2 : 55 Object Number: 1 
Thread-6 : 550 Object Number: 1 
Thread-0 : 495 Object Number: 1 
我们看到只有一个线程（此处是Thread-2)线程输出的结果是我们期望的，而输出的每次都是累加的。为什么都是累加的呢？

      根本的原因是我们创建的Count对象是线程共享的，一个线程改变了成员变量num的值，下一个线程正巧读到了修改后的num，所以会递增输出。
       要说明线程同步问题首先要说明Java线程的两个特性，可见性和有序性。多个线程之间是不能直接传递数据交互的，它们之间的交互只能通过共享变量来实现。 拿上篇博文中的例子来说明，在多个线程之间共享了Count类的一个对象，这个对象是被创建在主内存(堆内存)中，每个线程都有自己的工作内存(线程 栈)，工作内存存储了主内存Count对象的一个副本，当线程操作Count对象时，首先从主内存复制Count对象到工作内存中，然后执行代码 count.count()，改变了num值，最后用工作内存Count刷新主内存Count。当一个对象在多个内存中都存在副本时，如果一个内存修改了 共享变量，其它线程也应该能够看到被修改后的值，此为可见性。由上述可知，一个运算赋值操作并不是一个原子性操作，多 个线程执行时，CPU对线程的调度是随机的，我们不知道当前程序被执行到哪步就切换到了下一个线程，一个最经典的例子就是银行汇款问题，一个银行账户存款 100，这时一个人从该账户取10元，同时另一个人向该账户汇10元，那么余额应该还是100。那么此时可能发生这种情况，A线程负责取款，B线程负责汇 款，A从主内存读到100，B从主内存读到100，A执行减10操作，并将数据刷新到主内存，这时主内存数据100-10=90，而B内存执行加10操 作，并将数据刷新到主内存，最后主内存数据100+10=110，显然这是一个严重的问题，我们要保证A线程和B线程有序执行，先取款后汇款或者先汇款后 取款，此为有序性。
       特别说明： 1.    10个线程，可能一开始都从主内存中读取到count对象的num的值都是1并放到各自的线程栈的工作内存中，但是当线程1执行完并刷新结果到主内存以后，线程2会在进行具体的操作之前，会去清楚自己的工作内存并重新从主内存中读取新的变量num的值。
                          2.     有序性可以简单的理解为，无论是A线程还是B线程先执行，都要保证有序，即A线程要么先执行完，再执行B线程，或者B线程先执行完，再执行A线程。即要么先取款，或者要么先存款。
                          3.      这一点大家一定要注意：特性1是可见性，这是多个线程共享同一个资源时，多个线程天然具有的特性，但是特性2 即有序性并不是天然具有的，而是我们要通过相关的API来解决的问题，我们往往要确保线程的执行是有序的，或者说是互斥的，即一个线程执行时，不允许另一个线程执行。如果你足够细心，那就会提出这样一个疑问，那么在上面的例子中，我们并没有用到线程相关的API，但最后的线程之间的输出结果是如此的有序（输出结果是很有规律的：55， 110，165， 220等后一个比前一个恰好大55的输出结果，如果上面的10个线程是随机执行的，那么输出结果肯定不是55， 110，165等. 因为有可能一个线程恰好加到53时，此时另一个线程开始执行，并从53开始逐渐的加1，而不是从我们期望的55逐渐加1，这是什么原因呢？这是因为CPU执行上面的10个线程都足够快，这是因为我们只是从1简单的加到10，等cpu时间片还没来得及执行下一个线程时，这个线程已经执行完了，所以看到的线程执行都是有序的，这个结果告诉我们的表现其实是不对的，因为线程的执行是随机的。要验证我们这个说法其实很简单，只需要将加大上面的for循环，加大for循环的执行时间，那么等其中一个线程没有执行完时，另一个线程可能就开始执行了，所以我们可以这样去修改：)

将for (int i = 1; i <= 10; i++) {num += i;}
改为：
for (int i = 1; i <= 1000; i++) {num += i;}， 下面是输出结果，从输出结果可以看出，此时的多个线程的执行不再是有序的，而是随机执行了。在下一篇博文中，我将通过一个例子，让你更加深入的体会到线程的随机执行性。

Result代码  收藏代码
----- Thread running 1 times 
----- Thread running 10 times 
Thread-0 : 1001000 Object Number: 1 
----- Thread running 8 times 
----- Thread running 9 times 
Thread-9 : 2002000 Object Number: 1 
----- Thread running 7 times 
----- Thread running 6 times 
Thread-5 : 3003000 Object Number: 1 
----- Thread running 5 times 
----- Thread running 4 times 
----- Thread running 3 times 
----- Thread running 2 times 
Thread-2 : 4504500 Object Number: 1 
Thread-3 : 4004000 Object Number: 1 
Thread-4 : 3503500 Object Number: 1 
Thread-8 : 2502500 Object Number: 1 
Thread-7 : 1501500 Object Number: 1 
Thread-6 : 1001000 Object Number: 1 
Thread-1 : 5005000 Object Number: 1 



       如果想要得到我们的期望结果，即每个线程的输出结果都是55.怎么办？有几种解决方案：
1. 将Count类中num变成count方法的局部变量：

/** 
 *  
 */  
package com.wsheng.thread.simlesafe;  
  
/** 
 * 在这个类中的Count方法是计算1一直加到10的和，并输出当前线程名和最后的总和， 
 * 我们期望的结果应该是每一个线程都会输出55 
 *  
 * @author Wang Sheng(Josh) 
 * 
 */  
public class Count2 {  
  
    // 我们想查看Count类的对象在内存中有几个, 以判断是否有资源共享和竞争  
    private int objectNum;  
      
    public Count2(int objectNum) {  
        this.objectNum = objectNum;  
    }  
      
    public void count() {  
        int num = 0;  
        for (int i = 1; i <= 10; i++) {  
            num += i;  
        }  
// Object Number一值都是1，说明只有一个Count对象，保证多个线程共享一个Count对象。  
        System.out.println(Thread.currentThread().getName() + " : " + num + " Object Number: "  + objectNum);  
          
    }  
  
}  

         2. 将线程类成员变量拿到run方法中；

/** 
 *  
 */  
package com.wsheng.thread.simlesafe;  
  
/** 
 * @author Wang Sheng(Josh) 
 * 
 */  
public class ThreadTest3 {  
  
    public static void main(String[] args) {  
        Runnable run = new Runnable() {  
            int i = 1, j = 1;  
              
            public void run() {  
                Count count = new Count(i++);  
                System.out.println(" ----- Thread running " + j++ + " times");  
                count.count();  
            }  
        };  
          
        for (int i = 0; i < 10; i++) {  
            new Thread(run).start();  
        }  
    }  
  
}  

很明显，这个方法会构造10个Count对象。

     3. 每次启动一个线程使用不同的线程类，不推荐。
        上述测试，我们发现，存在成员变量的类用于多线程时是不安全的，而变量定义在方法内是线程安全的。想想在使用struts1时，不推荐创建成员变量，因为 action是单例的，如果创建了成员变量，就会存在线程不安全的隐患，而struts2是每一次请求都会创建一个action，就不用考虑线程安全的问 题。