Java并发编程面试题——JUC专题

news2024/9/20 14:47:08

文章目录

  • 一、AQS高频问题
    • 1.1 AQS是什么？
    • 1.2 唤醒线程时，AQS为什么从后往前遍历？
    • 1.3 AQS为什么用双向链表，（为啥不用单向链表）？
    • 1.4 AQS为什么要有一个虚拟的head节点
    • 1.5 ReentrantLock的底层实现原理
    • 1.6 ReentrantLock的公平锁和非公平锁的区别
    • 1.7 ReentrantReadWriteLock如何实现的读写锁
  • 二、阻塞队列高频问题
    • 2.1 说下你熟悉的阻塞队列？
    • 2.2 虚假唤醒是什么？
  • 三、线程池高频问题
    • 3.1 线程池的7个参数
    • 3.2 线程池的状态有什么，如何记录的？
    • 3.3 线程池常见的拒绝策略
    • 3.4 线程池执行流程
    • 3.5 线程池为什么添加空任务的非核心线程
    • 3.7 工作线程出现异常会导致什么问题？
    • 3.8 工作线程继承AQS的目的是什么？
    • 3.9 核心参数怎么设置？
  • 四、CountDownLatch，Semaphore的高频问题
    • 4.1 CountDownLatch是啥？有啥用？底层咋实现的？
    • 4.2 Semaphore是啥？有啥用？底层咋实现的？
    • 4.3 main线程结束，程序会停止嘛？
  • 五、CopyOnWriteArrayList的高频问题
    • 5.1 CopyOnWriteArrayList是如何保证线程安全的？有什么缺点吗？
  • 六、ConcurrentHashMap（JDK1.8）的高频问题
    • 6.1 HashMap为啥线程不安全？
    • 6.2 ConcurrentHashMap如何保证线程安全的？
    • 6.3 ConcurrentHashMap构建好，数组就创建出来了吗？如果不是，如何保证初始化数组的线程安全？
    • 6.4 为什么负载因子是0.75，为什么链表长度到8转为红黑树？
    • 6.5put操作太频繁的场景，会造成扩容时期put的阻塞 ？
    • 6.6 ConcurrentHashMap何时扩容，扩容的流程是什么？
    • 6.7 ConcurrentHashMap得计数器如何实现的？
    • 6.8 ConcurrentHashMap的读操作会阻塞嘛？

一、AQS高频问题

1.1 AQS是什么？

AQS是JUC下大量工具的基础类，很多工具都基于AQS实现的，比如lock锁，CountDownLatch，Semaphore，线程池等等都用到了AQS。

AQS中有一个核心属性state，还有一个双向链表以及一个单向链表。其中state是基于volatile修饰，再基于CAS修改，可以保证原子，可见，有序三大特性。单向链表是内部类ConditionObject对标synchronized中的等待池，当lock在线程持有锁时，执行await方法，会将线程封装为Node对象，扔到Condition单向链表中，等待唤醒。如果线程唤醒了，就将Condition中的Node扔到AQS的双向链表等待获取锁。

1.2 唤醒线程时，AQS为什么从后往前遍历？

当持有资源的线程执行完成后，需要在AQS的双向链表拿出来一个，如果head的next节点取消了

如果在唤醒线程时，head节点的next是第一个要被唤醒的，如果head的next节点取消了，会出现节点丢失问题。

如下图，当一个新的Node添加到链表时有3个步骤，当第三个步骤还未完成时，如果从head开始就找不到需要被唤醒的节点了。
在这里插入图片描述

1.3 AQS为什么用双向链表，（为啥不用单向链表）？

因为AQS中，存在取消节点的操作，如果使用双向链表只需要两步

  • 需要将prev节点的next指针，指向next节点。
  • 需要将next节点的prev指针，指向prev节点。

但是如果是单向链表，需要遍历整个单向链表才能完成的上述的操作。比较浪费资源。

1.4 AQS为什么要有一个虚拟的head节点

