JAVA多线程的问题以及处理（一）【转】

        多线程编程为程序开发带来了很多的方便，但是也带来了一些问题，这些问题是在程序开发过程中必须进行处理的问题。

         这些问题的核心是，如果多个线程同时访问一个资源，例如变量、文件等，时如何保证访问安全的问题。在多线程编程中，这种会被多个线程同时访问的资源叫做临界资源。

         下面通过一个简单的示例，演示多个线程访问临界资源时产生的问题。在该示例中，启动了两个线程类DataThread的对象，该线程每隔200毫秒输出一次变量n的值，并将n的值减少1。变量n的值存储在模拟临界资源的Data类中，该示例的核心是两个线程类都使用同一个Data类的对象，这样Data类的这个对象就是一个临界资源了。

示例代码如下：

    package syn1;

/**
 * 模拟临界资源的类
 */
public class Data {
         public int n;
         public Data(){
                   n = 60;
         }
}

package syn1;
/**
 * 测试多线程访问时的问题
 */
public class TestMulThread1 {
         public static void main(String[] args) {
                   Data data = new Data();
                   DataThread d1 = new DataThread(data,"线程1");
                   DataThread d2 = new DataThread(data,"线程2");
         }
}

package syn1;
/**
 * 访问数据的线程
 */
public class DataThread extends Thread {
         Data data;
         String name;
         public DataThread(Data data,String name){
                   this.data = data;
                   this.name = name;
                   start();
         }
          
         public void run(){
                   try{
                            for(int i = 0;i < 10;i++){
                                     System.out.println(name + ":" + data.n);
                                     data.n--;
                                     Thread.sleep(200);
                            }
                   }catch(Exception e){}
         }
}

 在运行时，因为不同情况下该程序的运行结果会出现不同，该程序的一种执行结果为：

                   线程1:60

线程2:60
线程2:58
线程1:58
线程2:56
线程1:56
线程2:54
线程1:54
线程2:52
线程1:52
线程2:50
线程1:50
线程2:48
线程1:48
线程2:47
线程1:46
线程2:44
线程1:44
线程2:42
线程1:42

      从执行结果来看，第一次都输出60是可以理解的，因为线程在执行时首先输出变量的值，这个时候变量n的值还是初始值60，而后续的输出就比较麻烦了，在开始的时候两个变量保持一致的输出，而不是依次输出n的每个值的内容，而到将要结束时，线程2输出47这个中间数值。

         出现这种结果的原因很简单：线程1改变了变量n的值以后，还没有来得及输出，这个变量n的值就被线程2给改变了，所以在输出时看的输出都是跳跃的，偶尔出现了连续。

         出现这个问题也比较容易接受，因为最基本的多线程程序，系统只保证线程同时执行，至于哪个先执行，哪个后执行，或者执行中会出现一个线程执行到一半，就把CPU的执行权交给了另外一个线程，这样线程的执行顺序是随机的，不受控制的。所以会出现上面的结果。

         这种结果在很多实际应用中是不能被接受的，例如银行的应用，两个人同时取一个账户的存款，一个使用存折、一个使用卡，这样访问账户的金额就会出现问题。或者是售票系统中，如果也这样就出现有人买到相同座位的票，而有些座位的票却未售出。

         在多线程编程中，这个是一个典型的临界资源问题，解决这个问题最基本，最简单的思路就是使用同步关键字synchronized。

         synchronized关键字是一个修饰符，可以修饰方法或代码块，其的作用就是，对于同一个对象(不是一个类的不同对象)， 当多个线程都同时调用该方法或代码块时，必须依次执行，也就是说，如果两个或两个以上的线程同时执行该段代码时，如果一个线程已经开始执行该段代码，则另 外一个线程必须等待这个线程执行完这段代码才能开始执行。就和在银行的柜台办理业务一样，营业员就是这个对象，每个顾客就好比线程，当一个顾客开始办理 时，其它顾客都必须等待，及时这个正在办理的顾客在办理过程中接了一个电话 (类比于这个线程释放了占用CPU的时间，而处于阻塞状态)，其它线程也只能等待。

         使用synchronized关键字修改以后的上面的代码为：

                package syn2;

/**
 * 模拟临界资源的类
 */
public class Data2 {
         public int n;
         public Data2(){
                   n = 60;
         }
        
         public synchronized void action(String name){
                   System.out.println(name + ":" + n);
                   n--;
         }
}

package syn2;
/**
 * 测试多线程访问时的问题
 */
