Java高级篇（一）——线程

　　前面我们系统的了解了Java的基础知识，本篇开始将进入到Java更深层次的介绍，我们先来介绍一下Java中的一个重要的概念——线程。

一、什么是线程

　　在了解线程前，我们首先要了解进程的概念。进程是操作系统调度和分配资源的基本单位，进程之间的通信需要通过专门的系统机制，比如消息、socket和管道来完成。而线程是比进程更小的执行单位，每个线程拥有自己的栈和寄存器等资源数据，多个线程之间共享进程的代码、数据和文件。

　　那为什么要引入线程的概念？或者说线程有什么优点？

　　举个简单的例子，我们在使用电脑时，可以使用它听歌，可以使用它打印文件，也可以使用它看电影，而这些活动完全可以同时进行，这种思想在Java中被称为并发，线程就是并发完成的每一件事情。

　　线程的优点有如下几条：

1. 创建一个线程比创建一个进程的代价要小
2. 线程的切换比进程间的切换代价小
3. 充分利用多处理器
4. 数据共享（数据共享使得线程之间的通信比进程间的通信更高效）
5. 快速响应特性（在系统繁忙的情况下，进程通过独立的线程及时响应用户的输入 ）

　　在单线程中，程序代码按调用顺序依次往下执行，如果需要一个进程同时完成多段代码的操作，就需要产生多线程。

二、线程的实现

　　在Java中主要提供了两种方式实现线程，下面分别介绍一下这两种方式。

　　1. 继承Thread类

　　在Java中可通过继承java.lang.Thread类来实现线程，语法格式如下：

public class MyThread extends Thread {
    //...
}

　　而完成线程真正功能的代码在run()方法中，且run()方法的语法格式固定，如下：

public void run() {
    //...
}

　　之后通过调用start()方法启动线程，如果start()方法调用一个已经启动的线程，会抛出IllegalThreadStateException异常。

　　下面看一个实例。

public class MyThread extends Thread {

    private static int i=0;
    
    public void run() {
        i++;    
        System.out.println(i);    
    }
    
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        MyThread myThread3 = new MyThread();
        myThread1.start();
        myThread2.start();
        myThread3.start();
    }
}

　　这里定义了三个线程，分别执行start()方法，运行结果如下：

　　

　　如果不调用start()方法，线程永远都不会启动，在主方法没有调用start()方法之前，Thread对象只是一个实例，而不是一个真正的线程。

　　2. 实现Runnable接口

　　我们知道每次只能继承一个类，如果此时要在使用线程的前提下还要继承其他类，就需要使用Runnable接口了。语法格式如下：

public class MyThread implements Runnable {
    //...
}

　　如果还要继承其他类，语法格式如下：

public class MyThread extends Object implements Runnable {
    //...
}

　　实现Runnable接口的程序会创建一个Thread对象，并将Runnable对象与Thread对象相关联。例如如下代码：

new Thread(new Runnable(){

　　@Override
　　public void run() {
　　　　i++;    
　　　　System.out.println(i);    
　　}

}).start();

　　在Thread对象中实现Runnable接口，并将其start()。

三、生命周期

　　线程的生命周期包含出生状态、就绪状态、运行状态、等待状态、休眠状态、阻塞状态和死亡状态7种状态。当用户创建线程时线程处于出生状态；在用户调用start()方法后线程处于就绪状态；当线程得到资源后进入运行状态；当在运行态调用wait()方法时线程处于等待状态，此时必须调用notify()方法才能被唤醒，notifyAll()可以唤醒所有处于等待状态下的线程；当线程调用sleep()方法时会进入休眠状态；如果一个线程在运行状态下发出输入/输出请求，该线程将进入阻塞状态，在其等待输入/输出结束时线程进入就绪状态；当线程的run()方法执行完毕时线程进入死亡状态。（具体内容可参考操作系统）

　　下图为线程生命周期状态图，可对照上述文字加以理解。

　　

四、线程的休眠/加入/中断/礼让

　　1. 线程的休眠(sleep)

　　调用sleep()方法，该方法需要一个参数用于指定线程休眠时间，单位为ms，通常用在run()方法内的循环中被使用，注意要使用try···catch包围。语法格式如下：

