多线程与多进程(3)

原文：http://blog.csdn.net/luoweifu/article/details/46673975
作者:luoweifu
转载请标名出处

单线程

任何程序至少有一个线程，即使你没有主动地创建线程，程序从一开始执行就有一个默认的线程，被称为主线程，只有一个线程的程序称为单线程程序。如下面这一简单的代码，没有显示地创建一个线程，程序从main开始执行，main本身就是一个线程(主线程)，单个线程从头执行到尾。

【Demo1】：单线程程序

1 public static void main(String args[]) {
2    System.out.println("输出从1到100的数:");
3    for (int i = 0; i < 100; i ++) {
4       System.out.println(i + 1);
5    }
6 }

创建线程

单线程程序简单明了，但有时无法满足特定的需求。如一个文字处理的程序，我在打印文章的同时也要能对文字进行编辑，如果是单线程的程序则要等打印机打印完成之后你才能对文字进行编辑，但打印的过程一般比较漫长，这是我们无法容忍的。如果采用多线程，打印的时候可以单独开一个线程去打印，主线程可以继续进行文字编辑。在程序需要同时执行多个任务时，可以采用多线程。

在程序需要同时执行多个任务时，可以采用多线程。Java给多线程编程提供了内置的支持，提供了两种创建线程方法：1.通过实现Runable接口；2.通过继承Thread类。

Thread是JDK实现的对线程支持的类，Thread类本身实现了Runnable接口，所以Runnable是显示创建线程必须实现的接口; Runnable只有一个run方法，所以不管通过哪种方式创建线程，都必须实现run方法。我们可以看一个例子。

【Demo2】：线程的创建和使用

 1 /**
 2  * Created with IntelliJ IDEA.
 3  * User: luoweifu
 4  * Date: 15-5-24
 5  * Time: 下午9:30
 6  * To change this template use File | Settings | File Templates.
 7  */
 8 
 9 /**
10  * 通过实现Runnable方法
11  */
12 class ThreadA implements Runnable {
13    private Thread thread;
14    private String threadName;
15    public ThreadA(String threadName) {
16       thread = new Thread(this, threadName);
17       this.threadName = threadName;
18    }
19 
20    //实现run方法
21    public void run() {
22       for (int i = 0; i < 100; i ++) {
23          System.out.println(threadName + ": " + i);
24       }
25    }
26 
27    public void start() {
28       thread.start();
29    }
30 }
31 
32 /**
33  * 继承Thread的方法
34  */
35 class ThreadB extends Thread {
36    private String threadName;
37 
38    public ThreadB(String threadName) {
39       super(threadName);
40       this.threadName = threadName;
41    }
42 
43    //实现run方法
44    public void run() {
45       for (int i = 0; i < 100; i ++) {
46          System.out.println(threadName + ": " + i);
47       }
48    }
49 }
50 
51 public class MultiThread{
52 
53    public static void main(String args[]) {
54       ThreadA threadA = new ThreadA("ThreadA");
55       ThreadB threadB = new ThreadB("ThreadB");
56       threadA.start();
57       threadB.start();
58    }
59 }

说明：上面的例子中例举了两种实现线程的方式。大部分情况下选择实现Runnable接口的方式会优于继承Thread的方式，因为：
1. 从 Thread 类继承会强加类层次；
2. 有些类不能继承Thread类，如要作为线程运行的类已经是某一个类的子类了，但Java只支持单继承，所以不能再继承Thread类了。

线程同步

线程与线程之间的关系，有几种:

模型一：简单的线程，多个线程同时执行，但各个线程处理的任务毫不相干，没有数据和资源的共享，不会出现争抢资源的情况。这种情况下不管有多少个线程同时执行都是安全的，其执行模型如下：

图 1：处理相互独立的任务

模型二：复杂的线程，多个线程共享相同的数据或资源，就会出现多个线程争抢一个资源的情况。这时就容易造成数据的非预期(错误)处理，是线程不安全的，其模型如下:

图 2：多个线程共享相同的数据或资源

在出现模型二的情况时就要考虑线程的同步，确保线程的安全。Java中对线程同步的支持，最常见的方式是添加synchronized同步锁。

我们通过一个例子来看一下线程同步的应用。

买火车票是大家春节回家最为关注的事情，我们就简单模拟一下火车票的售票系统(为使程序简单，我们就抽出最简单的模型进行模拟)：有500张从北京到赣州的火车票，在8个窗口同时出售，保证系统的稳定性和数据的原子性。

图 3：模拟火车票售票系统

