互联网Java工程师面试题·Java 总结篇·第六弹

目录

56、TreeMap 和 TreeSet 在排序时如何比较元素？Collections 工具类中的 sort()方法如何比较元素？

57、Thread 类的 sleep()方法和对象的 wait()方法都可以让线程暂停执行，它们有什么区别?

58、线程的 sleep()方法和 yield()方法有什么区别？

59、当一个线程进入一个对象的 synchronized 方法 A 之后，其它线程是否可进入此对象的 synchronized 方法 B？

60、请说出与线程同步以及线程调度相关的方法。

61、编写多线程程序有几种实现方式？

62、synchronized 关键字的用法？

63、举例说明同步和异步。

64、启动一个线程是调用 run()还是 start()方法？

65、什么是线程池（thread pool）？

66、线程的基本状态以及状态之间的关系？

67、简述 synchronized 和 java.util.concurrent.locks.Lock的异同？

---

56、TreeMap 和 TreeSet 在排序时如何比较元素？Collections 工具类中的 sort()方法如何比较元素？

TreeSet 要求存放的对象所属的类必须实现 Comparable 接口，该接口提供了比较元素的 compareTo()方法，当插入元素时会回调该方法比较元素的大小。TreeMap 要求存放的键值对映射的键必须实现 Comparable 接口从而根据键对元素进 行排 序。Collections 工具类的 sort 方法有两种重载的形式，第一种要求传入的待排序容器中存放的对象比较实现 Comparable 接口以实现元素的比较；第二种不强制性的要求容器中的元素必须可比较，但是要求传入第二个参数，参数是Comparator 接口的子类型（需要重写 compare 方法实现元素的比较），相当于一个临时定义的排序规则，其实就是通过接口注入比较元素大小的算法，也是对回调模式的应用（Java 中对函数式编程的支持）。

例子 1：

public class Student implements Comparable<Student> {
    private String name;// 姓名
    private int age;// 年龄
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
@Override
public String toString() {
    return "Student [name=" + name + ", age=" + age + "]";
}
 
@Override
public int compareTo(Student o) {
    return this.age - o.age; // 比较年龄(年龄的升序)
}
}

import java.util.Set;
import java.util.TreeSet;
class Test01 {
    public static void main(String[] args) {
        Set<Student> set = new TreeSet<>();// Java 7 的钻石语法
(构造器后面的尖括号中不需要写类型)
        set.add(new Student("Hao LUO", 33));
        set.add(new Student("XJ WANG", 32));
        set.add(new Student("Bruce LEE", 60));
        set.add(new Student("Bob YANG", 22));
 
        for(Student stu : set) {
            System.out.println(stu);
        }
//输出结果:
//Student [name=Bob YANG, age=22]
//Student [name=XJ WANG, age=32]
//Student [name=Hao LUO, age=33]
//Student [name=Bruce LEE, age=60]
    }
}

例子2：

public class Student {
    private String name; // 姓名
    private int age; // 年龄
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
}
/*** 获取学生姓名 ***/
public String getName() {
    return name;
}
/*** 获取学生年龄***/
public int getAge() {
    return age;
}
@Override
public String toString() {
    return "Student [name=" + name + ", age=" + age + "]";
    }
}
 

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
class Test02 {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();// Java 7 的钻石语法
(构造器后面的尖括号中不需要写类型)
        list.add(new Student("Hao LUO", 33));
        list.add(new Student("XJ WANG", 32));
        list.add(new Student("Bruce LEE", 60));
        list.add(new Student("Bob YANG", 22));
// 通过 sort 方法的第二个参数传入一个 Comparator 接口对象
//相当于是传入一个比较对象大小的算法到 sort 方法中
//由于 Java 中没有函数指针、仿函数、委托这样的概念
//因此要将一个算法传入一个方法中唯一的选择就是通过接口回调
    Collections.sort(list, new Comparator<Student> () {
    @Override
        public int compare(Student o1, Student o2) {
        return o1.getName().compareTo(o2.getName()); //比较学生姓名
        }
    });
    for(Student stu : list) {
        System.out.println(stu);
    }
//输出结果:
//Student [name=Bob YANG, age=22]
//Student [name=Bruce LEE, age=60]
//Student [name=Hao LUO, age=33]
//Student [name=XJ WANG, age=32]
    }
}