每个Node都会有一些状态，这个状态不单单针对自己，还针对后续节点

  • 1：当前节点取消了。
  • 0：默认状态，啥事没有。
  • -1：当前节点的后继节点，挂起了。
  • -2：代表当前节点在Condition队列中（await将线程挂起了）
  • -3：代表当前是共享锁，唤醒时，后续节点依然需要被唤醒。

但是一个节点无法同时保存当前节点状态和后继节点状态，有一个哨兵节点，更方便操作。

1.5 ReentrantLock的底层实现原理

ReentrantLock是基于AQS实现的。

  1. 在线程基于ReentrantLock加锁时，需要基于CAS去修改state属性，如果能从0改为1，代表获取锁资源成功
  2. 如果CAS失败了，添加到AQS的双向链表中排队（可能会挂起线程），等待获取锁。
  3. 持有锁的线程，如果执行了condition的await方法，线程会封装为Node添加到Condition的单向链表中，等待被唤醒并且重新竞争锁资源

1.6 ReentrantLock的公平锁和非公平锁的区别

公平锁和非公平中的lock方法和tryAcquire方法的实现有点不同，其他都一样

  • 非公平锁
    • lock：直接尝试将state从 0 改为 1，如果成功，拿锁直接走，如果失败了，执行tryAcquire。
    • tryAcquire：如果当前没有线程持有锁资源，直接再次尝试将state从0 改为 1 如果成功，拿锁直接走。
  • 公平锁
    • lock：直接执行tryAcquire。
    • tryAcquire：如果当前没有线程持有锁资源，先看一下，有排队的么。如果没有排队的，直接尝试将state从 0 改为 1。如果有排队的并且第一名，直接尝试将state从 0 改为 1。

如果都没拿到锁，公平锁和非公平锁的后续逻辑是一样的，加入到AQS双向链表中排队。

1.7 ReentrantReadWriteLock如何实现的读写锁

如果一个操作写少读多，还用互斥锁的话，性能太低，因为读读不存在并发问题。读写锁可以解决该问题。

ReentrantReadWriteLock也是基于AQS实现的一个读写锁，但是锁资源用state标识。如何基于一个int来标识两个锁信息，有写锁，有读锁，怎么做的？

一个int，占了32个bit位。在写锁获取锁时，基于CAS修改state的低16位的值。在读锁获取锁时，基于CAS修改state的高16位的值。

写锁的重入，基于state低16直接标识，因为写锁是互斥的。读锁的重入，无法基于state的高16位去标识，因为读锁是共享的，可以多个线程同时持有。所以读锁的重入用的是ThreadLocal来表示，同时也会对state的高16为进行追加。

二、阻塞队列高频问题

2.1 说下你熟悉的阻塞队列？

ArrayBlockingQueue：底层基于数组实现，记得new的时候设置好边界。

LinkedBlockingQueue：底层基于链表实现的，可以认为是无界队列，但是可以设置长度。

PriorityBlockingQueue：底层是基于数组实现的二叉堆，可以认为是无界队列，因为数组会扩容。

ArrayBlockingQueue，LinkedBlockingQueue是ThreadPoolExecutor线程池最常用的两个阻塞队列。

2.2 虚假唤醒是什么？

虚假唤醒在阻塞队列的源码中就有体现。
在这里插入图片描述

比如消费者1在消费数据时，会先判断队列是否有元素，如果元素个数为0，消费者1会await挂起。此处判断元素为0的位置，如果用if循环会导致出现一个问题。

  1. 如果生产者添加了一个数据，会唤醒消费者1并去拿锁资源。
  2. 此时如果来了消费者2抢到了锁资源并带走了数据的话，消费者1再次拿到锁资源时，无法从队列获取到任何元素，出现虚假唤醒问题。

解决方案，将判断元素个数的位置，设置为while判断。

三、线程池高频问题

3.1 线程池的7个参数

核心线程数，最大线程数，最大空闲时间，时间单位，阻塞队列，线程工厂，拒绝策略

3.2 线程池的状态有什么，如何记录的？

