多线程问题及处理

多线程问题及处理

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

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

        

1. 互斥

 下面通过一个简单的示例，演示多个线程访问临界资源时产生的问题。在该示例中，启动了两个线程类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方法，这就是解决多线程问题的第一种思路——互斥的解决原理。

2. 同步

         使用互斥解决多线程问题是一种简单有效的解决办法，但是由于该方法比较简单，所以只能解决一些基本的问题，对于复杂的问题就无法解决了。

         解 决多线程问题的另外一种思路是同步。同步是另外一种解决问题的思路，结合前面卫生间的示例，互斥方式解决多线程的原理是，当一个人进入到卫生间内部时，别 的人只能在外部时刻等待，这样就相当于别的人虽然没有事情做，但是还是要占用别的人的时间，浪费系统的执行资源。而同步解决问题的原理是，如果一个人进入 到卫生间内部时，则别的人可以去睡觉，不占用系统资源，而当这个人从卫生间出来以后，把这个睡觉的人叫醒，则它就可以使用临界资源了。所以使用同步的思路 解决多线程问题更加有效，更加节约系统的资源。

 

         在常见的多线程问题解决中，同步问题的典型示例是“生产者-消费者”模型，也就是生产者线程只负责生产，消费者线程只负责消费，在消费者发现无内容可消费时则睡觉。下面举一个比较实际的例子——生活费问题。

         生 活费问题是这样的：学生每月都需要生活费，家长一次预存一段时间的生活费，家长和学生使用统一的一个帐号，在学生每次取帐号中一部分钱，直到帐号中没钱时 通知家长存钱，而家长看到帐户还有钱则不存钱，直到帐户没钱时才存钱。在这个例子中，这个帐号被学生和家长两个线程同时访问，则帐号就是临界资源，两个线 程是同时执行的，当每个线程发现不符合要求时则等待，并释放分配给自己的CPU执行时间，也就是不占用系统资源。实现该示例的代码为：

                   package syn4;

/**

 * 测试类

 */

public class TestAccount {

         public static void main(String[] args) {

                   Accout a = new Accout();

                   StudentThread s = new StudentThread(a);

                   GenearchThread g = new GenearchThread(a);

         }

}

package syn4;

/**

 * 模拟学生线程

 */

public class StudentThread extends Thread {

         Accout a;

         public StudentThread(Accout a){

                   this.a = a;

                   start();

         }

         public void run(){

                   try{

                            while(true){

                                     Thread.sleep(2000);

                                     a.getMoney(); //取钱

                            }

                   }catch(Exception e){}

         }

}

package syn4;

/**

 * 家长线程

 */

public class GenearchThread extends Thread {

         Accout a;

         public GenearchThread(Accout a){

                   this.a = a;

                   start();

         }

         public void run(){

                   try{

                            while(true){

                                     Thread.sleep(12000);

                                     a.saveMoney(); //存钱

                            }

                   }catch(Exception e){}

         }

}

package syn4;

/**

 * 银行账户

 */

public class Accout {

         int money = 0;

         /**

          * 取钱

          * 如果账户没钱则等待，否则取出所有钱提醒存钱

          */

         public synchronized void getMoney(){

                   System.out.println("准备取钱！");

                   try{

                            if(money == 0){

                                     wait(); //等待

                            }

                            //取所有钱

                            System.out.println("剩余:" + money);

                            money -= 50;

                            //提醒存钱

                            notify();

                   }catch(Exception e){}                

         }

        

         /**

          * 存钱

          * 如果有钱则等待，否则存入200提醒取钱

          */

         public synchronized void saveMoney(){

                   System.out.println("准备存钱！");

                   try{

                            if(money != 0){

                                     wait(); //等待

                            }

                            //取所有钱

                            money = 200;

                            System.out.println("存入:" + money);

                            //提醒存钱

                            notify();

                   }catch(Exception e){}                

         }

}

         该程序的一部分执行结果为：

                   准备取钱！

准备存钱！

存入:200

剩余:200

准备取钱！

剩余:150

准备取钱！

剩余:100

准备取钱！

剩余:50

准备取钱！

准备存钱！

存入:200

剩余:200

准备取钱！

剩余:150

准备取钱！

剩余:100

