0o霏霏o0 阅读(17) 评论(0)

  前面我们系统的了解了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异常。

  下面看一个实例。

 1 public class MyThread extends Thread {
 2 
 3     private static int i=0;
 4     
 5     public void run() {
 6         i++;    
 7         System.out.println(i);    
 8     }
 9     
10     public static void main(String[] args) {
11         MyThread myThread1 = new MyThread();
12         MyThread myThread2 = new MyThread();
13         MyThread myThread3 = new MyThread();
14         myThread1.start();
15         myThread2.start();
16         myThread3.start();
17     }
18 }

  这里定义了三个线程,分别执行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()方法中使用无限循环的形式,然后使用一个布尔型标记控制循环的停止。如下:

 1 public class InterruptedTest implements Runnable {
 2 
 3     private boolean isContinue = false;        //标记变量,默认值为false
 4     
 5     @Override
 6     public void run() {
 7         while(true) {
 8             //... 此部分代码省略
 9             if(isContinue) {        //为true时,停止线程
10                 break;
11             }
12         }
13     }
14     
15 }

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

Thread.interrupt();

  4. 程序的礼让(yield)

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

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

五、线程同步

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

  1. 线程同步机制

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

 1 public class ThreadSafeTest implements Runnable {
 2 
 3     int num = 10;
 4     
 5     @Override
 6     public void run() {
 7         while(true) {
 8             if(num>0) {
 9                 try {
10                     Thread.sleep(100);
11                 } catch (Exception e) {
12                     e.printStackTrace();
13                 }
14                 System.out.println("车票剩余:" + num-- + "张");
15             }
16         }
17     }
18 
19     public static void main(String[] args) {
20         ThreadSafeTest test = new ThreadSafeTest();
21         Thread tA = new Thread(test);        //实例化4个线程
22         Thread tB = new Thread(test);
23         Thread tC = new Thread(test);
24         Thread tD = new Thread(test);
25         tA.start();        //启动线程
26         tB.start();
27         tC.start();
28         tD.start();
29     }
30     
31 }

  运行结果如下:

  

  这里出现了剩余-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的随机测试数组,用于保证样本的统一性(串行与并行使用同一个数组)。

 1 import java.util.Random;
 2 
 3 public class MakeArrays {
 4 
 5     private int length = 1024*1024;
 6     
 7     public int[] makeArray() {
 8         int[] array = new int[length];
 9         
10         Random random = new Random();
11         for(int i=0; i<length; i++) {
12             int x = random.nextInt();
13             array[i] = x;
14         }
15         
16         return array;
17     }
18     
19 }

  3. MergeSort.java

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

 1 public class MergeSort {
 2 
 3     public static void sort(int[] array){
 4         int length = array.length;
 5         int[] tmpArray = new int[ length ];
 6         sort(array, tmpArray, 0, length-1);
 7     }
 8 
 9     public static void sort(int[] array, int[] tmpArray, int left, int right){
10         if(left < right){
11             int center = (left + right)/2;    //取中间值
12             sort(array, tmpArray, left, center);    //递归分解
13             sort(array, tmpArray, center+1, right);    //递归分解
14             merge(array, tmpArray, left, center+1, right);    //合并排序
15         }
16     }
17 
18     private static void merge(int[] array, int[] tmpArray, int leftStart, int rightStart, int rightEnd) {
19         int leftEnd = rightStart - 1;    //左侧数组截止下标
20         int tmpPos = leftStart;    //数组坐标
21         int total = rightEnd - leftStart + 1;    //需要合并的数组元素数量
22 
23         while(leftStart <= leftEnd && rightStart <= rightEnd){
24             if(array[ leftStart ] <= array[ rightStart ]){
25                 //如果左侧数组元素小于或等于右侧数组元素,将左侧数组元素的值存入临时数组,并移动左侧数组下标
26                 tmpArray[ tmpPos++ ] = array[ leftStart++ ];
27             }else{
28                 //如果左侧数组元素大于右侧数组元素,将右侧数组元素的值存入临时数组,并移动右侧数组下标
29                 tmpArray[ tmpPos++ ] = array[ rightStart++ ];
30             }
31         }
32 
33         //如果左侧数组元素没有全部存入临时数组,将剩余元素循环写入临时数组
34         while(leftStart <= leftEnd){
35             tmpArray[ tmpPos++ ] = array[ leftStart++ ];
36         }
37 
38         //如果右侧数组元素没有全部存入临时数组,将剩余元素循环写入临时数组
39         while(rightStart <= rightEnd){
40             tmpArray[ tmpPos++ ] = array[ rightStart++ ];
41         }
42 
43         //将临时数组中排序好的元素写入原数组
44         for(int i = 0; i < total; i++, rightEnd-- ){
45             array[ rightEnd ] = tmpArray[ rightEnd ];
46         }
47 
48     }
49 
50 }

  4. SerialDemo.java

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

