Java高级篇（一）——线程
前面我们系统的了解了Java的基础知识，本篇开始将进入到Java更深层次的介绍，我们先来介绍一下Java中的一个重要的概念——线程。
一、什么是线程
在了解线程前，我们首先要了解进程的概念。进程是操作系统调度和分配资源的基本单位，进程之间的通信需要通过专门的系统机制，比如消息、socket和管道来完成。而线程是比进程更小的执行单位，每个线程拥有自己的栈和寄存器等资源数据，多个线程之间共享进程的代码、数据和文件。
那为什么要引入线程的概念？或者说线程有什么优点？
举个简单的例子，我们在使用电脑时，可以使用它听歌，可以使用它打印文件，也可以使用它看电影，而这些活动完全可以同时进行，这种思想在Java中被称为并发，线程就是并发完成的每一件事情。
线程的优点有如下几条：
- 创建一个线程比创建一个进程的代价要小
- 线程的切换比进程间的切换代价小
- 充分利用多处理器
- 数据共享（数据共享使得线程之间的通信比进程间的通信更高效）
- 快速响应特性（在系统繁忙的情况下，进程通过独立的线程及时响应用户的输入 ）
在单线程中，程序代码按调用顺序依次往下执行，如果需要一个进程同时完成多段代码的操作，就需要产生多线程。
二、线程的实现
在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 }转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以加QQ（2602138376）
文章标题:Java高级篇（一）——线程
文章字数:3.9k
本文作者:Zevs
发布时间:2019-08-15, 12:37:05
最后更新:2019-08-15, 16:20:56
原始链接:http://zhsh666.xyz/2019/08/15/Java高级篇（一）——线程/版权声明: "署名-非商用-相同方式共享 4.0" 转载请保留原文链接及作者。
√本站访问人数：人次 | ◎本站总访问量：次