try {
    Thread.sleep(1000);
} catch(InterruptedException e) {
    e.printStackTrace();
}

　　使用了sleep()方法的线程在一段时间内会醒来，但是并不能保证它醒来后进入运行状态，只能保证它进入就绪状态。

　　2. 线程的加入(join)

　　假设有一个线程A，现在需要插入线程B，并要求线程B先执行完毕，然后再继续执行线程A，此时可以使用join()方法来完成。当某个线程使用join()方法加入到另一个线程时，另一个线程会等待该线程执行完毕再继续执行。语法格式如下：

Thread.join();

　　3. 线程的中断(stop/interrupt)

　　stop()方法可以停止线程，但JDK早已废除，同时也不建议使用stop()方法来停止一个线程的运行。可在run()方法中使用无限循环的形式，然后使用一个布尔型标记控制循环的停止。如下：

public class InterruptedTest implements Runnable {

    private boolean isContinue = false;        //标记变量，默认值为false
    
    @Override
    public void run() {
        while(true) {
            //... 此部分代码省略
            if(isContinue) {        //为true时，停止线程
                break;
            }
        }
    }
    
}

　　如果线程因为使用了sleep()或wait()方法进入了就绪状态，这时可以使用Thread类中的interrupt()方法使线程离开run()方法，同时结束线程，但会抛出InterruptedException异常。语法格式如下：

Thread.interrupt();

　　4. 程序的礼让(yield)

　　Thread类中提供了一种礼让方法yield()，用于给当前正处于运行状态下的线程一个提醒，告知它可以将资源礼让给其他线程。

　　yield()方法使具有同样优先级的线程有进入可执行状态的机会，当当前线程放弃执行权时会再度回到就绪状态。

五、线程同步

　　多线程中，可能会发生两个线程抢占资源的问题，例如两个人同时过一个独木桥。所以Java提供线程同步机制来防止这些资源访问的冲突。

　　1. 线程同步机制

　　在多线程中，多个线程共享同一个资源可能会出现一些问题，比如下面这个例子，火车售票系统。

public class ThreadSafeTest implements Runnable {

    int num = 10;
    
    @Override
    public void run() {
        while(true) {
            if(num>0) {
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("车票剩余：" + num-- + "张");
            }
        }
    }

    public static void main(String[] args) {
        ThreadSafeTest test = new ThreadSafeTest();
        Thread tA = new Thread(test);        //实例化4个线程
        Thread tB = new Thread(test);
        Thread tC = new Thread(test);
        Thread tD = new Thread(test);
        tA.start();        //启动线程
        tB.start();
        tC.start();
        tD.start();
    }
    
}

　　运行结果如下：

　　

　　这里出现了剩余-1张的情况，究其原因是因为同时创建了4个线程，都执行run()方法时，四个线程对num都有储存功能，当线程1执行run()方法时，还没来得及递减，此时线程2、3、4都进入了run()方法，发现num仍大于0，但此时线程1休眠时间已到，将num变量递减，同时线程2、3、4也对num变量进行递减操作，从而产生了负值。同理出现多次十张的情况也是互相抢占了资源。换句话说就是产生了资源冲突问题，为了解决这种问题，就需要给共享资源上一道锁。最简单的例子就是上洗手间，一个人进去后要将门锁上，当他出来时再将锁打开，然后其他人才可以进。

　　我们使用同步块或同步方法来实现加锁操作。语法结构分别如下：

synchronzied(Object) {
    //... 
}

synchronzied void test() {
    //...
}

　　可将上述代码改为

public class ThreadSafeTest implements Runnable {

    int num = 10;
    
