Java高级篇（一）——线程

清疚 2021-12-21 06:49 231阅读 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()方法，运行结果如下：

![1018770-20180326211918465-1592834983.png][]

如果不调用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()方法执行完毕时线程进入死亡状态。（具体内容可参考操作系统）

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

![1018770-20180326213758422-1099741618.png][]

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

### 　　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 }

运行结果如下：

![1018770-20180326224559584-1275137303.png][]

这里出现了剩余-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-- + "张");
        } 
    }

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

![1018770-20180326225706000-1175038514.png][]

## 六、线程实例测试 ##

下面举一个完整的例子。

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

### 　　1. 程序结构 ###

![1018770-20180326230951282-1717138315.png][]

### 　　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. 运行结果 ###

![1018770-20180326231806593-867405148.png][]

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

这里再给另一种简单的代码，换了一种方法，可以自行理解。如下对随机产生的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 }

转载于:https://www.cnblogs.com/adamjwh/p/8654008.html

[1018770-20180326211918465-1592834983.png]: /images/20211221/fd4f086ead364fc0aa5aa83777d91202.png
[1018770-20180326213758422-1099741618.png]: /images/20211221/4c9cbe5b32064bdf9d6ad8df5b75a0ea.png
[1018770-20180326224559584-1275137303.png]: /images/20211221/7114291560da49f8ae3965cfab575717.png
[1018770-20180326225706000-1175038514.png]: /images/20211221/e6d5b89342cc4d5eb1c326b620f047df.png
[1018770-20180326230951282-1717138315.png]: /images/20211221/85f16ee7ec894ba7b0ab062459c08aee.png
[1018770-20180326231806593-867405148.png]: /images/20211221/f476f930c7af46639ea76dbcfaff52f9.png