---

银行账户类：

public class Account {
    private double balance; // 账户余额
/**
* 存款
* @param money 存入金额
*/
public void deposit(double money) {
    double newBalance = balance + money;
    try {
        Thread.sleep(10); // 模拟此业务需要一段处理时间
    }
    catch(InterruptedException ex) {
        ex.printStackTrace();
    }
    balance = newBalance;
}
/**
* 获得账户余额
*/
public double getBalance() {
    return balance;
    }
}

存钱线程类：

public class AddMoneyThread implements Runnable {
    private Account account;// 存入账户
    private double money;// 存入金额
 
 
    public AddMoneyThread(Account account, double money) {
        this.account = account;
        this.money = money;
    }
    @Override
    public void run() {
        account.deposit(money);
    }
}

测试类：
 

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class Test01 {
 
    public static void main(String[] args) {
        Account account = new Account();
        ExecutorService service = Executors.newFixedThreadPool(100);
        for(int i = 1; i <= 100; i++) {
            service.execute(new AddMoneyThread(account, 1));
        }
        service.shutdown();
        while(!service.isTerminated()) {}
        System.out.println("账户余额: " + account.getBalance());
    }
}

public class Account {
    private double balance; // 账户余额
/**
* 存款
* @param money 存入金额
*/
public synchronized void deposit(double money) {
    double newBalance = balance + money;
    try {
        Thread.sleep(10); // 模拟此业务需要一段处理时间
    }
    catch(InterruptedException ex) {
        ex.printStackTrace();
    }
    balance = newBalance;
}
/**
* 获得账户余额
*/
public double getBalance() {
    return balance;
    }
}

在线程调用存款方法时对银行账户进行同步

public class AddMoneyThread implements Runnable {
    private Account account;    // 存入账户
    private double money;    // 存入金额
 
 
public AddMoneyThread(Account account, double money) {
    this.account = account;
    this.money = money;
}
 
@Override
public void run() {
    synchronized (account) {
        account.deposit(money);
        }
    }
}

通过 Java 5 显示的锁机制，为每个银行账户创建一个锁对象，在存款操作进行加锁和解锁的操作

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Account {
    private Lock accountLock = new ReentrantLock();
    private double balance; // 账户余额
/**
* 存款
*@param money
*存入金额
*/
public void deposit(double money) {
    accountLock.lock();
    try {
        double newBalance = balance + money;
        try {
            Thread.sleep(10); // 模拟此业务需要一段处理时间
        }
        catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        balance = newBalance;
    }
    finally {
        accountLock.unlock();
    }
}
/**
* 获得账户余额
*/
    public double getBalance() {
        return balance;
    }
}

        按照上述三种方式对代码进行修改后，重写执行测试代码 Test01，将看到最终的账户余额为 100 元。当然也可以使用 Semaphore 或 CountdownLatch 来实现同步。

---

61、编写多线程程序有几种实现方式？

        Java 5 以前实现多线程有两种实现方法：一种是继承 Thread 类；另一种是实现Runnable 接口。两种方式都要通过重写 run()方法来定义线程的行为，推荐使用后者，因为 Java 中的继承是单继承，一个类有一个父类，如果继承了 Thread 类就无法再继承其他类了，显然使用 Runnable 接口更为灵活。

补充：Java 5 以后创建线程还有第三种方式：实现 Callable 接口，该接口中的 call方法可以在线程执行结束时产生一个返回值，代码如下所示：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
 