    @Override
    public void run() {
        while(true) {
            synchronized ("") {        //加锁        
                if(num>0) {
                    try {
                        Thread.sleep(100);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    System.out.println("车票剩余：" + num-- + "张");
                }
            }
        }
    }

    public static void main(String[] args) {
        ThreadSafeTest test = new ThreadSafeTest();
        Thread tA = new Thread(test);        //实例化4个线程
        Thread tB = new Thread(test);
        Thread tC = new Thread(test);
        Thread tD = new Thread(test);
        tA.start();        //启动线程
        tB.start();
        tC.start();
        tD.start();
    }
    
}

　　也可以用同步方法如下：

public synchronized void doit() {        //定义同步方法
    if(num>0) {
        try {
            Thread.sleep(100);
        } catch (Exception e) {
            e.printStackTrace();
        }
    System.out.println("车票剩余：" + num-- + "张");
    } 
}

　　两种方法运行结果一致，运行结果如下：

　　

六、线程实例测试

　　下面举一个完整的例子。

　　对归并排序使用多线程进行求解，排序数据量不少于1M。

　　1. 程序结构

　　

　　2. MakeArrays.java

　　该类用于创建一个1M的随机测试数组，用于保证样本的统一性（串行与并行使用同一个数组）。

import java.util.Random;

public class MakeArrays {

    private int length = 1024*1024;
    
    public int[] makeArray() {
        int[] array = new int[length];
        
        Random random = new Random();
        for(int i=0; i<length; i++) {
            int x = random.nextInt();
            array[i] = x;
        }
        
        return array;
    }
    
}

　　3. MergeSort.java

　　此部分用来编写归并排序算法。

public class MergeSort {

    public static void sort(int[] array){
        int length = array.length;
        int[] tmpArray = new int[ length ];
        sort(array, tmpArray, 0, length-1);
    }

    public static void sort(int[] array, int[] tmpArray, int left, int right){
        if(left < right){
            int center = (left + right)/2;    //取中间值
            sort(array, tmpArray, left, center);    //递归分解
            sort(array, tmpArray, center+1, right);    //递归分解
            merge(array, tmpArray, left, center+1, right);    //合并排序
        }
    }

    private static void merge(int[] array, int[] tmpArray, int leftStart, int rightStart, int rightEnd) {
        int leftEnd = rightStart - 1;    //左侧数组截止下标
        int tmpPos = leftStart;    //数组坐标
        int total = rightEnd - leftStart + 1;    //需要合并的数组元素数量

        while(leftStart <= leftEnd && rightStart <= rightEnd){
            if(array[ leftStart ] <= array[ rightStart ]){
                //如果左侧数组元素小于或等于右侧数组元素，将左侧数组元素的值存入临时数组，并移动左侧数组下标
                tmpArray[ tmpPos++ ] = array[ leftStart++ ];
            }else{
                //如果左侧数组元素大于右侧数组元素，将右侧数组元素的值存入临时数组，并移动右侧数组下标
                tmpArray[ tmpPos++ ] = array[ rightStart++ ];
            }
        }

        //如果左侧数组元素没有全部存入临时数组，将剩余元素循环写入临时数组
        while(leftStart <= leftEnd){
            tmpArray[ tmpPos++ ] = array[ leftStart++ ];
        }

        //如果右侧数组元素没有全部存入临时数组，将剩余元素循环写入临时数组
        while(rightStart <= rightEnd){
            tmpArray[ tmpPos++ ] = array[ rightStart++ ];
        }

        //将临时数组中排序好的元素写入原数组
        for(int i = 0; i < total; i++, rightEnd-- ){
            array[ rightEnd ] = tmpArray[ rightEnd ];
        }

    }

}

　　4. SerialDemo.java

　　该类为串行代码，即不使用线程的情况下直接调用归并排序算法。

public class SerialDemo2_5 {

    public void mergeSort(int[] array) {
        //归并排序
        MergeSort.sort(array);
    }
    
}

　　5. ThreadDemo.java

　　该类为并行代码，即使用多线程的情况下调用归并排序算法，这里以两个线程为例，将前面的1M的数组平均分为两份，分别交给这两个线程进行归并排序处理，然后再对其合并排序，得到最终的数组。

import java.util.concurrent.CountDownLatch;

public class ThreadDemo2_5 {

