写在最前面，我总结出了很多互联网公司的面试题及答案，并整理成了文档，以及各种学习的进阶学习资料，免费分享给大家。扫码加微信好友进【程序员面试学习交流群】，免费领取。也欢迎各位一起在群里探讨技术。
前面我们系统的了解了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 }
转载：https://www.cnblogs.com/adamjwh/p/8654008.html
推荐内容：
Java枚举类型的用法
java面试题整理
顽石系列：Java技术面试
Java进阶篇（六）——Swing程序设计（下）
一个两年Java的面试总结
为什么说 Java 程序员到了必须掌握 Spring Boot 的时候？
Java面试经
Java 面试知识点解析(五)——网络协议篇
【原创】JAVA面试解析（有赞一面）
java面试题
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