准备取钱！

剩余:50

准备取钱！

         在该示例代码中，TestAccount类是测试类，主要实现创建帐户Account类的对象，以及启动学生线程StudentThread和启动家长线程GenearchThread。在StudentThread线程中，执行的功能是每隔2秒中取一次钱，每次取50元。在GenearchThread线程中，执行的功能是每隔12秒存一次钱，每次存200。这样存款和取款之间不仅时间间隔存在差异，而且数量上也会出现交叉。而该示例中，最核心的代码是Account类的实现。

         在Account类中，实现了同步控制功能，在该类中包含一个关键的属性money，该属性的作用是存储帐户金额。在介绍该类的实现前，首先介绍一下两个同步方法——wait和notify方法的使用，这两个方法都是Object类中的方法，也就是说每个类都包含这两个方法，换句话说，就是Java天生就支持同步处理。这两个方法都只能在synchronized修饰的方法或语句块内部采用被调用。其中wait方法的作用是使调用该方法的线程休眠，也就是使该线程退出CPU的等待队列，处于冬眠状态，不执行动作，也不占用CPU排队的时间，notify方法的作用是唤醒一个任意该对象的线程，该线程当前处于休眠状态，至于唤醒的具体是那个则不保证。在Account类中，被StudentThread调用的getMoney方法的功能是判断当前金额是否是0，如果是则使StudentThread线程处于休眠状态，如果金额不是0，则取出50元，同时唤醒使用该帐户对象的其它一个线程，而被GenearchThread线程调用的saveMoney方法的功能是判断当前是否不为0，如果是则使GenearchThread线程处于休眠状态，如果金额是0，则存入200元，同时唤醒使用该帐户对象的其它一个线程。

         如果还是不清楚，那就结合前面的程序执行结果来解释一下程序执行的过程：在程序开始执行时，学生线程和家长线程都启动起来，所以输出“准备取钱”和“准备存钱”，然后学生线程按照该线程run方法的逻辑执行，先延迟2秒，然后调用帐户对象a中的getMoney方法，但是由于初始情况下帐户对象a中的money数值为0，所以学生线程就休眠了。在学生线程执行的同时，家长线程也按照该线程的run方法的逻辑执行，先延迟12秒，然后调用帐户对象a中的saveMoney方法，由于帐户a对象中的money为零，条件不成立，所以执行存入200元，同时唤醒线程，由于使用对象a的线程现在只有学生线程，所以学生线程被唤醒，开始执行逻辑，取出50元，然后唤醒线程，由于当前没有线程处于休眠状态，所以没有线程被唤醒。同时家长线程继续执行，先延迟12秒，这个时候学生线程执行了4次，耗时4X2秒=8秒，就取光了帐户中的钱，接着由于帐户为0则学生线程又休眠了，一直到家长线程延迟12秒结束以后，判断帐户为0，又存入了200元，程序继续执行下去。

         在解决多线程问题是，互斥和同步都是解决问题的思路，如果需要形象的比较这两种方式的区别的话，就看一下下面的示例。一个比较忙的老总，桌子上有2部电话，在一部处于通话状态时，另一部响了，老总拿其这部电话说我在接电话，你等一下，而没有挂电话，这种处理的方式就是互斥。而如果老总拿其另一部电话说，我在接电话，等会我打给你，然后挂了电话，这种处理的方式就是同步。两者相比，互斥明显占用系统资源(浪费电话费，浪费别人的时间)，而同步则是一种更加好的解决问题的思路。

3. 死锁

         多线程编程在实际的网络程序开发中，在客户端程序实现中使用的比较简单，但是在服务器端程序实现中却不仅是大量使用，而且会出现比客户端更多的问题。

         另 外一个容易在服务器端出现的多线程问题是——死锁。死锁指两个或两个以上的线程为了使用某个临界资源而无限制的等待下去。还是以前面卫生间的例子来说明死 锁，例如两个人都同时到达卫生间，而且两个人都比较礼貌，第一个人和第二个人说：你先吧，第二个人和第一个人说：你先吧。这两个人就这样一直在互相礼让， 谁也不进入，这种现象就是死锁。这里的两个人就好比是线程，而卫生间在这里就是临界资源，而由于这两个线程在一直谦让，谁也不使用临界资源。

         死锁不仅使程序无法达到预期实现的功能，而且浪费系统的资源，所以在服务器端程序中危害比较大，在实际的服务器端程序开发中，需要注意避免死锁。

         而死锁的检测比较麻烦，而且不一定每次都出现，这就需要在测试服务器端程序时，有足够的耐心，仔细观察程序执行时的性能检测，如果发现执行的性能显著降低，则很可能是发生了死锁，然后再具体的查找死锁出现的原因，并解决死锁的问题。

         死锁出现的最本质原因还是逻辑处理不够严谨，在考虑时不是很周全，所以一般需要修改程序逻辑才能够很好的解决死锁。