1 public class SerialDemo2_5 {
2 
3     public void mergeSort(int[] array) {
4         //归并排序
5         MergeSort.sort(array);
6     }
7     
8 }

  5. ThreadDemo.java

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

 1 import java.util.concurrent.CountDownLatch;
 2 
 3 public class ThreadDemo2_5 {
 4 
 5     public void mergeSort(int[] array) throws InterruptedException {
 6         int length = array.length;
 7         
 8         int minLength = length/2;
 9         int[] a = new int[minLength];
10         int[] b = new int[minLength];
11 
12         for(int i=0; i<2; i++){
13             int start = minLength * i;
14             int end = minLength * (i + 1);
15 
16             if(i==0){
17                 for(int j=start, k=0; j<end; j++,k++){
18                     a[k] = array[j];
19                 }
20             }else if(i==1){
21                 for(int j=start, k=0; j<end; j++,k++){
22                     b[k] = array[j];
23                 }
24             }
25         }
26 
27         //使用CountDownLatch来确保两个子线程都处理完毕后才执行最后的归并操作
28         CountDownLatch latch = new CountDownLatch(2);
29         new Thread(new Runnable(){
30 
31             @Override
32             public void run() {
33                 MergeSort.sort(a);
34                 latch.countDown();
35             }
36 
37         }).start();
38 
39         new Thread(new Runnable(){
40             @Override
41             public void run() {
42                 MergeSort.sort(b);
43                 latch.countDown();
44             }
45         }).start();
46 
47         //等待
48         latch.await();
49 
50         //合并两个有序序列
51         merge(a, b, array);
52         
53     }
54 
55     //合并序列
56     private static void merge(int[] a1, int[] a2, int[] tmpArray){
57         int length1 = a1.length;
58         int length2 = a2.length;
59 
60         int left = 0;
61         int right = 0;
62         int pos = 0;
63 
64         while(left < length1 && right < length2){
65             if(a1[left] <= a2[right]){
66                 tmpArray[pos] = a1[left];
67                 left++;
68             }else{
69                 tmpArray[pos] = a2[right];
70                 right++;
71             }
72             pos++;
73         }
74 
75         while(left < length1){
76             tmpArray[ pos++ ] = a1[ left++ ];
77         }
78 
79         while(right < length2){
80             tmpArray[ pos++ ] = a2[ right++ ];
81         }
82 
83     }
84     
85 }

  6. Main.java

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

 1 public class MainEx2_5 {
 2     
 3     private static int[] array = new MakeArrays().makeArray();
 4     
 5     /**
 6      * 测试函数
 7      * @param args
 8      * ms : currentTimeMillis
 9      * ns : nanoTime
10      */
11     public static void main(String[] args) {
12         /**
13          * 串行测试
14          */
15         long startTime = System.currentTimeMillis();   //获取开始时间
16         new SerialDemo2_5().mergeSort(array);  //测试的代码段
17         long endTime = System.currentTimeMillis(); //获取结束时间
18         System.out.println("串行使用的时间: "+(endTime-startTime)+"ms");
19         
20         /**
21          * 线程测试
22          */
23         long startTime1 = System.currentTimeMillis();   //获取开始时间
24         try {
25             new ThreadDemo2_5().mergeSort(array);
26         } catch (InterruptedException e) {
27             // TODO Auto-generated catch block
28             e.printStackTrace();
29         }  //测试的代码段
30         long endTime1 = System.currentTimeMillis(); //获取结束时间
31         System.out.println("线程使用的时间: "+(endTime1-startTime1)+"ms");
32     }
33 
34 }

  7. 运行结果

  

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

 

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

 1 public class ThreadDemo1_1 {
 2 
 3     /**
 4      * 对数组求和
 5      * @param array 数组
 6      * @param threadCount 线程数
 7      * @return 数组元素和
 8      */
 9     public long sumArray(final int[] array, int threadCount) {
10         if (array == null || array.length == 0) {
11             throw new IllegalArgumentException("数组长度必须大于0");
12         }
13 
14         final RuntimeSave rd = new RuntimeSave();     // 保存数据
15         final int lenPerThread = array.length / threadCount;  // 计算每个线程的数组元素个数
16         
17         for (int i = 0; i < threadCount; i++) {
18             final int index = i;
19             new Thread() {
20                 @Override
21                 public void run() {
22                     long s = 0;
23                     int start = index * lenPerThread;
24                     int end = start + lenPerThread;
25                     
26                     for (int j = start; j < end; j++) {
27                         s += array[j];
28                     }
29                     synchronized (rd) {
30                         rd.sum += s;
31                         rd.finishThreadCount++;
32                     }
33                 };
34             }.start();
35         }
36    
37         int remain = array.length % threadCount;      // 剩余数组元素
38         long s = 0;
39         
40         for (int i = array.length - remain; i < array.length; i++) {
41             s += array[i];  
42         }
43         synchronized (rd) {  
44             rd.sum += s;
45         }
46         
47         while (rd.finishThreadCount != threadCount) {
48             try {
49                 Thread.sleep(1);
50             } catch (InterruptedException e) {
51                 e.printStackTrace();
52                 break;
53             }  
54         }  
55         return rd.sum;
56     }
57     
58     /**
59      * 保存运行时的相关数据
60      * @author adamjwh
61      *
62      */
63     static class RuntimeSave {
64         long sum;  // 保存求和
65         int finishThreadCount;  // 已执行完毕的线程数
66     }
67 }