    public void mergeSort(int[] array) throws InterruptedException {
        int length = array.length;
        
        int minLength = length/2;
        int[] a = new int[minLength];
        int[] b = new int[minLength];

        for(int i=0; i<2; i++){
            int start = minLength * i;
            int end = minLength * (i + 1);

            if(i==0){
                for(int j=start, k=0; j<end; j++,k++){
                    a[k] = array[j];
                }
            }else if(i==1){
                for(int j=start, k=0; j<end; j++,k++){
                    b[k] = array[j];
                }
            }
        }

        //使用CountDownLatch来确保两个子线程都处理完毕后才执行最后的归并操作
        CountDownLatch latch = new CountDownLatch(2);
        new Thread(new Runnable(){

            @Override
            public void run() {
                MergeSort.sort(a);
                latch.countDown();
            }

        }).start();

        new Thread(new Runnable(){
            @Override
            public void run() {
                MergeSort.sort(b);
                latch.countDown();
            }
        }).start();

        //等待
        latch.await();

        //合并两个有序序列
        merge(a, b, array);
        
    }

    //合并序列
    private static void merge(int[] a1, int[] a2, int[] tmpArray){
        int length1 = a1.length;
        int length2 = a2.length;

        int left = 0;
        int right = 0;
        int pos = 0;

        while(left < length1 && right < length2){
            if(a1[left] <= a2[right]){
                tmpArray[pos] = a1[left];
                left++;
            }else{
                tmpArray[pos] = a2[right];
                right++;
            }
            pos++;
        }

        while(left < length1){
            tmpArray[ pos++ ] = a1[ left++ ];
        }

        while(right < length2){
            tmpArray[ pos++ ] = a2[ right++ ];
        }

    }
    
}

　　6. Main.java

　　这里为主函数用于测试串行与并行的时间有何差别。

public class MainEx2_5 {
    
    private static int[] array = new MakeArrays().makeArray();
    
    /**
     * 测试函数
     * @param args
     * ms : currentTimeMillis
     * ns : nanoTime
     */
    public static void main(String[] args) {
        /**
         * 串行测试
         */
        long startTime = System.currentTimeMillis();   //获取开始时间
        new SerialDemo2_5().mergeSort(array);  //测试的代码段
        long endTime = System.currentTimeMillis(); //获取结束时间
        System.out.println("串行使用的时间： "+(endTime-startTime)+"ms");
        
        /**
         * 线程测试
         */
        long startTime1 = System.currentTimeMillis();   //获取开始时间
        try {
            new ThreadDemo2_5().mergeSort(array);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }  //测试的代码段
        long endTime1 = System.currentTimeMillis(); //获取结束时间
        System.out.println("线程使用的时间： "+(endTime1-startTime1)+"ms");
    }

}

　　7. 运行结果

　　

　　从这里可以看出并行的时间比线程少了很多，提高了效率。

　　这里再给另一种简单的代码，换了一种方法，可以自行理解。如下对随机产生的1M-10M的数组进行求和，这里只给出线程部分的代码（这个代码可以实现线程数自定）。

public class ThreadDemo1_1 {

    /**
     * 对数组求和
     * @param array 数组
     * @param threadCount 线程数
     * @return 数组元素和
     */
    public long sumArray(final int[] array, int threadCount) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException("数组长度必须大于0");
        }

        final RuntimeSave rd = new RuntimeSave();     // 保存数据
        final int lenPerThread = array.length / threadCount;  // 计算每个线程的数组元素个数
        
        for (int i = 0; i < threadCount; i++) {
            final int index = i;
            new Thread() {
                @Override
                public void run() {
                    long s = 0;
                    int start = index * lenPerThread;
                    int end = start + lenPerThread;
                    
                    for (int j = start; j < end; j++) {
                        s += array[j];
                    }
                    synchronized (rd) {
                        rd.sum += s;
                        rd.finishThreadCount++;
                    }
                };
            }.start();
        }
   
        int remain = array.length % threadCount;      // 剩余数组元素
        long s = 0;
        
        for (int i = array.length - remain; i < array.length; i++) {
            s += array[i];  
        }
        synchronized (rd) {  
            rd.sum += s;
        }
        
        while (rd.finishThreadCount != threadCount) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
                break;
            }  
        }  
        return rd.sum;
    }
    
    /**
     * 保存运行时的相关数据
     * @author adamjwh
     *
     */
    static class RuntimeSave {
        long sum;  // 保存求和
        int finishThreadCount;  // 已执行完毕的线程数
    }
}