线程池有5个状态：RUNINING、SHUTDOWN、STOP、TIDYING、TERMINATED
image.png

线程池的状态是在ctl属性中记录的。本质就是int类型
在这里插入图片描述

3.3 线程池常见的拒绝策略

  • AbortPolicy：丢弃任务并抛异常（默认） image.png

  • CallerRunsPolicy：当前线程执行
    image.png

  • DiscardPolicy：丢弃任务直接不要
    image.png

  • DiscardOldestPolicy：丢弃等待队列中最旧的任务，并执行当前任务
    image.png

一般情况下，线程池自带的无法满足业务时，自定义一个线程池的拒绝策略，实现下面的接口即可。
image.png

3.4 线程池执行流程

核心线程不是new完就构建的，是懒加载的机制，添加任务才会构建核心线程
image.png

3.5 线程池为什么添加空任务的非核心线程

image.png
避免线程池出现队列有任务，但是没有工作线程处理。

当核心线程数是0个，任务进来后会到阻塞队列，但是没有工作线程，此时空任务的非核心线程就可以处理该任务。

##3.6 在没任务时，线程池中的工作线程在干嘛？

  • 如果是核心线程，默认情况下，会在阻塞队列的位置执行take方法，直到拿到任务为止。

  • 如果是非核心线程，默认情况下，会在阻塞队列的位置执行poll方法，等待最大空闲时间，如果没任务，删除线程，如果有活，那就正常干。

3.7 工作线程出现异常会导致什么问题？

首先出现异常的工作线程不会影响到其他的工作线程。

  • 如果任务是execute方法执行的，工作线程会将异常抛出。
  • 如果任务是submit方法执行的futureTask，工作线程会将异常捕获并保存到FutureTask里，可以基于futureTask的get得到异常信息。
  • 最后线程结束。

3.8 工作线程继承AQS的目的是什么？

工作线程的本质，就是Worker对象。继承AQS跟shutdown和shutdownNow有关系。

  • 如果是shutdown，会中断空闲的工作线程，基于Worker实现的AQS中的state的值来判断能否中断工作线程。如果工作线程的state是0，代表空闲，可以中断，如果是1，代表正在干活。

  • 如果是shutdownNow，直接强制中断所有工作线程

3.9 核心参数怎么设置？

线程池的目的是为了减少线程频繁创建/销毁带来的资源消耗，充分发挥CPU的资源，提升整个系统的性能。不同业务的线程池参考的方式也不一样。

  • 如果是CPU密集的任务，一般也就是CPU内核数 + 1的核心线程数。这样足以充分发挥CPU性能。
  • 如果是IO密集的任务，因为IO的程度不一样，有的是1s，有的是1ms，有的是1分钟，所以IO密集的任务在用线程池处理时，一定要通过压测的方式，观察CPU资源的占用情况，来决定核心线程数。一般发挥CPU性能到70~80足矣。

所以线程池的参数设置需要通过压测以及多次调整才能得出具体的。

四、CountDownLatch，Semaphore的高频问题

4.1 CountDownLatch是啥？有啥用？底层咋实现的？

CountDownLatch本质其实就是一个计数器。在多线程并行处理业务时，需要等待其他线程处理完再做后续的合并等操作时，可以使用CountDownLatch做计数，等到其他线程出现完之后，主线程就会被唤醒。实现过程如下：

  1. CountDownLatch本身就是基于AQS实现的。new CountDownLatch时，直接指定好具体的数值，这个数值会复制给state属性。
  2. 当子线程处理完任务后，执行countDown方法，内部就是直接给state - 1。
  3. 当state减为0之后，执行await挂起的线程，就会被唤醒。
import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch count = new CountDownLatch(3);
        for (int i = 0; i < 3; i++) {
            int finalI = i;
            new Thread(() -> {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程" + finalI + "执行中");
                count.countDown();
            }).start();
        }

        count.await();

        System.out.println("所有线程都执行完成了");
    }
}

4.2 Semaphore是啥？有啥用？底层咋实现的？

