首页 文章 精选 留言 我的

精选列表

搜索[Java]，共10000篇文章
优秀的个人博客,低调大师

java中驼峰命名和下划线命名互转方法(代码实现)

1 /** 2 * 将驼峰式命名的字符串转换为下划线大写方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。 3 * 例如：HelloWorld->HELLO_WORLD 4 * @param name 转换前的驼峰式命名的字符串 5 * @return 转换后下划线大写方式命名的字符串 6 */ 7 public static String underscoreName(String name) { 8 StringBuilder result = new StringBuilder(); 9 if (name != null && name.length() > 0) { 10 // 将第一个字符处理成大写 11 result.append(name.substring(0, 1).toUpperCase()); 12 // 循环处理其余字符 13 for (int i = 1; i < name.length(); i++) { 14 String s = name.substring(i, i + 1); 15 // 在大写字母前添加下划线 16 if (s.equals(s.toUpperCase()) && !Character.isDigit(s.charAt(0))) { 17 result.append("_"); 18 } 19 // 其他字符直接转成大写 20 result.append(s.toUpperCase()); 21 } 22 } 23 return result.toString(); 24 } 1 /** 2 * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 3 * 例如：HELLO_WORLD->HelloWorld 4 * @param name 转换前的下划线大写方式命名的字符串 5 * @return 转换后的驼峰式命名的字符串 6 */ 7 public static String camelName(String name) { 8 StringBuilder result = new StringBuilder(); 9 // 快速检查 10 if (name == null || name.isEmpty()) { 11 // 没必要转换 12 return ""; 13 } else if (!name.contains("_")) { 14 // 不含下划线，仅将首字母小写 15 return name.substring(0, 1).toLowerCase() + name.substring(1); 16 } 17 // 用下划线将原始字符串分割 18 String camels[] = name.split("_"); 19 for (String camel : camels) { 20 // 跳过原始字符串中开头、结尾的下换线或双重下划线 21 if (camel.isEmpty()) { 22 continue; 23 } 24 // 处理真正的驼峰片段 25 if (result.length() == 0) { 26 // 第一个驼峰片段，全部字母都小写 27 result.append(camel.toLowerCase()); 28 } else { 29 // 其他的驼峰片段，首字母大写 30 result.append(camel.substring(0, 1).toUpperCase()); 31 result.append(camel.substring(1).toLowerCase()); 32 } 33 } 34 return result.toString(); 35 } 参考博客：http://jhonnnnnn.iteye.com/blog/2261298我的GitHub地址： https://github.com/heizemingjun 我的博客园地址： http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址： http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名，谢谢！】
2018-03-20
优秀的个人博客,低调大师

java面试-深入理解JVM(五)——HotSpot垃圾收集器详解

HotSpot虚拟机提供了多种垃圾收集器，每种收集器都有各自的特点，没有最好的垃圾收集器，只有最适合的垃圾收集器。我们可以根据自己实际的应用需求选择最适合的垃圾收集器。 根据新生代和老年代各自的特点，我们应该分别为它们选择不同的收集器，以提升垃圾回收效率。 新生代垃圾收集器 1. Serial垃圾收集器 单线程只开启一条GC线程进行垃圾回收，并且在垃圾回收过程中停止一切用户线程，从而用户的请求或图形化界面会出现卡顿。 适合客户端应用一般客户端应用所需内存较小，不会创建太多的对象，而且堆内存不大，因此垃圾回收时间比较短，即使在这段时间停止一切用户线程，用户也不会感受到明显的停顿，因此本垃圾收集器适合客户端应用。 简单高效由于Serial收集器只有一条GC线程，因此避免了线程切换的开销，从而简单高效。 采用“复制”算法 2. ParNew垃圾收集器 ParNew是Serial的多线程版本。1. 多线程并行执行ParNew由多条GC线程并行地进行垃圾清理。但清理过程仍然需要停止一切用户线程。但由于有多条GC线程同时清理，清理速度比Serial有一定的提升。 适合多CPU的服务器环境由于使用了多线程，因此适合CPU较多的服务器环境。 与Serial性能对比ParNew和Serial唯一的区别就是使用了多线程进行垃圾回收，在多CPU的环境下性能比Serial会有一定程度的提升；但线程切换需要额外的开销，因此在单CPU环境中表现不如Serial。 采用“复制”算法 追求“降低停顿时间”和Serial相比，ParNew使用多线程的目的就是缩短垃圾收集时间，从而减少用户线程被停顿的时间。 3. Parallel Scavenge垃圾收集器 Parallel Scavenge和ParNew一样都是多线程、新生代收集器，都使用“复制”算法进行垃圾回收。但它们有个巨大的不同点：ParNew收集器追求降低用户线程的停顿时间，因此适合交互式应用；而Parallel Scavenge追求CPU吞吐量，能够在较短的时间内完成指定任务，因此适合没有交互的后台计算。 什么是“吞吐量”？吞吐量是指用户线程运行时间占CPU总时间的比例。CPU总时间包括：用户线程运行时间 和 GC线程运行的时间。因此，吞吐量越高表示用户线程运行时间越长，从而用户线程能够被快速处理完。 降低停顿时间的两种方式1.在多CPU环境中使用多条GC线程，从而垃圾回收的时间减少，从而用户线程停顿的时间也减少；2.实现GC线程与用户线程并发执行。所谓并发，就是用户线程与GC线程交替执行，从而每次停顿的时间会减少，用户感受到的停顿感降低，但线程之间不断切换意味着需要额外的开销，从而垃圾回收和用户线程的总时间将会延长。 Parallel Scavenge提供的参数 设置“吞吐量”通过参数-XX:GCTimeRadio设置垃圾回收时间占总CPU时间的百分比。 设置“停顿时间”通过参数-XX:MaxGCPauseMillis设置垃圾处理过程最久停顿时间。Parallel Scavenge会根据这个值的大小确定新生代的大小。如果这个值越小，新生代就会越小，从而收集器就能以较短的时间进行一次回收。但新生代变小后，回收的频率就会提高，因此要合理控制这个值。 启用自适应调节策略通过命令-XX:+UseAdaptiveSizePolicy就能开启自适应策略。我们只要设置好堆的大小和MaxGCPauseMillis或GCTimeRadio，收集器会自动调整新生代的大小、Eden和Survior的比例、对象进入老年代的年龄，以最大程度上接近我们设置的MaxGCPauseMillis或GCTimeRadio。 老年代垃圾收集器 1. Serial Old垃圾收集器 Serial Old收集器是Serial的老年代版本，它们都是单线程收集器，也就是垃圾收集时只启动一条GC线程，因此都适合客户端应用。 它们唯一的区别就是Serial Old工作在老年代，使用“标记-整理”算法；而Serial工作在新生代，使用“复制”算法。 2. Parallel Old垃圾收集器 Parallel Old收集器是Parallel Scavenge的老年代版本，一般它们搭配使用，追求CPU吞吐量。它们在垃圾收集时都是由多条GC线程并行执行，并停止一切用户线程。因此，由于在垃圾清理过程中没有使垃圾收集和用户线程并行执行，因此它们是追求吞吐量的垃圾收集器。 3. CMS垃圾收集器 CMS收集器是一款追求停顿时间的老年代收集器，它在垃圾收集时使得用户线程和GC线程并行执行，因此在垃圾收集过程中用户也不会感受到明显的卡顿。但用户线程和GC线程之间不停地切换会有额外的开销，因此垃圾回收总时间就会被延长。 垃圾回收过程 初始标记停止一切用户线程，仅使用一条初始标记线程对所有与GC ROOTS直接关联的对象进行标记。速度很快。 并发标记使用多条并发标记线程并行执行，并与用户线程并发执行。此过程进行可达性分析，标记出所有废弃的对象。速度很慢。 重新标记停止一切用户线程，并使用多条重新标记线程并行执行，将刚才并发标记过程中新出现的废弃对象标记出来。这个过程的运行时间介于初始标记和并发标记之间。 并发清除只使用一条并发清除线程，和用户线程们并发执行，清除刚才标记的对象。这个过程非常耗时。 CMS的缺点 吞吐量低由于CMS在垃圾收集过程使用用户线程和GC线程并行执行，从而线程切换会有额外开销，因此CPU吞吐量就不如在垃圾收集过程中停止一切用户线程的方式来的高。 无法处理浮动垃圾，导致频繁Full GC由于垃圾清除过程中，用户线程和GC线程并发执行，也就是用户线程仍在执行，那么在执行过程中会产生垃圾，这些垃圾称为“浮动垃圾”。如果CMS在垃圾清理过程中，用户线程需要在老年代中分配内存时发现空间不足时，就需要再次发起Full GC，而此时CMS正在进行清除工作，因此此时只能由Serial Old临时对老年代进行一次Full GC。 使用“标记-清除”算法产生碎片空间由于CMS使用了“标记-清除”算法， 因此清除之后会产生大量的碎片空间，不利于空间利用率。不过CMS提供了应对策略： 开启-XX:+UseCMSCompactAtFullCollection开启该参数后，每次FullGC完成后都会进行一次内存压缩整理，将零散在各处的对象整理到一块儿。但每次都整理效率不高，因此提供了以下参数。 设置参数-XX:CMSFullGCsBeforeCompaction本参数告诉CMS，经过了N次Full GC过后再进行一次内存整理。 通用垃圾收集器——G1垃圾收集器 G1是目前最牛逼的垃圾收集器。 G1的特点 追求停顿时间 多线程GC 面向服务端应用 标记-整理和复制算法合并不会产生碎片内存。 可对整个堆进行垃圾回收 可预测停顿时间 G1的内存模型 G1垃圾收集器没有新生代和老年代的概念了，而是将堆划分为一块块独立的Region。当要进行垃圾收集时，首先估计每个Region中的垃圾数量，每次都从垃圾回收价值最大的Region开始回收，因此可以获得最大的回收效率。 Remembered Set 一个对象和它内部所引用的对象可能不在同一个Region中，那么当垃圾回收时，是否需要扫描整个堆内存才能完整地进行一次可达性分析？ 当然不是，每个Region都有一个Remembered Set，用于记录本区域中所有对象引用的对象所在的区域，从而在进行可达性分析时，只要在GC ROOTs中再加上Remembered Set即可防止对所有堆内存的遍历。 G1垃圾收集过程 初始标记标记与GC ROOTS直接关联的对象，停止所有用户线程，只启动一条初始标记线程，这个过程很快。 并发标记进行全面的可达性分析，开启一条并发标记线程与用户线程并行执行。这个过程比较长。 最终标记标记出并发标记过程中用户线程新产生的垃圾。停止所有用户线程，并使用多条最终标记线程并行执行。 筛选回收回收废弃的对象。此时也需要停止一切用户线程，并使用多条筛选回收线程并行执行。
2018-03-19
优秀的个人博客,低调大师

java面试-深入理解JVM(二)——揭开HotSpot对象创建的奥秘

对象的创建过程 当虚拟机遇到一条含有new的指令时，会进行一系列对象创建的操作： 检查常量池中是否有即将要创建的这个对象所属的类的符号引用； 若常量池中没有这个类的符号引用，说明这个类还没有被定义！抛出ClassNotFoundException； 若常量池中有这个类的符号引用，则进行下一步工作； 进而检查这个符号引用所代表的类是否已经被JVM加载； 若该类还没有被加载，就找该类的class文件，并加载进方法区； 若该类已经被JVM加载，则准备为对象分配内存； 根据方法区中该类的信息确定该类所需的内存大小；一个对象所需的内存大小是在这个对象所属类被定义完就能确定的！且一个类所生产的所有对象的内存大小是一样的！JVM在一个类被加载进方法区的时候就知道该类生产的每一个对象所需要的内存大小。 从堆中划分一块对应大小的内存空间给新的对象；分配堆中内存有两种方式： 指针碰撞如果JVM的垃圾收集器采用复制算法或标记-整理算法，那么堆中空闲内存是完整的区域，并且空闲内存和已使用内存之间由一个指针标记。那么当为一个对象分配内存时，只需移动指针即可。因此，这种在完整空闲区域上通过移动指针来分配内存的方式就叫做“指针碰撞”。 空闲列表如果JVM的垃圾收集器采用标记-清除算法，那么堆中空闲区域和已使用区域交错，因此需要用一张“空闲列表”来记录堆中哪些区域是空闲区域，从而在创建对象的时候根据这张“空闲列表”找到空闲区域，并分配内存。综上所述：JVM究竟采用哪种内存分配方法，取决于它使用了何种垃圾收集器。 为对象中的成员变量赋上初始值(默认初始化)； 设置对象头中的信息； 调用对象的构造函数进行初始化此时，整个对象的创建过程就完成了。 对象的内存模型 一个对象从逻辑角度看，它由成员变量和成员函数构成，从物理角度来看，对象是存储在堆中的一串二进制数，这串二进制数的组织结构如下。 对象在内存中分为三个部分： 对象头 实例数据 对齐补充 1. 对象头 对象头中记录了对象在运行过程中所需要使用的一些数据：哈希码、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等。 此外，对象头中可能还包含类型指针。通过该指针能确定这个对象所属哪个类。 此外，如果对象是一个数组，那么对象头中还要包含数组长度。 2. 实例数据 实力数据部分就是成员变量的值，其中包含父类的成员变量和本类的成员变量。 3. 对齐补充 用于确保对象的总长度为8字节的整数倍。HotSpot要求对象的总长度必须是8字节的整数倍。由于对象头一定是8字节的整数倍，但实例数据部分的长度是任意的，因此需要对齐补充字段确保整个对象的总长度为8的整数倍。 访问对象的过程 我们知道，引用类型的变量中存放的是一个地址，那么根据地址类型的不同，对象有不同的访问方式： 句柄访问方式堆中需要有一块叫做“句柄池”的内存空间，用于存放所有对象的地址和所有对象所属类的类信息。引用类型的变量存放的是该对象在句柄池中的地址。访问对象时，首先需要通过引用类型的变量找到该对象的句柄，然后根据句柄中对象的地址再访问对象。 直接指针访问方式引用类型的变量直接存放对象的地址，从而不需要句柄池，通过引用能够直接访问对象。但对象所在的内存空间中需要额外的策略存储对象所属的类信息的地址。 比较 HotSpot采用直接指针方式访问对象，因为它只需一次寻址操作，从而性能比句柄访问方式快一倍。但它需要额外的策略存储对象在方法区中类信息的地址。
2018-03-19
优秀的个人博客,低调大师

Java并发编程的艺术(一)——并发编程需要注意的问题

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_34173549/article/details/79612496 并发是为了提升程序的执行速度，但并不是多线程一定比单线程高效，而且并发编程容易出错。若要实现正确且高效的并发，就要在开发过程中时刻注意以下三个问题： 上下文切换 死锁 资源限制 接下来会逐一分析这三个问题，并给出相应的解决方案。 问题一：上下文切换会带来额外的开销 线程的运行机制 一个CPU每个时刻只能执行一条线程； 操作系统给每条线程分配不同长度的时间片； 操作系统会从一堆线程中随机选取一条来执行； 每条线程用完自己的时间片后，即使任务还没完成，操作系统也会剥夺它的执行权，让另一条线程执行 什么是“上下文切换”？ 当一条线程的时间片用完后，操作系统会暂停该线程，并保存该线程相应的信息，然后再随机选择一条新线程去执行，这个过程就称为“线程的上下文切换”。 上下文切换的过程 暂停正在执行的线程； 保存该线程的相关信息（如：执行到哪一行、程序计算的中间结果等） 从就绪队列中随机选一条线程； 读取该线程的上下文信息，继续执行 上下文切换是有开销的 每次进行上下文切换时都需要保存当前线程的执行状态，并加载新线程先前的状态。如果上下文切换频繁，CPU花在上下文切换上的时间占比就会上升，而真正处理任务的时间占比就会下降。因此，为了提高并发程序的执行效率，让CPU把时间花在刀刃上，我们需要减少上下文切换的次数。 如何减少上下文切换？ 减少线程的数量由于一个CPU每个时刻只能执行一条线程，而傲娇的我们又想让程序并发执行，操作系统只好不断地进行上下文切换来使我们从感官上觉得程序是并发执的行。因此，我们只要减少线程的数量，就能减少上下文切换的次数。然而如果线程数量已经少于CPU核数，每个CPU执行一条线程，照理来说CPU不需要进行上下文切换了，但事实并非如此。 控制同一把锁上的线程数量如果多条线程共用同一把锁，那么当一条线程获得锁后，其他线程就会被阻塞；当该线程释放锁后，操作系统会从被阻塞的线程中选一条执行，从而又会出现上下文切换。因此，减少同一把锁上的线程数量也能减少上下文切换的次数。 采用无锁并发编程我们知道，如果减少同一把锁上线程的数量就能减少上下文切换的次数，那么如果不用锁，是否就能避免因竞争锁而产生的上下文切换呢？答案是肯定的！但你需要根据以下两种情况挑选不同的策略： 需要并发执行的任务是无状态的：HASH分段所谓无状态是指并发执行的任务没有共享变量，他们都独立执行。对于这种类型的任务可以按照ID进行HASH分段，每段用一条线程去执行。 需要并发执行的任务是有状态的：CAS算法如果任务需要修改共享变量，那么必须要控制线程的执行顺序，否则会出现安全性问题。你可以给任务加锁，保证任务的原子性与可见性，但这会引起阻塞，从而发生上下文切换；为了避免上下文切换，你可以使用CAS算法， 仅在线程内部需要更新共享变量时使用CAS算法来更新，这种方式不会阻塞线程，并保证更新过程的安全性。 问题二：并发不当可能会产生死锁 什么是“死锁”？ 当多个线程相互等待已经被对方占用的资源时，就会产生死锁。 死锁示例 class DeadLock { // 锁A private Object lockA; // 锁B private Object lockB; // 第一条线程 Thread t1 = new Thread(new Runnable(){ void run () { synchronized (lockA) { Thread.sleep(5000); synchronized (lockB) { System.out.println("线程1"); } } } }).start(); // 第二条线程 Thread t2 = new Thread(new Runnable(){ void run () { synchronized (lockB) { Thread.sleep(5000); synchronized (lockA) { System.out.println("线程2"); } } } }).start(); } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 线程1和线程2都需要锁A和锁B 线程1首先获得锁A，然后sleep 5秒PS：线程sleep过程中会释放执行权 此时线程2执行，获得锁B，然后也sleep 5秒； 线程1 sleep 5秒后继续执行，此时需要锁B，然而锁B已经被线程2持有，因此线程1被阻塞； 此时线程2醒了，它需要锁A，然而锁A已经被线程1持有，因此它也被阻塞； 此时死锁出现了！两条线程相互等待已经被占用的资源，程序就死在这了。死锁是并发编程中一个重要的问题，上面介绍的减少上下文切换只是为了提升程序的性能，而一旦产生死锁，程序就不能正确执行！ 如何避免死锁？ 不要在一条线程中嵌套使用多个锁； 不要在一条线程中嵌套占用多个计算机资源； 给锁和资源加超时时间如果你非要在一条线程中嵌套使用多个锁或占用多个资源，那你需要给锁、资源加超时时间，从而避免无限期的等待。 问题三：计算机资源会限制并发 误区：线程越多速度越快 在并发编程中，并不是线程越多越好，有时候线程多了反而会拉低执行效率，原因如下： 线程多了会导致上下文切换增多，CPU花在上下文切换的时间增多后，花在处理任务上的时间自然就减少了。 计算机资源会限制程序的并发度。 比如：你家网入口带宽10M，你写了个多线程下载的软件，同时开100条线程下载，那每条线程平均以每秒100k的速度下载，然而100条线程之间还要不断进行上下文切换，所以你还不如只开5条线程，每条平均2M/s的速度下载。 再比如：数据库连接池最多给你用10个连接，然而你却开了100条线程进行数据库操作，那么当10个用完后其他线程就要等待，从而操作系统要在这100条线程间不断进行上下文切换；所以与其这样还不如只开10条线程，减少上下文切换的次数。 说了这么多只想告诉你一个道理：线程并不是越多越好，要根据当前计算机所能提供的资源考虑。 什么是“资源”？ 资源分为硬件资源和软件资源： 硬件资源 硬盘读写速度 网络带宽 等 软件资源 Socket连接数 数据库连接数 等 如何解决资源的限制？ 花钱买更高级的机器 根据资源限制并发度
2018-03-19
优秀的个人博客,低调大师

Java并发编程的艺术(九)——批量获取多条线程的执行结果

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_34173549/article/details/79612353 当向线程池提交callable任务后，我们可能需要一次性获取所有返回结果，有三种处理方法。 方法一：自己维护返回结果 // 创建一个线程池 ExecutorService executorService = Executors.newFixedThreadPool(10); // 存储执行结果的List List<Future<String>> results = new ArrayList<Future<String>>(); // 提交10个任务 for ( int i=0; i<10; i++ ) { Future<String> result = executorService.submit( new Callable<String>(){ public String call(){ int sleepTime = new Random().nextInt(1000); Thread.sleep(sleepTime); return "线程"+i+"睡了"+sleepTime+"秒"; } } ); // 将执行结果存入results中 results.add( result ); } // 获取10个任务的返回结果 for ( int i=0; i<10; i++ ) { // 获取包含返回结果的future对象 Future<String> future = results.get(i); // 从future中取出执行结果（若尚未返回结果，则get方法被阻塞，直到结果被返回为止） String result = future.get(); System.out.println(result); } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 此方法的弊端： 需要自己创建容器维护所有的返回结果，比较麻烦； 从list中遍历的每个Future对象并不一定处于完成状态，这时调用get()方法就会被阻塞住，如果系统是设计成每个线程完成后就能根据其结果继续做后面的事，这样对于处于list后面的但是先完成的线程就会增加了额外的等待时间。 方法二：使用ExecutorService的invokeAll函数 本方法能解决第一个弊端，即并不需要自己去维护一个存储返回结果的容器。当我们需要获取线程池所有的返回结果时，只需调用invokeAll函数即可。但是，这种方式需要你自己去维护一个用于存储任务的容器。 // 创建一个线程池 ExecutorService executorService = Executors.newFixedThreadPool(10); // 创建存储任务的容器 List<Callable<String>> tasks = new ArrayList<Callable<String>>(); // 提交10个任务 for ( int i=0; i<10; i++ ) { Callable<String> task = new Callable<String>(){ public String call(){ int sleepTime = new Random().nextInt(1000); Thread.sleep(sleepTime); return "线程"+i+"睡了"+sleepTime+"秒"; } }; executorService.submit( task ); // 将task添加进任务队列 tasks.add( task ); } // 获取10个任务的返回结果 List<Future<String>> results = executorService.invokeAll( tasks ); // 输出结果 for ( int i=0; i<10; i++ ) { // 获取包含返回结果的future对象 Future<String> future = results.get(i); // 从future中取出执行结果（若尚未返回结果，则get方法被阻塞，直到结果被返回为止） String result = future.get(); System.out.println(result); } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 方法三：使用CompletionService CompletionService内部维护了一个阻塞队列，只有执行完成的任务结果才会被放入该队列，这样就确保执行时间较短的任务率先被存入阻塞队列中。 ExecutorService exec = Executors.newFixedThreadPool(10); final BlockingQueue<Future<Integer>> queue = new LinkedBlockingDeque<Future<Integer>>( 10); //实例化CompletionService final CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>( exec, queue); // 提交10个任务 for ( int i=0; i<10; i++ ) { executorService.submit( new Callable<String>(){ public String call(){ int sleepTime = new Random().nextInt(1000); Thread.sleep(sleepTime); return "线程"+i+"睡了"+sleepTime+"秒"; } } ); } // 输出结果 for ( int i=0; i<10; i++ ) { // 获取包含返回结果的future对象（若整个阻塞队列中还没有一条线程返回结果，那么调用take将会被阻塞，当然你可以调用poll，不会被阻塞，若没有结果会返回null，poll和take返回正确的结果后会将该结果从队列中删除） Future<String> future = completionService.take(); // 从future中取出执行结果，这里存储的future已经拥有执行结果，get不会被阻塞 String result = future.get(); System.out.println(result); }
2018-03-18
优秀的个人博客,低调大师

Java并发编程的艺术(八)——闭锁、同步屏障、信号量详解

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_34173549/article/details/79612374 1. 闭锁：CountDownLatch 1.1 使用场景 若有多条线程，其中一条线程需要等到其他所有线程准备完所需的资源后才能运行，这样的情况可以使用闭锁。 1.2 代码实现 // 初始化闭锁，并设置资源个数 CountDownLatch latch = new CountDownLatch(2); Thread t1 = new Thread( new Runnable(){ public void run(){ // 加载资源1 加载资源的代码…… // 本资源加载完后，闭锁-1 latch.countDown(); } } ).start(); Thread t2 = new Thread( new Runnable(){ public void run(){ // 加载资源2 资源加载代码…… // 本资源加载完后，闭锁-1 latch.countDown(); } } ).start(); Thread t3 = new Thread( new Runnable(){ public void run(){ // 本线程必须等待所有资源加载完后才能执行 latch.await(); // 当闭锁数量为0时，await返回，执行接下来的任务 任务代码…… } } ).start(); 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 2. 同步屏障：CyclicBarrier 2.1 使用场景 若有多条线程，他们到达屏障时将会被阻塞，只有当所有线程都到达屏障时才能打开屏障，所有线程同时执行，若有这样的需求可以使用同步屏障。此外，当屏障打开的同时还能指定执行的任务。 2.2 闭锁 与 同步屏障 的区别 闭锁只会阻塞一条线程，目的是为了让该条任务线程满足条件后执行； 而同步屏障会阻塞所有线程，目的是为了让所有线程同时执行（实际上并不会同时执行，而是尽量把线程启动的时间间隔降为最少）。 2.3 代码实现 // 创建同步屏障对象，并制定需要等待的线程个数 和 打开屏障时需要执行的任务 CyclicBarrier barrier = new CyclicBarrier(3,new Runnable(){ public void run(){ //当所有线程准备完毕后触发此任务 } }); // 启动三条线程 for( int i=0; i<3; i++ ){ new Thread( new Runnable(){ public void run(){ // 等待，（每执行一次barrier.await，同步屏障数量-1，直到为0时，打开屏障） barrier.await(); // 任务 任务代码…… } } ).start(); } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 3. 信号量：Semaphore 3.1 使用场景 若有m个资源，但有n条线程（n>m），因此同一时刻只能允许m条线程访问资源，此时可以使用Semaphore控制访问该资源的线程数量。 3.2 代码实现 // 创建信号量对象，并给予3个资源 Semaphore semaphore = new Semaphore(3); // 开启10条线程 for ( int i=0; i<10; i++ ) { new Thread( new Runnbale(){ public void run(){ // 获取资源，若此时资源被用光，则阻塞，直到有线程归还资源 semaphore.acquire(); // 任务代码 …… // 释放资源 semaphore.release(); } } ).start(); }
2018-03-18

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

时间: 2026-04-11 大小: 211.28KB 下载: 56次
腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

时间: 2026-04-11 大小: 1MB 下载: 9次
Rocky Linux

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

时间: 2026-04-12 大小: 1.42GB 下载: 4次
Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

时间: 2025-12-03 大小: 9.84MB 下载: 39次
热门标签
DeepSeek Jdk25 OpenAi HarmonyOS6 Nacos3 SpringBoot4 SpringCloud Docker Kubernetes Service Mesh Redis Gemini3 Rocky

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册