【Demo3】：火车票售票系统模拟程序

 1 /**
 2  * 模拟服务器的类
 3  */
 4 class Service {
 5    private String ticketName;    //票名
 6    private int totalCount;        //总票数
 7    private int remaining;        //剩余票数
 8 
 9    public Service(String ticketName, int totalCount) {
10       this.ticketName = ticketName;
11       this.totalCount = totalCount;
12       this.remaining = totalCount;
13    }
14 
15    public synchronized int saleTicket(int ticketNum) {
16       if (remaining > 0) {
17          remaining -= ticketNum;
18          try {        //暂停0.1秒，模拟真实系统中复杂计算所用的时间
19             Thread.sleep(100);
20          } catch (InterruptedException e) {
21             e.printStackTrace();
22          }
23 
24          if (remaining >= 0) {
25             return remaining;
26          } else {
27             remaining += ticketNum;
28             return -1;
29          }
30       }
31       return -1;
32    }
33 
34    public synchronized int getRemaining() {
35       return remaining;
36    }
37 
38    public String getTicketName() {
39       return this.ticketName;
40    }
41 
42 }
43 
44 /**
45  * 售票程序
46  */
47 class TicketSaler implements Runnable {
48    private String name;
49    private Service service;
50 
51    public TicketSaler(String windowName, Service service) {
52       this.name = windowName;
53       this.service = service;
54    }
55 
56    @Override
57    public void run() {
58       while (service.getRemaining() > 0) {
59          synchronized (this)
60          {
61             System.out.print(Thread.currentThread().getName() + "出售第" + service.getRemaining() + "张票，");
62             int remaining = service.saleTicket(1);
63             if (remaining >= 0) {
64                System.out.println("出票成功!剩余" + remaining + "张票.");
65             } else {
66                System.out.println("出票失败！该票已售完。");
67             }
68          }
69       }
70    }
71 }

测试程序：

 1 /**
 2  * 测试类
 3  */
 4 public class TicketingSystem {
 5    public static void main(String args[]) {
 6       Service service = new Service("北京-->赣州", 500);
 7       TicketSaler ticketSaler = new TicketSaler("售票程序", service);
 8       //创建8个线程，以模拟8个窗口
 9       Thread threads[] = new Thread[8];
10       for (int i = 0; i < threads.length; i++) {
11          threads[i] = new Thread(ticketSaler, "窗口" + (i + 1));
12          System.out.println("窗口" + (i + 1) + "开始出售 " + service.getTicketName() + " 的票...");
13          threads[i].start();
14       }
15 
16    }
17 }

结果如下：

窗口1开始出售北京–>赣州的票…
窗口2开始出售北京–>赣州的票…
窗口3开始出售北京–>赣州的票…
窗口4开始出售北京–>赣州的票…
窗口5开始出售北京–>赣州的票…
窗口6开始出售北京–>赣州的票…
窗口7开始出售北京–>赣州的票…
窗口8开始出售北京–>赣州的票…
窗口1出售第500张票，出票成功!剩余499张票.
窗口1出售第499张票，出票成功!剩余498张票.
窗口6出售第498张票，出票成功!剩余497张票.
窗口6出售第497张票，出票成功!剩余496张票.
窗口1出售第496张票，出票成功!剩余495张票.
窗口1出售第495张票，出票成功!剩余494张票.
窗口1出售第494张票，出票成功!剩余493张票.
窗口2出售第493张票，出票成功!剩余492张票.
窗口2出售第492张票，出票成功!剩余491张票.
窗口2出售第491张票，出票成功!剩余490张票.
窗口2出售第490张票，出票成功!剩余489张票.
窗口2出售第489张票，出票成功!剩余488张票.
窗口2出售第488张票，出票成功!剩余487张票.
窗口6出售第487张票，出票成功!剩余486张票.
窗口6出售第486张票，出票成功!剩余485张票.
窗口3出售第485张票，出票成功!剩余484张票.
……

在上面的例子中，涉及到数据的更改的Service类saleTicket方法和TicketSaler类run方法都用了synchronized同步锁进行同步处理，以保证数据的准确性和原子性。

关于synchronized更详细的用法请参见：《Java中Synchronized的用法》

线程控制

在多线程程序中，除了最重要的线程同步外，还有其它的线程控制，如线程的中断、合并、优先级等。

线程等待(wait、notify、notifyAll)

Wait：使当前的线程处于等待状态；
Notify：唤醒其中一个等待线程；
notifyAll：唤醒所有等待线程。

详细用法参见：《 Java多线程中wait, notify and notifyAll的使用》

线程中断(interrupt)

在Java提供的线程支持类Thread中，有三个用于线程中断的方法：
public void interrupt(); 中断线程。
public static boolean interrupted(); 是一个静态方法，用于测试当前线程是否已经中断，并将线程的中断状态清除。所以如果线程已经中断，调用两次interrupted，第二次时会返回false，因为第一次返回true后会清除中断状态。
public boolean isInterrupted(); 测试线程是否已经中断。

【Demo4】：线程中断的应用

 1 /**
 2  * 打印线程
 3  */
 4 class Printer implements Runnable {
 5    public void run() {
 6       while (!Thread.currentThread().isInterrupted()) {     //如果当前线程未被中断，则执行打印工作
 7          System.out.println(Thread.currentThread().getName() + "打印中… …");
 8       }
 9       if (Thread.currentThread().isInterrupted()) {
10          System.out.println("interrupted:" +  Thread.interrupted());       //返回当前线程的状态，并清除状态
11          System.out.println("isInterrupted:" +  Thread.currentThread().isInterrupted());
12       }
13    }
14 }