信号量，就是一个可以用于做限流功能的工具类。比如要求当前服务最多3个线程同时干活，将信号量设置为3。每个任务提交前都需要获取一个信号量，获取到就去干活，干完了，归还信号量。实现过程如下：

  1. 信号量也是基于AQS实现的，构建信号量时，指定信号量资源数，这个数值会复制给state属性。
  2. 获取信号量时，执行acquire方法，内部就是直接给state - 1。当state为0时，新来的任务会因获取不到信号量而等待。
  3. 当任务执行完成后，执行release方法，释放信号量。
import java.util.concurrent.Semaphore;

public class SemaphoreTest {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < 3; i++) {
            int finalI = i;
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println("线程" + finalI + "执行中");
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }

            }).start();
        }

        new Thread(() -> {
            try {
                long begin = System.currentTimeMillis();
                semaphore.acquire();
                long end = System.currentTimeMillis();
                System.out.println("限流了" + (end - begin) + "ms");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release();
            }
        }).start();
    }
}

4.3 main线程结束，程序会停止嘛？

  • 如果main线程结束，但是还有用户线程在执行，不会结束！
  • 如果main线程结束，剩下的都是守护线程，结束！

五、CopyOnWriteArrayList的高频问题

5.1 CopyOnWriteArrayList是如何保证线程安全的？有什么缺点吗？

CopyOnWriteArrayList写数据时，是基于ReentrantLock保证原子性的。写数据时，会复制一个副本写入，写入成功后，才会写入到CopyOnWriteArrayList中的数组，保证读数据时，不要出现数据不一致的问题。

缺点就是：如果数据量比较大时，每次写入数据，都需要复制一个副本，对空间的占用太大了。如果数据量比较大，不推荐使用CopyOnWriteArrayList。

适合写操作要求保证原子性，读操作保证并发，并且数据量不大的场景。

六、ConcurrentHashMap（JDK1.8）的高频问题

6.1 HashMap为啥线程不安全？

  1. JDK1.7里有环（扩容时）。

  2. 并发添加数据时会覆盖，数据可能丢失。

  3. 在记录元素个数和HashMap写的次数时，记录不准确。

  4. 数据迁移，扩容，也可能会丢失数据。

6.2 ConcurrentHashMap如何保证线程安全的？

  1. 尾插
  2. 写入数组时，基于CAS保证安全；插入链表或红黑树时，基于synchronized保证安全。
  3. 这里ConcurrentHashMap是采用LongAdder实现的技术，底层还是CAS。
  4. ConcurrentHashMap扩容时，基于CAS保证数据迁移不出现并发问题。

6.3 ConcurrentHashMap构建好，数组就创建出来了吗？如果不是，如何保证初始化数组的线程安全？

ConcurrentHashMap是懒加载的机制，而且大多数的框架组件都是懒加载的~

基于CAS来保证初始化线程安全的，这里不但涉及到了CAS去修改sizeCtl的变量去控制线程初始化数据的原子性，同时还使用了DCL，外层判断数组未初始化，中间基于CAS修改sizeCtl，内层再做数组未初始化判断。

image.png

6.4 为什么负载因子是0.75，为什么链表长度到8转为红黑树？

负载因子是0.75从两个方面去解释。为啥不是0.5，为啥不是1？

0.5：如果负载因子是0.5，数据添加一半就开始扩容了

  • 优点：hash碰撞少，查询效率高。
  • 缺点：扩容太频繁，而且空间利用率低。

1：如果负载因子是1，数据添加到数组长度才开始扩容

  • 优点：扩容不频繁，空间利用率可以的。
  • 缺点：hash冲突会特别频繁，数据挂到链表上，影响查询效率，甚至链表过长生成红黑树，导致写入的效率也收到影响。

0.75就可以说是一个居中的选择，两个方面都兼顾了。

