Java高级篇（一）——线程，java面试题，java基础笔试题，BAT

写在最前面，我总结出了很多互联网公司的面试题及答案，并整理成了文档，以及各种学习的进阶学习资料，免费分享给大家。扫码加微信好友进【程序员面试学习交流群】，免费领取。也欢迎各位一起在群里探讨技术。

 

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

 

一、什么是线程

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

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

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

线程的优点有如下几条：

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

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

二、线程的实现

在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) {

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){

18                     a[k] = array[j];

19                 }

20             }else if(i==1){

21                 for(int j=start, k=0; j){

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面试题