class MyTask implements Callable<Integer> {
    private int upperBounds;
    public MyTask(int upperBounds) {
        this.upperBounds = upperBounds;
    }
 
@Override
public Integer call() throws Exception {
    int sum = 0;
    for(int i = 1; i <= upperBounds; i++) {
        sum += i;
    }
    return sum;
    }
}
 
class Test {
    public static void main(String[] args) throws Exception {
        List<Future<Integer>> list = new ArrayList<>();
        ExecutorService service = Executors.newFixedThreadPool(10);
        for(int i = 0; i < 10; i++) {
            list.add(service.submit(new MyTask((int) (Math.random() * 100))));
        }
        int sum = 0;
        for(Future<Integer> future : list) {
            // while(!future.isDone()) ;
            sum += future.get();
        }
        System.out.println(sum);
    }
}

---

62、synchronized 关键字的用法？

        synchronized 关键字可以将对象或者方法标记为同步，以实现对对象和方法的互斥访问，可以用 synchronized(对象) { … }定义同步代码块，或者在声明方法时将 synchronized 作为方法的修饰符。在第 60 题的例子中已经展示了synchronized 关键字的用法。

---

63、举例说明同步和异步。

        如果系统中存在临界资源（资源数量少于竞争资源的线程数量的资源），例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就必须进行同步存取（数据库操作中的排他锁就是最好的例子）。当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。事实上，所谓的同步就是指阻塞式操作，而异步就是非阻塞式操作。

---

64、启动一个线程是调用 run()还是 start()方法？

        启动一个线程是调用 start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由 JVM 调度并执行，这并不意味着线程就会立即运行。run()方法是线程启动后要进行回调（callback）的方法。

---

65、什么是线程池（thread pool）？

        在面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其它更多资源。在 Java 中更是如此，虚拟机将试图跟踪每一个对象，以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁，这就是”池化资源”技术产生的原因。线程池顾名思义就是事先创建若干个可执行的线程放入一个池（容器）中，需要的时候从池中获取线程不用自行创建，使用完毕不需要销毁线程而是放回池中，从而减少创建和销毁线程对象的开销。Java 5+中的 Executor 接口定义一个执行线程的工具。它的子类型即线程池接口是 ExecutorService。要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，因此在工具类 Executors 面提供了一些静态工厂方法，生成一些常用的线程池，如下所示：

        newSingleThreadExecutor：创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

        newFixedThreadPool：创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

        newCachedThreadPool：创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60 秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说 JVM）能够创建的最大线程大小。

        newScheduledThreadPool：创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

        newSingleThreadExecutor：创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

        第 60 题的例子中演示了通过 Executors 工具类创建线程池并使用线程池执行线程的代码。如果希望在服务器上使用线程池，强烈建议使用 newFixedThreadPool方法来创建线程池，这样能获得更好的性能。

---

66、线程的基本状态以及状态之间的关系？

说明：其中 Running 表示运行状态，Runnable 表示就绪状态（万事俱备，只欠CPU），Blocked 表示阻塞状态，阻塞状态又有多种情况，可能是因为调用 wait()方法进入等待池，也可能是执行同步方法或同步代码块进入等锁池，或者是调用了 sleep()方法或 join()方法等待休眠或其他线程结束，或是因为发生了 I/O 中断。

---

67、简述 synchronized 和 java.util.concurrent.locks.Lock的异同？

        Lock 是 Java 5 以后引入的新的 API，和关键字 synchronized 相比主要相同点：Lock 能完成 synchronized 所实现的所有功能；主要不同点：Lock 有比synchronized 更精确的线程语义和更好的性能，而且不强制性的要求一定要获得锁。synchronized 会自动释放锁，而 Lock 一定要求程序员手工释放，并且最好在 finally 块中释放（这是释放外部资源的最好的地方).

---

要想了解更多：

千题千解·Java面试宝典_时光の尘的博客-CSD