再就是泊松分布，在负载因子是0.75时，根据泊松分布得出，链表长度达到8的概率是非常低的，源码中的标识是0.00000006，生成红黑树的概率特别低。虽然ConcurrentHashMap引入了红黑树，但是红黑树对于写入的维护成本更高，能不用就不用，HashMap源码的注释也描述了，要尽可能规避红黑树。

6.5put操作太频繁的场景，会造成扩容时期put的阻塞 ？

一般情况下不会造成阻塞。

  • 如果在put操作时，发现当前索引位置并没有数据时，正常把数据落到老数组上。

  • 如果put操作时，发现当前位置数据已经被迁移到了新数组，这时无法正常插入，去帮助扩容，快速结束扩容操作，并且重新选择索引位置查询

6.6 ConcurrentHashMap何时扩容，扩容的流程是什么？

  • ConcurrentHashMap中的元素个数，达到了负载因子计算的阈值，那么直接扩容
  • 当调用putAll方法，查询大量数据时，也可能会造成直接扩容的操作，大量数据是如果插入的数据大于下次扩容的阈值，直接扩容，然后再插入
  • 数组长度小于64，并且链表长度大于等于8时，会触发扩容image.png

6.7 ConcurrentHashMap得计数器如何实现的？

这里是基于LongAdder的机制实现，但是并没有直接用LongAdder的引用，而是根据LongAdder的原理写了一个相似度在80%以上的代码，直接使用。

LongAdder使用CAS添加，保证原子性，其次基于分段锁，保证并发性。

6.8 ConcurrentHashMap的读操作会阻塞嘛？

无论查哪，都不阻塞。

  • 查询数组：查看元素是否在数组，在就直接返回。
  • 查询链表：在链表next，next查询即可。
  • 扩容时：如果当前索引位置是-1，代表当前位置数据全部都迁移到了新数组，直接去新数组查询，不管有没有扩容完。
  • 查询红黑树：转换红黑树时，不但有一个红黑树，还会保留一个双向链表，此时会查询双向链表，不让读线程阻塞。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/358838.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

组合实现多类别分割（含实战代码）

组合实现多类别分割（含实战代码）

来源&#xff1a;投稿 作者&#xff1a;AI浩 编辑&#xff1a;学姐 摘要 segmentation_models_pytorch是一款非常优秀的图像分割库&#xff0c;albumentations是一款非常优秀的图像增强库&#xff0c;这篇文章将这两款优秀结合起来实现多类别的图像分割算法。数据集选用CamVid…
阅读更多...
Java实现JDBC工具类DbUtils的抽取及程序实现数据库的增删改操作

Java实现JDBC工具类DbUtils的抽取及程序实现数据库的增删改操作

封装DbUtils 工具类 不知道我们发现没有&#xff0c;不管是对数据库进行查询&#xff0c;还是标准的JDBC 步骤&#xff0c;其开端都是先实现JDBC 的加载注册&#xff0c;接着是获取数据库的连接&#xff0c;最后都是实现关闭连接&#xff0c;释放资源的操作。那我们何不直接把…
阅读更多...
起薪2万的爬虫工程师，Python需要学到什么程度才可以就业？

起薪2万的爬虫工程师，Python需要学到什么程度才可以就业？

爬虫工程师的的薪资为20K起&#xff0c;当然&#xff0c;因为大数据&#xff0c;薪资也将一路上扬。那么&#xff0c;Python需要学到什么程度呢?今天我们来看看3位前辈的回答。 1、前段时间快要毕业&#xff0c;而我又不想找自己的老本行Java开发了&#xff0c;所以面了很多P…
阅读更多...
【Python】用sympy判断函数的单调性和极值

【Python】用sympy判断函数的单调性和极值

文章目录单调性和奇异性连续性、极值、周期、不动点单调性和奇异性 sympy.calculus.singularities提供了4个关于单调性判定的函数&#xff0c;分别是 is_decreasing(expr, interval, symbolNone) is_increasing(expr, interval, symbolNone) is_strictly_decreasing(expr, in…
阅读更多...
【期末复习】例题讲解Dijkstra算法

【期末复习】例题讲解Dijkstra算法