4. 线程优先级

         在日常生活中，例如火车售票窗口等经常可以看到“XXX优先”，那么多线程编程中每个线程是否也可以设置优先级呢？

         在多线程编程中，支持为每个线程设置优先级。优先级高的线程在排队执行时会获得更多的CPU执行时间，得到更快的响应。在实际程序中，可以根据逻辑的需要，将需要得到及时处理的线程设置成较高的优先级，而把对时间要求不高的线程设置成比较低的优先级。

         在Thread类中，总计规定了三个优先级，分别为：

l MAX_PRIORITY——最高优先级

l NORM_PRIORITY——普通优先级，也是默认优先级

l MIN_PRIORITY——最低优先级

在前面创建的线程对象中，由于没有设置线程的优先级，则线程默认的优先级是NORM_PRIORITY，在实际使用时，也可以根据需要使用Thread类中的setPriority方法设置线程的优先级，该方法的声明为：

         public final void setPriority(int newPriority)

假设t是一个初始化过的线程对象，需要设置t的优先级为最高，则实现的代码为：

         t. setPriority(Thread. MAX_PRIORITY);

这样，在该线程执行时将获得更多的执行机会，也就是优先执行。如果由于安全等原因，不允许设置线程的优先级，则会抛出SecurityException异常。

下面使用一个简单的输出数字的线程演示线程优先级的使用，实现的示例代码如下：

         package priority;

/**

 * 测试线程优先级

 */

public class TestPriority {

         public static void main(String[] args) {

                   PrintNumberThread p1 = new PrintNumberThread("高优先级");

                   PrintNumberThread p2 = new PrintNumberThread("普通优先级");

                   PrintNumberThread p3 = new PrintNumberThread("低优先级");

                   p1.setPriority(Thread.MAX_PRIORITY);

                   p2.setPriority(Thread.NORM_PRIORITY);

                   p3.setPriority(Thread.MIN_PRIORITY);

                   p1.start();

                   p2.start();

                   p3.start();

         }

}

package priority;

/**

 * 输出数字的线程

 */

public class PrintNumberThread extends Thread {

         String name;

         public PrintNumberThread(String name){

                   this.name = name;

         }

         public void run(){

                   try{

                            for(int i = 0;i < 10;i++){

                                     System.out.println(name + ":" + i);

                            }

                   }catch(Exception e){}

         }

}

程序的一种执行结果为：

高优先级:0

高优先级:1

高优先级:2

普通优先级:0

高优先级:3

普通优先级:1

高优先级:4

普通优先级:2

高优先级:5

高优先级:6

高优先级:7

高优先级:8

高优先级:9

普通优先级:3

普通优先级:4

普通优先级:5

普通优先级:6

普通优先级:7

普通优先级:8

普通优先级:9

低优先级:0

低优先级:1

低优先级:2

低优先级:3

低优先级:4

低优先级:5

低优先级:6

低优先级:7

低优先级:8

低优先级:9

         在该示例程序，PrintNumberThread线程实现的功能是输出数字，每次数字输出之间没有设置时间延迟，在测试类TestPriority中创建三个PrintNumberThread类型的线程对象，然后分别设置线程优先级是最高、普通和最低，接着启动线程执行程序。从执行结果可以看出高优先级的线程获得了更多的执行时间，首先执行完成，而低优先级的线程由于优先级较低，所以最后一个执行结束。

         其实，对于线程优先级的管理主要由系统的线程调度实现，较高优先级的线程优先执行，所以可以通过设置线程的优先级影响线程的执行。