调用代码：

 1 Printer printer = new Printer();
 2 Thread printerThread = new Thread(printer, "打印线程");
 3 printerThread.start();
 4 try {
 5    Thread.sleep(100);
 6 } catch (InterruptedException e) {
 7    e.printStackTrace();
 8 }
 9 System.out.println("有紧急任务出现，需中断打印线程.");
10 System.out.println("中断前的状态：" + printerThread.isInterrupted());
11 printerThread.interrupt();       // 中断打印线程
12 System.out.println("中断前的状态：" + printerThread.isInterrupted());

结果：

打印线程打印中… …
… …
打印线程打印中… …
有紧急任务出现，需中断打印线程.
打印线程打印中… …
中断前的状态：false
打印线程打印中… …
中断前的状态：true
interrupted:true
isInterrupted:false

线程合并(join)

所谓合并，就是等待其它线程执行完，再执行当前线程，执行起来的效果就好像把其它线程合并到当前线程执行一样。其执行关系如下：

图 4:线程合并的过程

public final void join()
等待该线程终止

public final void join(long millis);
等待该线程终止的时间最长为 millis 毫秒。超时为 0 意味着要一直等下去。

public final void join(long millis, int nanos)
等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒

这个常见的一个应用就是安装程序，很多大的软件都会包含多个插件，如果选择完整安装，则要等所有的插件都安装完成才能结束，且插件与插件之间还可能会有依赖关系。

【Demo5】:线程合并

 1 /**
 2  * 插件1
 3  */
 4 class Plugin1 implements Runnable {
 5 
 6    @Override
 7    public void run() {
 8       System.out.println("插件1开始安装.");
 9       System.out.println("安装中...");
10       try {
11          Thread.sleep(1000);
12       } catch (InterruptedException e) {
13          e.printStackTrace();
14       }
15       System.out.println("插件1完成安装.");
16    }
17 }
18 
19 /**
20  * 插件2
21  */
22 class Plugin2 implements Runnable {
23 
24    @Override
25    public void run() {
26       System.out.println("插件2开始安装.");
27       System.out.println("安装中...");
28       try {
29          Thread.sleep(2000);
30       } catch (InterruptedException e) {
31          e.printStackTrace();
32       }
33       System.out.println("插件2完成安装.");
34    }
35 }

合并线程的调用：

 1 System.out.println("主线程开启...");
 2 Thread thread1 = new Thread(new Plugin1());
 3 Thread thread2 = new Thread(new Plugin2());
 4 try {
 5    thread1.start();   //开始插件1的安装
 6    thread1.join();       //等插件1的安装线程结束
 7    thread2.start();   //再开始插件2的安装
 8    thread2.join();       //等插件2的安装线程结束,才能回到主线程
 9 } catch (InterruptedException e) {
10    e.printStackTrace();
11 }
12 System.out.println("主线程结束，程序安装完成！");

结果如下：

主线程开启…
插件1开始安装.
安装中…
插件1完成安装.
插件2开始安装.
安装中…
插件2完成安装.
主线程结束，程序安装完成！

优先级(Priority)

线程优先级是指获得CPU资源的优先程序。优先级高的容易获得CPU资源，优先级底的较难获得CPU资源，表现出来的情况就是优先级越高执行的时间越多。

Java中通过getPriority和setPriority方法获取和设置线程的优先级。Thread类提供了三个表示优先级的常量：MIN_PRIORITY优先级最低，为1；NORM_PRIORITY是正常的优先级；为5，MAX_PRIORITY优先级最高，为10。我们创建线程对象后，如果不显示的设置优先级的话，默认为5。

【Demo】:线程优先级

 1 /**
 2  * 优先级
 3  */
 4 class PriorityThread implements Runnable{
 5    @Override
 6    public void run() {
 7       for (int i = 0; i < 1000; i ++) {
 8          System.out.println(Thread.currentThread().getName() + ": " + i);
 9       }
10    }
11 }

调用代码：

 1 //创建三个线程
 2 Thread thread1 = new Thread(new PriorityThread(), "Thread1");
 3 Thread thread2 = new Thread(new PriorityThread(), "Thread2");
 4 Thread thread3 = new Thread(new PriorityThread(), "Thread3");
 5 //设置优先级
 6 thread1.setPriority(Thread.MAX_PRIORITY);
 7 thread2.setPriority(8);
 8 //开始执行线程
 9 thread3.start();
10 thread2.start();
11 thread1.start()

从结果中我们可以看到线程thread1明显比线程thread3执行的快。

如果您有什么疑惑和想法，请在评论处给予反馈，您的反馈就是最好的测评师！由于本人技术和能力有限，如果本博文有错误或不足之处，敬请谅解并给出您宝贵的建议！