使用场景Dijkstra算法用于解决单源点最短路径问题&#xff0c;即给一个顶点作为源点&#xff0c;依次求它到图中其他n-1个顶点的最短距离。例题讲解Dijkstra算法将图中所有顶点分成两部分&#xff0c;第一部分是已知到源点最短距离的顶点Known(K)&#xff0c;第二部分是不知道到…
阅读更多...
教你如何搭建人事OA-考勤管理系统，demo可分享

教你如何搭建人事OA-考勤管理系统，demo可分享

1、简介1.1、案例简介本文将介绍&#xff0c;如何搭建人事OA-考勤管理。1.2、应用场景可查看员工考勤的数据统计&#xff0c;可进行考勤签到、补签、请假、加班、调休等流程。2、设置方法2.1、表单搭建1&#xff09;新建表单【考勤签到】&#xff0c;字段设置如下&#xff1a;名…
阅读更多...
VS Code Spring 全新功能来了！

VS Code Spring 全新功能来了！

大家好&#xff0c;欢迎来到我们 2023 年的第一篇博客&#xff01;我们想与您分享几个与 Spring 插件、代码编辑和性能相关的激动人心的更新&#xff0c;让我们开始吧&#xff01; Spring 插件包的新入门演练 演练&#xff08;Walkthrough&#xff09; 是一种多步骤、向导式的体…
阅读更多...
跨境进口税费计算

跨境进口税费计算

以前搞跨境进口的时候&#xff0c;需要计算商品税费。税费计算比较复杂&#xff0c;把信息整理了一下&#xff0c;分享给大家。 一、基础知识 1.1税费类型 BBC/BC&#xff1a;跨境电商进口综合税 关税*0 (消费税进口环节增值税)*70%CC&#xff1a;行邮税&#xff0c;税额低…
阅读更多...
Vue3电商项目实战-商品详情模块1【01-商品详情-基础布局、02-商品详情-渲染面包屑、03-商品详情-图片预览组件、04-商品详情-图片放大镜】

Vue3电商项目实战-商品详情模块1【01-商品详情-基础布局、02-商品详情-渲染面包屑、03-商品详情-图片预览组件、04-商品详情-图片放大镜】

文章目录01-商品详情-基础布局02-商品详情-渲染面包屑03-商品详情-图片预览组件04-商品详情-图片放大镜01-商品详情-基础布局 目的&#xff1a;完成商品详情基础布局&#xff0c;路由配置&#xff0c;搭好页面架子。 大致步骤&#xff1a; 准备组件结构容器提取商品推荐组件且…
阅读更多...
十二月券商金工精选

十二月券商金工精选

✦研报目录✦ ✦简述✦ 按发布时间排序 华宝证券 主动暴露的得与失—从Barra框架到私募指增因子分析方法 发布日期&#xff1a;2022-12-01 关键词&#xff1a;股票、Barra、风险暴露、指数增强 主要内容&#xff1a;本文针对私募指数增强产品的策略流程&#xff0c;设计…
阅读更多...
＜JVM上篇：内存与垃圾回收篇＞11 - 垃圾回收相关算法

＜JVM上篇：内存与垃圾回收篇＞11 - 垃圾回收相关算法

对象存活判断 在堆里存放着几乎所有的 Java 对象实例&#xff0c;在 GC 执行垃圾回收之前&#xff0c;首先需要区分出内存中哪些是存活对象&#xff0c;哪些是已经死亡的对象。只有被标记为己经死亡的对象&#xff0c;GC 才会在执行垃圾回收时&#xff0c;释放掉其所占用的内存…
阅读更多...
vue项目开发（vue2与vue3对比）

vue项目开发（vue2与vue3对比）

vue中使用typescrip 初与typescrip的约定情愫&#xff1a;最近项目要用到vue3,所以打算使用typescrip语法&#xff01; 安装&#xff1a; npx tyarn add typescript vue/cli-plugin-typescript -D npx tsc --init修改 tsconfig.json&#xff1a; {"compilerOptions&quo…
阅读更多...
LVS中的keepalived高可用