public class TestMulThread2 {
         public static void main(String[] args) {
                   Data2 data = new Data2();
                   Data2Thread d1 = new Data2Thread(data,"线程1");
                   Data2Thread d2 = new Data2Thread(data,"线程2");
         }
}

package syn2;
/**
 * 访问数据的线程
 */
public class Data2Thread extends Thread {
         Data2 data;
         String name;
         public Data2Thread(Data2 data,String name){
                   this.data = data;
                   this.name = name;
                   start();
         }
          
         public void run(){
                   try{
                            for(int i = 0;i < 10;i++){
                                     data.action(name);
                                     Thread.sleep(200);
                            }
                   }catch(Exception e){}
         }
}

       该示例代码的执行结果会出现不同，一种执行结果为：

                 线程1:60

线程2:59
线程2:58
线程1:57
线程2:56
线程1:55
线程2:54
线程1:53
线程2:52
线程1:51
线程2:50
线程1:49
线程1:48
线程2:47
线程2:46
线程1:45
线程2:44
线程1:43
线程2:42
线程1:41

        在该示例中，将打印变量n的代码和变量n变化的代码组成一个专门的方法action，并且使用修饰符synchronized修改该方法，也就是说对于一个Data2的对象，无论多少个线程同时调用action方法时，只有一个线程完全执行完该方法以后，别的线程才能够执行该方法。这就相当于一个线程执行到该对象的synchronized方法时，就为这个对象加上了一把锁，锁住了这个对象，别的线程在调用该方法时，发现了这把锁以后就继续等待下去了。

如果这个例子还不能帮助你理解如何解决多线程的问题，那么下面再来看一个更加实际的例子——卫生间问题。

         例 如火车上车厢的卫生间，为了简单，这里只模拟一个卫生间，这个卫生间会被多个人同时使用，在实际使用时，当一个人进入卫生间时则会把卫生间锁上，等出来时 打开门，下一个人进去把门锁上，如果有一个人在卫生间内部则别人的人发现门是锁的则只能在外面等待。从编程的角度来看，这里的每个人都可以看作是一个线程 对象，而这个卫生间对象由于被多个线程访问，则就是临界资源，在一个线程实际使用时，使用synchronized关键将临界资源锁定，当结束时，释放锁定。实现的代码如下：

 package syn3;

/**
 * 测试类
 */
public class TestHuman {
         public static void main(String[] args) {
                   Toilet t = new Toilet(); //卫生间对象
                   Human h1 = new Human("1",t);
                   Human h2 = new Human("2",t);
                   Human h3 = new Human("3",t);
         }
}

package syn3;
/**
 * 人线程类，演示互斥
 */
public class Human extends Thread {
         Toilet t;
         String name;
         public Human(String name,Toilet t){
                   this.name = name;
                   this.t = t;
                   start(); //启动线程
         }
        
         public void run(){
                   //进入卫生间
                   t.enter(name);
         }
}

package syn3;
/**
 * 卫生间，互斥的演示
 */
public class Toilet {
         public synchronized void enter(String name){
                   System.out.println(name + "已进入！");
                   try{
                            Thread.sleep(2000);
                   }catch(Exception e){}
                   System.out.println(name + "离开！");
         }
}

         该示例的执行结果为，不同次数下执行结果会有所不同：

           1已进入！

1离开！
3已进入！
3离开！
2已进入！
2离开！

        在该示例代码中，Toilet类表示卫生间类，Human类模拟人，是该示例中的线程类，TestHuman类是测试类，用于启动线程。在TestHuman中，首先创建一个Toilet类型的对象t，并将该对象传递到后续创建的线程对象中，这样后续的线程对象就使用同一个Toilet对象，该对象就成为了临界资源。下面创建了三个Human类型的线程对象，每个线程具有自己的名称name参数，模拟3个线程，在每个线程对象中，只是调用对象t中的enter方法，模拟进入卫生间的动作，在enter方法中，在进入时输出调用该方法的线程进入，然后延迟2秒，输出该线程离开，然后后续的一个线程进入，直到三个线程都完成enter方法则程序结束。

         在该示例中，同一个Toilet类的对象t的enter方法由于具有synchronized修饰符修饰，则在多个线程同时调用该方法时，如果一个线程进入到enter方法内部，则为对象t上锁，直到enter方法结束以后释放对该对象的锁定，通过这种方式实现无论多少个Human类型的线程，对于同一个对象t，任何时候只能有一个线程执行enter方法，这就是解决多线程问题的第一种思路——互斥的解决原理。