java面试(二十三)--（1）不用加减乘除做加法（2）CyclicBarrier和CountDownLatch的区别（3）什么是线程池（thread pool）

最新推荐文章于 2024-06-19 15:14:21 发布

原创最新推荐文章于 2024-06-19 15:14:21 发布 · 247 阅读

0 ·

CC 4.0 BY-SA版权

java面试专栏收录该内容

33 篇文章

订阅专栏

本文深入探讨了不使用基本算术运算实现加法的方法，并对比分析了CyclicBarrier和CountDownLatch两种并发控制工具的区别与用法，同时介绍了线程池的概念、优缺点及工作原理。

1.不用加减乘除做加法

写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。
示例代码:

public class Solution {
    public int Add(int num1,int num2) {
        
    }
}

实现代码:

public class Solution {
    public int Add(int num1,int num2) {
        int sum = 0;
        int carry = 0;
        do {
            // 异或，实现相加但不进位
            sum = num1 ^ num2;
            // 先位与，后左移，相当于进位
            carry = (num1 & num2) << 1;
            num1 = sum;//
            num2 = carry;
        } while (num2 != 0);
        return num1;
    }
}

2.CyclicBarrier和CountDownLatch的区别

CyclicBarrier和CountDownLatch 都位于java.util.concurrent 这个包下.
区别:

CountDownLatch	CyclicBarrier
减计数方式	加计数方式
计算为0时释放所有等待的线程	计数达到指定值时释放所有等待线程
计数为0时，无法重置	计数达到指定值时，计数置为0重新开始
调用countDown()方法计数减一，调用await()方法只进行阻塞，对计数没任何影响	调用await()方法计数加1，若加1后的值不等于构造方法的值，则线程阻塞
不可重复利用	可重复利用

一、 CountDownLatch用法

CountDownLatch类只提供了一个构造器：

  public CountDownLatch(int count){};  //参数count为计数值

然后下面这3个方法是CountDownLatch类中最重要的方法：

public void await() throws InterruptedException { };   //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  //和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public void countDown() { };  //将count值减1

CountDownLatch一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
例如:

import java.util.concurrent.CountDownLatch;
public class countDownlatchTest {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for(int i=0;i<5;i++){
            new Thread(new readNum(i,countDownLatch)).start();
        }
        countDownLatch.await();//线程阻塞
        System.out.println("线程执行结束...");
    }
 
    static class readNum  implements Runnable{
        private int id;
        private CountDownLatch latch;
        public readNum(int id,CountDownLatch latch){
            this.id = id;
            this.latch = latch;
        }
        @Override
        public void run() {
            synchronized (this){
                System.out.println("id:"+id);
                latch.countDown();
                System.out.println("线程组任务"+id+"结束，其他任务继续");
            }
        }
    }
}

输出结果:
id:1
线程组任务1结束，其他任务继续
id:0
线程组任务0结束，其他任务继续
id:2
线程组任务2结束，其他任务继续
id:3
线程组任务3结束，其他任务继续
id:4
线程组任务4结束，其他任务继续
线程执行结束…

二、 CyclicBarrier用法

CyclicBarrier提供2个构造器：

//参数parties指让多少个线程或者任务等待至barrier状态；参数barrierAction为当这些线程都达到barrier状态时会执行的内容。
public CyclicBarrier(int parties, Runnable barrierAction) {

}
public CyclicBarrier(int parties) {
}

CyclicBarrier中最重要的方法就是await方法

public int await() throws InterruptedException, BrokenBarrierException { };//挂起当前线程，直至所有线程都到达barrier状态再同时执行后续任务；
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { }; //让这些线程等待至一定的时间，如果还有线程没有到达barrier状态就直接让到达barrier的线程执行后续任务

例如:

import java.util.concurrent.CyclicBarrier;
public class cyclicBarrierTest {
    public static void main(String[] args) throws InterruptedException {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                System.out.println("线程组执行结束");
            }
        });
        for (int i = 0; i < 5; i++) {
            new Thread(new readNum(i,cyclicBarrier)).start();
        }
        //CyclicBarrier 可以重复利用，
        // 这个是CountDownLatch做不到的
//        for (int i = 11; i < 16; i++) {
//            new Thread(new readNum(i,cyclicBarrier)).start();
//        }
    }
    static class readNum implements Runnable{
        private int id;
        private CyclicBarrier cyc;
        public readNum(int id,CyclicBarrier cyc){
            this.id = id;
            this.cyc = cyc;
        }
        @Override
        public void run() {
            synchronized (this){
                System.out.println("id:"+id);
                try {
                    cyc.await();
                    System.out.println("线程组任务" + id + "结束，其他任务继续");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

输出结果:
id:1
id:2
id:4
id:0
id:3
线程组执行结束
线程组任务3结束，其他任务继续
线程组任务1结束，其他任务继续
线程组任务4结束，其他任务继续
线程组任务0结束，其他任务继续
线程组任务2结束，其他任务继续

总结: CountDownLatch是线程执行完后,才执行后面程序; CyclicBarrier是线程阻塞到一定数量后,才执行后面程序.

本题参考: https://blog.youkuaiyun.com/tolcf/article/details/50925145

3.什么是线程池（thread pool）？

线程池与线程:
性能：每开启一个新的线程都要消耗内存空间及资源（默认情况下大约1 MB的内存），同时多线程情况下操作系统必须调度可运行的线程并执行上下文切换，所以太多的线程还对性能不利。而线程池其目的是为了减少开启新线程消耗的资源（使用线程池中的空闲线程，不必再开启新线程，以及统一管理线程（线程池中的线程执行完毕后，回归到线程池内，等待新任务））。
时间：无论何时启动一个线程，都需要时间(几百毫秒)，用于创建新的局部变量堆，线程池预先创建了一组可回收线程，因此可以缩短过载时间。
线程池缺点：线程池的性能损耗优于线程（通过共享和回收线程的方式实现），但是：
1.线程池不支持线程的取消、完成、失败通知等交互性操作。
2.线程池不支持线程执行的先后次序排序。
3.不能设置池化线程（线程池内的线程）的Name，会增加代码调试难度。
4.池化线程通常都是后台线程，优先级为ThreadPriority.Normal。
5.池化线程阻塞会影响性能（阻塞会使JVM错误地认为它占用了大量CPU。JVM能够检测或补偿（往池中注入更多线程），但是这可能使线程池受到后续超负荷的印象。Task解决了这个问题）。
6.线程池使用的是全局队列，全局队列中的线程依旧会存在竞争共享资源的情况，从而影响性能（Task解决了这个问题方案是使用本地队列）。

线程池工作原理：
JVM初始化时，线程池中是没有线程的。在内部，线程池维护了一个操作请求队列。应用程序执行一个异步操作时，会将一个记录项追加到线程池的队列中。线程池的代码从这个队列中读取记录将这个记录项派发给一个线程池线程。如果线程池没有线程，就创建一个新线程。当线程池线程完成工作后，线程不会被销毁，相反线程会返回线程池，在那里进入空闲状态，等待响应另一个请求，由于线程不销毁自身，所以不再产生额外的性能损耗。
程序向线程池发送多条请求，线程池尝试只用这一个线程来服务所有请求，当请求速度超过线程池线程处理任务速度，就会创建额外线程，所以线程池不必创建大量线程。
如果停止向线程池发送任务，池中大量空闲线程将在一段时间后自己醒来终止自己以释放资源(JVM不同版本对这个事件定义不一)。

本题参考: https://www.cnblogs.com/jonins/p/9369927.html (概念参考)
推荐: https://www.cnblogs.com/kuoAT/p/6714762.html （详细解答）