LVS中的keepalived高可用

文章目录前言一、Keepalived简介二、keepalived工作原理三、配置文件四、实验1.某台Real Server down2.LVS本身down实验过程&#xff1a;五、代码详细演示整体过程调度器安装软件、设置测试keepalived对后端RS的健康检测backup服务主机设置前言 一、Keepalived简介 Keepalived是…
阅读更多...
ubuntu18.4安装Redmine软件

ubuntu18.4安装Redmine软件

1.github网站下载Redmine4.2.0的安装包&#xff0c;如下图所示&#xff1a; https://github.com/redmine/redmine/releases/tag/4.2.0 图1 github网站下载redmine4.2.0安装包2.拷贝Redmine4.2.0的安装包到ubuntu工作目录&#xff0c;并解压缩&#xff0c;如下所示&#xff1a;…
阅读更多...
Springboot前后端分离国际化实现-chatgpt

Springboot前后端分离国际化实现-chatgpt

前言 Springboot国际化可以帮助使用者在不同语言环境中构建应用程序&#xff0c;这样应用程序可以有效地适应不同语言文化背景下的用户需求。 此外&#xff0c;Springboot国际化也可以方便多语言应用程序重用和维护&#xff0c;从而减少了系统部署的时间成本和维护的费用。 要实…
阅读更多...
医疗方案 | 星辰天合入选“2022智慧新医信优秀解决方案”

医疗方案 | 星辰天合入选“2022智慧新医信优秀解决方案”

近日&#xff0c;由 HC3i数字医疗网主办的《数字化转型驱动下的医院高质量发展论坛》暨 2022 智慧新医信优秀解决方案发布仪式在线上召开。XSKY星辰天合的“智慧医疗软件定义数据基础设施”解决方案成功入选 2022 智慧新医信优秀解决方案&#xff0c;。此次论坛由 HC3i 数字医疗…
阅读更多...
会利用信息差赚钱的人才是聪明人

会利用信息差赚钱的人才是聪明人

毕业后找不到工作&#xff0c;穷到只剩下时间&#xff0c;大小做了20多份副业兼职&#xff0c;终于找到了可靠的渠道&#xff0c; 我是专科生&#xff0c;学历不好&#xff0c;专业拉胯。毕业后&#xff0c;我找了两三份工作。要么工资太低&#xff0c;只能交房租&#xff0c;…
阅读更多...
javaFx实现鼠标穿透画布，同时操作画布和桌面，背景透明，类似ppt批注

javaFx实现鼠标穿透画布，同时操作画布和桌面，背景透明，类似ppt批注

一、功能需要由来和大致效果 今天&#xff0c;我们要用javaFx来实现一个鼠标穿透画布的功能&#xff0c;该需求来自于在我们的javaFx桌面应用中&#xff0c;需要实现一个悬浮的桌面侧边工具栏&#xff0c;在工具栏中有画笔绘制&#xff0c;批注的功能&#xff0c;能够实现在任何…
阅读更多...
【NLP】一种联合关系抽取模型——TPLinker

【NLP】一种联合关系抽取模型——TPLinker

背景 前文介绍了【NLP】一种基于联合方式的三元组抽取模型——CasRel.这个模型虽然实体和关系同时训练&#xff0c;但本质上来说还是分阶段的预测实体和关系&#xff0c;依然存在暴露偏差问题。下面介绍一个解决暴露偏差的模型&#xff1a;TPLinker&#xff0c;论文地址&#…
阅读更多...
【OJ】A＋B＝X

【OJ】A＋B＝X

&#x1f4da;Description: 数列S中有n个整数&#xff0c;判断S中是否存在两个数A、B&#xff0c;使之和等于X。 ⏳Input: 第一行为T&#xff0c;输入包括T组测试数据。 每组数据第一行包括两个数字n和X&#xff0c;第二行有n个整数&#xff0c;表示数列S&#xff0c;(1&l…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023