[ArrayList作为共享资源的并发控制...]的搜索结果

...在本文中，Redis作为数据存储和协调工具，在微服务架构设计中承担了关键角色，如实现数据共享、状态同步以及服务间通信等。 分布式锁 , 分布式锁是一种在分布式系统环境下，用于控制多个服务或进程对共享资源访问的同步机制。当多个微服务需要同时操作同一份资源时，通过Redis提供的分布式锁功能，可以确保在同一时刻只有一个服务能获取并操作该资源，从而保证数据的一致性和完整性。 Redis Cluster , Redis Cluster是Redis官方提供的一种分布式解决方案，允许用户将数据分散存储在多台机器上，形成一个分布式数据库集群。在微服务场景下，Redis Cluster通过分片（sharding）技术，可有效应对海量数据和高并发访问，提升系统的扩展性和性能，并确保各个微服务之间的松耦合，降低数据孤岛问题带来的风险。 哈希（Hash）数据结构 , 在Redis中，哈希数据结构是一种键值对集合，它允许用户在一个键下关联多个字段和值。文中提到的使用Redis Hash作为“数据字典”，意味着可以将复杂的数据结构，如用户的权限列表，以键值对的形式存储在Redis中，方便快速查询与更新，极大提升了系统处理这类需求的效率。 持久化 , 持久化是指将程序运行过程中的数据保存到非易失性存储介质中，即使在系统重启后也能恢复这些数据。Redis提供了两种持久化策略，即RDB（Redis Database）和AOF（Append-only File），以确保在内存中的数据能在断电、故障等情况下得以持久保存，满足不同业务场景对于数据安全性的要求。

...现锁机制的方法，用于控制多个不同节点对共享资源的访问。在本文上下文中，分布式锁通过HBase数据库实现，确保在多线程或分布式环境下，同一时刻只有一个任务能修改特定的数据或执行特定的操作，防止并发冲突。 RowKey , RowKey是HBase表中的行键，它是HBase数据模型的核心部分。每个RowKey在表中都是唯一的，类似于关系型数据库中的主键。在本文讨论的分布式锁实现中，RowKey被用来作为锁的唯一标识符或者锁定资源的标识，通过插入和删除具有特定RowKey的行来表示锁的获取与释放。 Zookeeper , Zookeeper是一个开源的分布式的，为大型分布式系统提供协调服务的 Apache项目。它主要负责维护配置信息、命名服务、集群管理、分布式同步等。在HBase分布式锁实现的场景中，虽然文章示例代码未直接使用Zookeeper，但提到了实际应用中可以结合Zookeeper的临时有序节点特性优化分布式锁服务，以实现更高级别的容错性和锁的超时自动释放等功能。

...，例如增强的读写操作并发控制、改进的内存管理机制以及对云原生部署的更好支持，这些都进一步提升了HBase在实时分析、大规模数据存储及快速检索等方面的表现。 同时，随着5G、物联网(IoT)等技术的发展，产生的数据量呈现出指数级增长态势，对于高效、灵活且可扩展的数据处理解决方案的需求愈发强烈。近日，《InfoWorld》的一篇深度报道指出，多个国际知名互联网企业已将HBase作为其核心数据平台的重要组成部分，成功支撑起每日数十亿级别的数据访问请求，充分验证了HBase在应对超大规模数据挑战时的卓越能力。 此外，针对HBase的学习资源也在不断丰富和完善中。Apache软件基金会联合多家教育机构共同推出了线上课程和实战培训项目，旨在帮助开发者深入理解HBase的架构原理，并掌握如何在实际业务场景中有效运用。未来，HBase将持续引领NoSQL数据库技术潮流，为全球企业和开发者提供更加先进、可靠的大数据处理工具。

...本质上是一个接收函数作为输入并返回新函数的高阶函数。通过使用@语法糖，装饰器可以在不改变原有函数源代码的情况下为其添加新的功能，如日志记录、性能测试、权限控制等。文中给出的装饰器outer接收一个名为func的函数，并在其前后分别添加了特定行为（输出“我要睡觉了”和“我起床了”）后返回一个新的包装后的函数。 单例模式 , 在面向对象编程设计模式中，单例模式确保某类在整个应用程序的生命周期内只创建一个实例，并提供全局访问点。通过限制对象的实例化次数，单例模式可以有效管理共享资源，避免重复创建带来的开销以及数据一致性问题。文章中的单例模式示例定义了一个strTool类，但并没有展示其实现细节；然后通过两次调用strTool()生成两个对象t1和t2，并打印它们的内存地址来验证这两个对象实际上是同一个实例，即实现了单例模式的效果。

...。在这方面，Etcd作为一款高性能的分布式键值存储系统，正逐渐成为开发者和运维人员的首选工具。最近的一个典型案例来自某知名电商公司，他们通过引入Etcd实现了跨数据中心的库存同步管理，显著提升了系统的可用性和响应速度。这一成功实践不仅证明了Etcd在高并发场景下的稳定性，也展示了其在大规模分布式系统中的广泛应用前景。 与此同时，Etcd社区也在不断迭代更新，最新版本已支持更多高级特性，例如更高效的压缩算法和更强的安全加密机制。这些改进使得Etcd在面对日益复杂的分布式环境时更具竞争力。值得一提的是，国内某大型云计算服务商近日宣布将全面支持Etcd 3.x系列，并计划在未来几个月内推出基于Etcd的托管服务，为企业用户提供更加便捷的部署和管理体验。 此外，关于分布式事务管理的话题，近期有专家指出，尽管Etcd提供了强大的工具集，但在实际应用中仍需谨慎对待事务的粒度和范围。过细的事务划分可能导致性能瓶颈，而过于粗略的设计则可能引发数据不一致的风险。因此，在设计分布式事务时，需要综合考虑业务逻辑、系统规模以及硬件资源等因素，制定合理的策略。 最后，回顾历史，我们可以发现，无论是早期的ZooKeeper还是如今的Etcd，这类分布式协调服务始终伴随着分布式计算的发展而演进。正如《分布式系统设计》一书中提到的：“分布式系统的设计是一门艺术，它要求我们在灵活性与可靠性之间找到平衡。”未来，随着5G、物联网等新技术的兴起，分布式系统的复杂性将进一步增加，而像Etcd这样的工具无疑将在其中扮演越来越重要的角色。

...不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。 前言 今年因为这个疫情，感觉这是从工作以来过的最久的一个年了，在家呆的时间不是一般的久，算一算有好几个月呢！我大概是3月底快4月了才出门，投了超多的简历，天天面试面试面试面试面试面试面试…庆幸的是还是上岸了（嘻嘻开心开心）。但其实所谓的庆幸也是靠努力堆起来的，我记忆力还比较好，背一背，没啥难的，背了1000道题。。。（注：关于我背的这1000题，文末有分享） 眼看着6月就过去了，再过两天就7月份了，想着面试大军可能也过不了几天就要来了，所以这两天整理了一些面经，今天给大家看的是“美团+字节跳动+腾讯”这三家的，每家一二三面，我想大家可以自己测试一下能坚持到哪里。 01 阿里中间件（四面，Java岗） 1.1 Java中间件一面 技术一面考察范围 重点问了Java线程锁：synchronized 和ReentrantLock相关的底层实现 线程池的底层实现以及常见的参数 数据结构基本都问了一遍：链表、队列等 Java内存模型：常问的JVM分代模型，以及JDK1.8后的区别，最后还问了JVM相关的调优参数 分布式锁的实现比较技术 一面题目 自我介绍 擅长哪方面的技术？ java有哪些锁中类？（乐观锁&悲观锁、可重入锁&Synchronize等）。 比较重要的数据结构，如链表，队列，栈的基本原理及大致实现 J.U.C下的常见类的使用。Threadpool的深入考察；blockingQueue的使用 Java内存分代模型，GC算法，JVM常见的启动参数；CMS算法的过程。 Volatile关键字有什么用（包括底层原理） 线程池的调优策略 Spring cloud的服务注册与发现是怎么设计的？ 分布式系统的全局id如何实现 分布式锁的方案，redis和zookeeper那个好，如果是集群部署，高并发情况下那个性能更好。 1.2 Java中间件二面 技术二面考察范围： 问了项目相关的技术实现细节 数据库相关：索引、索引底层实现、mysql相关的行锁、表锁等 redis相关：架构设计、数据一致性问题 容器:容器的设计原理等技术 二面题目： 参与的项目，选一个，技术难度在哪里？ Collections.sort底层排序方式 负载均衡的原理设计模式与重构，谈谈你对重构的理解 谈谈redis相关的集群有哪些成熟方案？ 再谈谈一致hash算法（redis）？ 数据库索引，B+树的特性和建树过程 Mysql相关的行锁，表锁；乐观锁，悲观锁 谈谈多线程和并发工具的使用 谈谈redis的架构和组件 Redis的数据一致性问题（分布式多节点环境&单机环境） Docker容器 1.3 Java中间件三面 技术三面考察范围： 主要谈到了高并发的实现方案 以及中间件：redis、rocketmq、kafka等的架构设计思路 最后问了平时怎么提升技术的技术 三面题目 高并发情况下，系统是如何支撑大量的请求的？ 接着上面的问题，延伸到了中间件，kafka、redis、rocketmq、mycat等设计思路和适用场景等 最近上过哪些技术网站；最近再看那些书。 工作和生活中遇见最大的挑战，怎么去克服？ 未来有怎样的打算 1.4 Java中间件四面 最后，你懂的，主要就是HR走流程了，主要问了未来的职业规划。 02 头条Java后台3面 2.1 头条一面 讲讲jvm运行时数据库区 讲讲你知道的垃圾回收算法 jvm内存模型jmm 内存泄漏与内存溢出的区别 select、epool 的区别？底层的数据结构是什么？ mysql数据库默认存储引擎，有什么优点 优化数据库的方法，从sql到缓存到cpu到操作系统，知道多少说多少 什么情景下做分表，什么情景下做分库 linkedList与arrayList区别 适用场景 array list是如何扩容的 volatile 关键字的作用？Java 内存模型？ java lock的实现，公平锁、非公平锁 悲观锁和乐观锁，应用中的案例，mysql当中怎么实现，java中的实现 2.2 头条二面 Java 内存分配策略？ 多个线程同时请求内存，如何分配？ Redis 底层用到了哪些数据结构？ 使用 Redis 的 set 来做过什么？ Redis 使用过程中遇到什么问题？ 搭建过 Redis 集群吗？ 如何分析“慢查询”日志进行 SQL/索引 优化？ MySQL 索引结构解释一下？（B+ 树） MySQL Hash 索引适用情况？举下例子？ 2.3 头条三面 如何保证数据库与redis缓存一致的Redis 的并发竞争问题是什么？ 如何解决这个问题？ 了解 Redis 事务的 CAS 方案吗？ 如何保证 Redis 高并发、高可用？ Redis 的主从复制原理，以及Redis 的哨兵原理？ 如果让你写一个消息队列，该如何进行架构设计啊？说一下你的思路。 MySQL数据库主从同步怎么实现？ 秒杀模块怎么设计的，如何压测，抗压手段 03 今日头条Java后台研发三面 3.1 一面 concurrent包下面用过哪些？ countdownlatch功能实现 synchronized和lock区别，重入锁thread和runnable的区别 AtomicInteger实现原理(CAS自旋) java并发sleep与wait、notify与notifyAll的区别 如何实现高效的同步链表 java都有哪些加锁方式（synchronized、ReentrantLock、共享锁、读写锁等） 设计模式（工厂模式、单例模式（几种情况）、适配器模式、装饰者模式） maven依赖树，maven的依赖传递，循环依赖 3.2 二面 synchronized和reentrantLock的区别，synchronized用在代码快、方法、静态方法时锁的都是什么? 介绍spring的IOC和AOP，分别如何实现(classloader、动态代理)JVM的内存布局以及垃圾回收原理及过程 讲一下，讲一下CMS垃圾收集器垃圾回收的流程，以及CMS的缺点 redis如何处理分布式服务器并发造成的不一致OSGi的机制spring中bean加载机制，bean生成的具体步骤，ioc注入的方式spring何时创建- applicationContextlistener是监听哪个事件？ 介绍ConcurrentHashMap原理，用的是哪种锁，segment有没可能增大? 解释mysql索引、b树，为啥不用平衡二叉树、红黑树 Zookeeper如何同步配置 3.3 三面 Java线程池ThreadPoolEcecutor参数，基本参数，使用场景 MySQL的ACID讲一下，延伸到隔离级别 dubbo的实现原理，说说RPC的要点 GC停顿原因，如何降低停顿？ JVM如何调优、参数怎么调？ 如何用工具分析jvm状态（visualVM看堆中对象的分配，对象间的引用、是否有内存泄漏，jstack看线程状态、是否死锁等等） 描述一致性hash算法 分布式雪崩场景如何避免? 再谈谈消息队列 04 抖音Java 三面 4.1 一面： hashmap，怎么扩容，怎么处理数据冲突？ 怎么高效率的实现数据迁移？ Linux的共享内存如何实现，大概说了一下。 socket网络编程，说一下TCP的三次握手和四次挥手同步IO和异步IO的区别？ Java GC机制？GC Roots有哪些？ 红黑树讲一下，五个特性，插入删除操作,时间复杂度？ 快排的时间复杂度，最坏情况呢，最好情况呢，堆排序的时间复杂度呢，建堆的复杂度是多少 4.2 二面： 自我介绍，主要讲讲做了什么和擅长什么 设计模式了解哪些？ AtomicInteger怎么实现原子修改的？ ConcurrentHashMap 在Java7和Java8中的区别？ 为什么Java8并发效率更好？什么情况下用HashMap，什么情况用ConcurrentHashMap？ redis数据结构？ redis数据淘汰机制？ 4.3 三面（约五十分钟）： mysql实现事务的原理(MVCC) MySQL数据主从同步是如何实现的？ MySQL索引的实现，innodb的索引，b+树索引是怎么实现的，为什么用b+树做索引节点，一个节点存了多少数据，怎么规定大小，与磁盘页对应。 如果Redis有1亿个key，使用keys命令是否会影响线上服务？ Redis的持久化方式，aod和rdb，具体怎么实现，追加日志和备份文件，底层实现原理的话知道么? 遇到最大困难是什么？怎么克服？ 未来的规划是什么？ 你想问我什么？ 05 百度三面 5.1 百度一面 自我介绍 Java中的多态 为什么要同时重写hashcode和equals Hashmap的原理 Hashmap如何变线程安全，每种方式的优缺点 垃圾回收机制 Jvm的参数你知道的说一下 设计模式了解的说一下啊 手撕一个单例模式 手撕算法：反转单链表 手撕算法：实现类似微博子结构的数据结构，输入一系列父子关系，输出一个类似微博评论的父子结构图 手写java多线程 手写java的soeket编程，服务端和客户端 手撕算法： 爬楼梯，写出状态转移方程 智力题：时针分针什么时候重合 5.2 百度二面（现场） 自我介绍 项目介绍 服务器如何负载均衡，有哪些算法，哪个比较好，一致性哈希原理，怎么避免DDOS攻击请求打到少数机器。 TCP连接中的三次握手和四次挥手，四次挥手的最后一个ack的作用是什么，为什么要time wait，为什么是2msl。 数据库的备份和恢复怎么实现的，主从复制怎么做的，什么时候会出现数据不一致，如何解决。 Linux查看cpu占用率高的进程 手撕算法：给定一个数字三角形，找到从顶部到底部的最小路径和。每一步可以移动到下面一行的相邻数字上。 然后继续在这个问题上扩展 求出最短那条的路径 递归求出所有的路径 设计模式讲一下熟悉的 会不会滥用设计模式 多线程条件变量为什么要在while体里 你遇到什么挫折，怎么应对和处理 5.3 百度三面（现场） 自我介绍 项目介绍 Redis的特点 Redis的持久化怎么做，aof和rdb，有什么区别，有什么优缺点。 Redis使用哨兵部署会有什么问题，我说需要扩容的话还是得集群部署。 说一下JVM内存模型把，有哪些区，分别干什么的 说一下gc算法，分代回收说下 MySQL的引擎讲一下，有什么区别，使用场景呢 分布式事务了解么 反爬虫的机制，有哪些方式 06 蚂蚁中间件团队面试题 6.1 蚂蚁中间件一面： 自我介绍 JVM垃圾回收算法和垃圾回收器有哪些，最新的JDK采用什么算法。 新生代和老年代的回收机制。 讲一下ArrayList和linkedlist的区别，ArrayList与HashMap的扩容方式。 Concurrenthashmap1.8后的改动。 Java中的多线程，以及线程池的增长策略和拒绝策略了解么。 Tomcat的类加载器了解么 Spring的ioc和aop，Springmvc的基本架构，请求流程。 HTTP协议与Tcp有什么区别，http1.0和2.0的区别。 Java的网络编程，讲讲NIO的实现方式，与BIO的区别，以及介绍常用的NIO框架。 索引什么时候会失效变成全表扫描 介绍下分布式的paxos和raft算法 6.2 蚂蚁中间件二面 你在项目中怎么用到并发的。 消息队列的使用场景，谈谈Kafka。 你说了解分布式服务，那么你怎么理解分布式服务。 Dubbo和Spring Clound的区别，以及使用场景。 讲一下docker的实现原理，以及与JVM的区别。 MongoDB、Redis和Memcached的应用场景，各自优势 MongoDB有事务吗 Redis说一下sorted set底层原理 讲讲Netty为什么并发高，相关的核心组件有哪些 6.3 蚂蚁中间件三面 完整的画一个分布式集群部署图，从负载均衡到后端数据库集群。 分布式锁的方案，Redis和Zookeeper哪个好，如果是集群部署，高并发情况下哪个性能更好。 分布式系统的全局id如何实现。 数据库万级变成亿级，你如何来解决。 常见的服务器雪崩是由什么引起的，如何来防范。 异地容灾怎么实现 常用的高并发技术解决方案有哪些，以及对应的解决步骤。 07 京东4面(Java研发） 7.1 一面（基础面：约1小时） 自我介绍，主要讲讲做了什么和擅长什么 springmvc和spring-boot区别 @Autowired的实现原理 Bean的默认作用范围是什么？其他的作用范围？ 索引是什么概念有什么作用？MySQL里主要有哪些索引结构？哈希索引和B+树索引比较？ Java线程池的原理？线程池有哪些？线程池工厂有哪些线程池类型，及其线程池参数是什么？ hashmap原理，处理哈希冲突用的哪种方法？ 还知道什么处理哈希冲突的方法？ Java GC机制？GC Roots有哪些？ Java怎么进行垃圾回收的？什么对象会进老年代？垃圾回收算法有哪些？为什么新生代使用复制算法？ HashMap的时间复杂度？HashMap中Hash冲突是怎么解决的？链表的上一级结构是什么？Java8中的HashMap有什么变化？红黑树需要比较大小才能进行插入，是依据什么进行比较的？其他Hash冲突解决方式？ hash和B+树的区别？分别应用于什么场景？哪个比较好？ 项目里有个数据安全的，aes和md5的区别？详细点 7.2 二面（问数据库较多） 自我介绍 为什么MyISAM查询性能好？ 事务特性（acid） 隔离级别 SQL慢查询的常见优化步骤？ 说下乐观锁，悲观锁（select for update），并写出sql实现 TCP协议的三次握手和四次挥手过程？ 用到过哪些rpc框架 数据库连接池怎么实现 Java web过滤器的生命周期 7.3 三面（综合面；约一个小时） 自我介绍。 ConcurrentHashMap 在Java7和Java8中的区别？为什么Java8并发效率更好？什么情况下用HashMap，什么情况用ConcurrentHashMap？ 加锁有什么机制？ ThreadLocal？应用场景？ 数据库水平切分，垂直切分的设计思路和切分顺序 Redis如何解决key冲突 soa和微服务的区别？ 单机系统演变为分布式系统，会涉及到哪些技术的调整？请从前面负载到后端详细描述。 设计一个秒杀系统？ 7.4 四面（HR面） 你自己最大优势和劣势是什么 平时遇见过什么样的挑战，怎么去克服的 工作中遇见了技术解决不了的问题，你的应对思路？ 你的兴趣爱好？ 未来的职业规划是什么？ 08 美团java高级开发3面 8.1 美团一面 自我介绍 项目介绍 Redis介绍 了解redis源码么 了解redis集群么 Hashmap的原理，增删的情况后端数据结构如何位移 hashmap容量为什么是2的幂次 hashset的源码 object类你知道的方法 hashcode和equals 你重写过hashcode和equals么，要注意什么 假设现在一个学生类，有学号和姓名，我现在hashcode方法重写的时候，只将学号参与计算，会出现什么情况？ 往set里面put一个学生对象，然后将这个学生对象的学号改了，再put进去，可以放进set么？并讲出为什么 Redis的持久化？有哪些方式，原理是什么？ 讲一下稳定的排序算法和不稳定的排序算法 讲一下快速排序的思想 8.2 美团二面 自我介绍 讲一下数据的acid 什么是一致性 什么是隔离性 Mysql的隔离级别 每个隔离级别是如何解决 Mysql要加上nextkey锁，语句该怎么写 Java的内存模型，垃圾回收 线程池的参数 每个参数解释一遍 然后面试官设置了每个参数，给了是个线程，让描述出完整的线程池执行的流程 Nio和IO有什么区别 Nio和aio的区别 Spring的aop怎么实现 Spring的aop有哪些实现方式 动态代理的实现方式和区别 Linux了解么 怎么查看系统负载 Cpu load的参数如果为4，描述一下现在系统处于什么情况 Linux，查找磁盘上最大的文件的命令 Linux，如何查看系统日志文件 手撕算法：leeetcode原题 22，Generate Parentheses，给定 n 对括号，请- 写一个函数以将其生成新的括号组合，并返回所有组合结果。 8.3 美团三面（现场） 三面没怎么问技术，问了很多技术管理方面的问题 自我介绍 项目介绍 怎么管理项目成员 当意见不一致时，如何沟通并说服开发成员，并举个例子 怎么保证项目的进度 数据库的索引原理 非聚簇索引和聚簇索引 索引的使用注意事项 联合索引 从底层解释最左匹配原则 Mysql对联合索引有优化么？会自动调整顺序么？哪个版本开始优化？ Redis的应用 Redis的持久化的方式和原理 技术选型，一个新技术和一个稳定的旧技术，你会怎么选择，选择的考虑有哪些 说你印象最深的美团点评技术团队的三篇博客 最近在学什么新技术 你是怎么去接触一门新技术的 会看哪些书 怎么选择要看的书 最后 由于篇幅限制，小编在此截出几张知识讲解的图解，有需要的程序猿（媛）可以点赞后戳这里免费领取全部资料获取哦 子 怎么保证项目的进度 数据库的索引原理 非聚簇索引和聚簇索引 索引的使用注意事项 联合索引 从底层解释最左匹配原则 Mysql对联合索引有优化么？会自动调整顺序么？哪个版本开始优化？ Redis的应用 Redis的持久化的方式和原理 技术选型，一个新技术和一个稳定的旧技术，你会怎么选择，选择的考虑有哪些 说你印象最深的美团点评技术团队的三篇博客 最近在学什么新技术 你是怎么去接触一门新技术的 会看哪些书 怎么选择要看的书 最后 由于篇幅限制，小编在此截出几张知识讲解的图解，有需要的程序猿（媛）可以点赞后戳这里免费领取全部资料获取哦 [外链图片转存中…(img-SFREePIJ-1624074891834)] [外链图片转存中…(img-5kF3pkiC-1624074891834)] [外链图片转存中…(img-HDVXfOMR-1624074891835)] [外链图片转存中…(img-RyaAC5jy-1624074891836)] [外链图片转存中…(img-iV32C5Ok-1624074891837)] 本篇文章为转载内容。原文链接：https://blog.csdn.net/m0_57285325/article/details/118051767。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。 网页右边，向下滑有目录索引，可以根据标题跳转到你想看的内容 如果右边没有就找找左边 上一节：JUC锁，一些面试题和源码讲解 1、引用 java引用共4种，强软弱虚 强引用：我们普通的new一个对象，就是强引用，只有它指向为空了，或者已经没用了，才会被回收 软引用：JVM内存不够了，就回收软引用 弱引用：只要碰见垃圾回收器(System.gc())，就被回收 虚引用：对象当被回收时，会将其放在队列中 1、软引用 / 软引用 软引用是用来描述一些还有用但并非必须的对象。 对于软引用关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围进行第二次回收。 如果这次回收还没有足够的内存，才会抛出内存溢出异常。 -Xmx20M/import java.lang.ref.SoftReference;public class T02_SoftReference {public static void main(String[] args) {SoftReference<byte[]> m = new SoftReference<>(new byte[1024102410]);//创建软引用，分配10M//m = null;System.out.println(m.get());//获取System.gc();//垃圾回收try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(m.get());//再分配一个数组，heap将装不下，这时候系统会垃圾回收，先回收一次，如果不够，会把软引用干掉byte[] b = new byte[1024102415];System.out.println(m.get());} }//软引用非常适合缓存使用 2、弱引用 public class M {@Overrideprotected void finalize() throws Throwable {System.out.println("finalize");} } 上图中，tl对象强引用指向ThreadLocal，map中key弱引用指向ThreadLocal，当tl=null时，强引用消失，此时弱引用也将自动被回收，但是此时key=null，value指向10M这个就永远访问不到，既内存泄露 下图中，18行到20行为解决内存泄露问题的，那就是通过remove()将它消除了 / 弱引用遭到gc就会回收/import java.lang.ref.WeakReference;public class T03_WeakReference {public static void main(String[] args) {WeakReference<M> m = new WeakReference<>(new M());System.out.println(m.get());System.gc();System.out.println(m.get());ThreadLocal<M> tl = new ThreadLocal<>();tl.set(new M());tl.remove();} } 3、虚引用 虚引用 虚引用不是给开发人员用的，一般是给写JVM（java虚拟机，没有它java程序运行不了），Netty等技术大牛用的 虚引用，对象当被回收时，会将其放在队列中，此时我们监听到队列中有新值了，就知道有虚引用被回收了 此时我们要做相应的处理，虚引用指向的值，是无法直接get()获取的 虚引用使用场景 一般情况（其它情况暂时没什么用），虚引用指向堆外内存(直接被操作系统管理的内存)，JVM无法对其回收 当虚引用对象被回收时，JVM的垃圾回收无法自动回收堆外内存， 但是此时，虚引用对象被回收，会将其放在队列中 操作人员，看到队列中有对象被回收，就进行相应操作，回收堆内存 如何回收堆外内存 C和C++有函数可以用 java现在也提供了Unsafe类可以操作堆外内存，具体请参考上一篇博客，总之，JDK1.8只能通过反射来用，JDK1.9以上可以通过new Unsafe对象来用 Unsafe类的方法有： copyMemory():直接访问内存 allocateMemory():直接分配内存，这就必须手动回收内存了 freeMemory():回收内存 下面是一个虚引用例子，自己看吧，懂得自然懂，现在看不懂的，先收藏或者保存上，以后回来看 / 一个对象是否有虚引用的存在，完全不会对其生存时间构成影响， 也无法通过虚引用来获取一个对象的实例。 为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。 虚引用和弱引用对关联对象的回收都不会产生影响，如果只有虚引用活着弱引用关联着对象， 那么这个对象就会被回收。它们的不同之处在于弱引用的get方法，虚引用的get方法始终返回null, 弱引用可以使用ReferenceQueue,虚引用必须配合ReferenceQueue使用。 jdk中直接内存的回收就用到虚引用，由于jvm自动内存管理的范围是堆内存， 而直接内存是在堆内存之外（其实是内存映射文件，自行去理解虚拟内存空间的相关概念）， 所以直接内存的分配和回收都是有Unsafe类去操作，java在申请一块直接内存之后， 会在堆内存分配一个对象保存这个堆外内存的引用， 这个对象被垃圾收集器管理，一旦这个对象被回收， 相应的用户线程会收到通知并对直接内存进行清理工作。 事实上，虚引用有一个很重要的用途就是用来做堆外内存的释放， DirectByteBuffer就是通过虚引用来实现堆外内存的释放的。/import java.lang.ref.PhantomReference;import java.lang.ref.Reference;import java.lang.ref.ReferenceQueue;import java.util.LinkedList;import java.util.List;public class T04_PhantomReference {private static final List<Object> LIST = new LinkedList<>();private static final ReferenceQueue<M> QUEUE = new ReferenceQueue<>();public static void main(String[] args) {PhantomReference<M> phantomReference = new PhantomReference<>(new M(), QUEUE);new Thread(() -> {while (true) {LIST.add(new byte[1024 1024]);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();Thread.currentThread().interrupt();}System.out.println(phantomReference.get());} }).start();new Thread(() -> {while (true) {Reference<? extends M> poll = QUEUE.poll();if (poll != null) {System.out.println("--- 虚引用对象被jvm回收了 ---- " + poll);} }}).start();try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();} }} 2、容器 1、发展历史(一定要了解) map容器你需要了解的历史 JDK早期，java提供了Vector和Hashtable两个容器，这两个容器，很多操作都加了锁Synchronized，对于某些不需要用锁的情况下，就显得十分影响性能，所以现在基本没人用这两个容器，但是面试经常问这两个容器里面的数据结构等内容 后来，出现了HashMap，此容器完全不加锁，是用的最多的容器 但是完全不加锁未免不完善，所以java提供了如下方式，将HashMap变为加锁的 //通过Collections.synchronizedMap(HashMap)方法，将其变为加锁Map集合，其中泛型随意，UUID只是举例。static Map<UUID, UUID> m = Collections.synchronizedMap(new HashMap<UUID, UUID>()); 通过阅读源码发现，上面方法将HashMap变为加锁，也是使用Synchronized，只是锁的内容更细，但并不比HashTable效率高多少 所以衍生除了新的容器ConcurrentHashMap ConcurrentHashMap 此容器，插入效率不如上面的，因为它做了各种判断和CAS，但是差距不是特别大 读取效率很高，100个线程同时访问，每个线程读取一百万次实测 Hashtable 39s ，SynchronizedHashMap 38s ，ConcurrentHashMap 1.7s 前两个将近40秒，ConcurrentHashMap只需要不到2s，由此可见此容器读取效率极高 2、为什么推荐使用Queue来做高并发 为什么推荐Queue（队列） Queue接口提供了很多针对多线程非常友好的API（offer ，peek和poll，其中BlockingQueue还添加了put和take可以阻塞），可以说专门为多线程高并发而创造的接口，所以一般我们使用Queue而不用List 以下代码分别使用链表LinkList和ConcurrentQueue，对比一下速度 LinkList用了5s多，ConcurrentQueue几乎瞬间完成 Concurrent接口就是专为多线程设计，多线程设计要多考虑Queue(高并发用)的使用，少使用List / 有N张火车票，每张票都有一个编号 同时有10个窗口对外售票 请写一个模拟程序 分析下面的程序可能会产生哪些问题？ 重复销售？超量销售？ 使用Vector或者Collections.synchronizedXXX 分析一下，这样能解决问题吗？ 就算操作A和B都是同步的，但A和B组成的复合操作也未必是同步的，仍然需要自己进行同步 就像这个程序，判断size和进行remove必须是一整个的原子操作 @author 马士兵/import java.util.LinkedList;import java.util.List;import java.util.concurrent.TimeUnit;public class TicketSeller3 {static List<String> tickets = new LinkedList<>();static {for(int i=0; i<1000; i++) tickets.add("票 编号：" + i);}public static void main(String[] args) {for(int i=0; i<10; i++) {new Thread(()->{while(true) {synchronized(tickets) {if(tickets.size() <= 0) break;try {TimeUnit.MILLISECONDS.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("销售了--" + tickets.remove(0));} }}).start();} }} 队列 import java.util.Queue;import java.util.concurrent.ConcurrentLinkedQueue;public class TicketSeller4 {static Queue<String> tickets = new ConcurrentLinkedQueue<>();static {for(int i=0; i<1000; i++) tickets.add("票 编号：" + i);}public static void main(String[] args) {for(int i=0; i<10; i++) {new Thread(()->{while(true) {String s = tickets.poll();if(s == null) break;else System.out.println("销售了--" + s);} }).start();} }} 3、多线程常用容器 1、ConcurrentHashMap(无序)和ConcurrentSkipListMap(有序，链表，使用跳表数据结构，让查询更快) 跳表：http://blog.csdn.net/sunxianghuang/article/details/52221913 import java.util.;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.ConcurrentSkipListMap;import java.util.concurrent.CountDownLatch;public class T01_ConcurrentMap {public static void main(String[] args) {Map<String, String> map = new ConcurrentHashMap<>();//Map<String, String> map = new ConcurrentSkipListMap<>(); //高并发并且排序//Map<String, String> map = new Hashtable<>();//Map<String, String> map = new HashMap<>(); //Collections.synchronizedXXX//TreeMapRandom r = new Random();Thread[] ths = new Thread[100];CountDownLatch latch = new CountDownLatch(ths.length);long start = System.currentTimeMillis();for(int i=0; i<ths.length; i++) {ths[i] = new Thread(()->{for(int j=0; j<10000; j++) map.put("a" + r.nextInt(100000), "a" + r.nextInt(100000));latch.countDown();});}Arrays.asList(ths).forEach(t->t.start());try {latch.await();} catch (InterruptedException e) {e.printStackTrace();}long end = System.currentTimeMillis();System.out.println(end - start);System.out.println(map.size());} } 2、CopyOnWriteList（写时复制）和CopyOnWriteSet 适用于，高并发是，读的多，写的少的情况 当我们写的时候，将容器复制，让写线程去复制的线程写（写的时候加锁） 而读线程依旧去读旧的(读的时候不加锁) 当写完，将对象指向复制后的已经写完的容器，原来容器销毁 大大提高读的效率 / 写时复制容器 copy on write 多线程环境下，写时效率低，读时效率高 适合写少读多的环境 @author 马士兵/import java.util.ArrayList;import java.util.Arrays;import java.util.List;import java.util.Random;import java.util.Vector;import java.util.concurrent.CopyOnWriteArrayList;public class T02_CopyOnWriteList {public static void main(String[] args) {List<String> lists = //new ArrayList<>(); //这个会出并发问题！//new Vector();new CopyOnWriteArrayList<>();Random r = new Random();Thread[] ths = new Thread[100];for(int i=0; i<ths.length; i++) {Runnable task = new Runnable() {@Overridepublic void run() {for(int i=0; i<1000; i++) lists.add("a" + r.nextInt(10000));} };ths[i] = new Thread(task);}runAndComputeTime(ths);System.out.println(lists.size());}static void runAndComputeTime(Thread[] ths) {long s1 = System.currentTimeMillis();Arrays.asList(ths).forEach(t->t.start());Arrays.asList(ths).forEach(t->{try {t.join();} catch (InterruptedException e) {e.printStackTrace();} });long s2 = System.currentTimeMillis();System.out.println(s2 - s1);} } 3、synchronizedList和ConcurrentLinkedQueue package com.mashibing.juc.c_025;import java.util.ArrayList;import java.util.Collections;import java.util.List;import java.util.Queue;import java.util.concurrent.ConcurrentLinkedQueue;public class T04_ConcurrentQueue {public static void main(String[] args) {List<String> strsList = new ArrayList<>();List<String> strsSync = Collections.synchronizedList(strsList);//加锁ListQueue<String> strs = new ConcurrentLinkedQueue<>();//Concurrent链表队列，就是读快for(int i=0; i<10; i++) {strs.offer("a" + i); //add添加，但是不同点是，此方法会返回一个布尔值}System.out.println(strs);System.out.println(strs.size());System.out.println(strs.poll());//取出，取完后将元素去除System.out.println(strs.size());System.out.println(strs.peek());//取出，但是不会将元素从队列删除System.out.println(strs.size());//双端队列Deque} } 4、LinkedBlockingQueue 链表阻塞队列（无界链表，可以一直装东西，直到内存满（其实，也不是无限，其长度Integer.MaxValue就是上限，毕竟最大就这么大）） 主要体现在put和take方法，put添加的时候，如果队列满了，就阻塞当前线程，直到队列有空位，继续插入。take方法取的时候，如果没有值，就阻塞，等有值了，立马去取 import java.util.Random;import java.util.concurrent.BlockingQueue;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.TimeUnit;public class T05_LinkedBlockingQueue {static BlockingQueue<String> strs = new LinkedBlockingQueue<>();static Random r = new Random();public static void main(String[] args) {new Thread(() -> {for (int i = 0; i < 100; i++) {try {strs.put("a" + i); //如果满了，当前线程就会等待（实现阻塞），等多会有空位，将值插入TimeUnit.MILLISECONDS.sleep(r.nextInt(1000));} catch (InterruptedException e) {e.printStackTrace();} }}, "p1").start();for (int i = 0; i < 5; i++) {new Thread(() -> {for (;;) {try {System.out.println(Thread.currentThread().getName() + " take -" + strs.take()); //取内容，如果空了，当前线程就会等待（实现阻塞）} catch (InterruptedException e) {e.printStackTrace();} }}, "c" + i).start();} }} 5、ArrayBlockingQueue 有界阻塞队列（因为Array需要指定长度） import java.util.Random;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.BlockingQueue;import java.util.concurrent.TimeUnit;public class T06_ArrayBlockingQueue {static BlockingQueue<String> strs = new ArrayBlockingQueue<>(10);static Random r = new Random();public static void main(String[] args) throws InterruptedException {for (int i = 0; i < 10; i++) {strs.put("a" + i);}//strs.put("aaa"); //满了就会等待，程序阻塞//strs.add("aaa");//strs.offer("aaa");strs.offer("aaa", 1, TimeUnit.SECONDS);System.out.println(strs);} } 6、特殊的阻塞队列1：DelayQueue 延时队列（按时间进行调度，就是隔多长时间运行，谁隔的少，谁先） 以下例子中，我们添加线程到队列顺序为t12345，正常情况下，会按照顺序运行，但是这里有了延时时间，也就是时间越短，越先执行 步骤很简单，拿到延时队列 指定构造方法 继承 implements Delayed 重写 compareTo和getDelay import java.util.Calendar;import java.util.Random;import java.util.concurrent.BlockingQueue;import java.util.concurrent.DelayQueue;import java.util.concurrent.Delayed;import java.util.concurrent.TimeUnit;public class T07_DelayQueue {static BlockingQueue<MyTask> tasks = new DelayQueue<>();static Random r = new Random();static class MyTask implements Delayed {String name;long runningTime;MyTask(String name, long rt) {this.name = name;this.runningTime = rt;}@Overridepublic int compareTo(Delayed o) {if(this.getDelay(TimeUnit.MILLISECONDS) < o.getDelay(TimeUnit.MILLISECONDS))return -1;else if(this.getDelay(TimeUnit.MILLISECONDS) > o.getDelay(TimeUnit.MILLISECONDS)) return 1;else return 0;}@Overridepublic long getDelay(TimeUnit unit) {return unit.convert(runningTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);}@Overridepublic String toString() {return name + " " + runningTime;} }public static void main(String[] args) throws InterruptedException {long now = System.currentTimeMillis();MyTask t1 = new MyTask("t1", now + 1000);MyTask t2 = new MyTask("t2", now + 2000);MyTask t3 = new MyTask("t3", now + 1500);MyTask t4 = new MyTask("t4", now + 2500);MyTask t5 = new MyTask("t5", now + 500);tasks.put(t1);tasks.put(t2);tasks.put(t3);tasks.put(t4);tasks.put(t5);System.out.println(tasks);for(int i=0; i<5; i++) {System.out.println(tasks.take());//获取的是toString方法返回值} }} 7、特殊的阻塞队列2：PriorityQueque 优先队列（二叉树算法，就是排序） import java.util.PriorityQueue;public class T07_01_PriorityQueque {public static void main(String[] args) {PriorityQueue<String> q = new PriorityQueue<>();q.add("c");q.add("e");q.add("a");q.add("d");q.add("z");for (int i = 0; i < 5; i++) {System.out.println(q.poll());} }} 8、特殊的阻塞队列3：SynchronusQueue 同步队列(线程池用处非常大) 此队列容量为0，当插入元素时，必须同时有个线程往外取 就是说，当你往这个队列里面插入一个元素，它就拿着这个元素站着(阻塞)，直到有个取元素的线程来，它就把元素交给它 就是用来同步数据的，也就是线程间交互数据用的一个特殊队列 package com.mashibing.juc.c_025;import java.util.concurrent.BlockingQueue;import java.util.concurrent.SynchronousQueue;public class T08_SynchronusQueue { //容量为0public static void main(String[] args) throws InterruptedException {BlockingQueue<String> strs = new SynchronousQueue<>();new Thread(()->{//这个线程就是消费者，来取值try {System.out.println(strs.take());//和同步队列要值} catch (InterruptedException e) {e.printStackTrace();} }).start();strs.put("aaa"); //阻塞等待消费者消费，就拿着aaa站着，等线程来取//strs.put("bbb");//strs.add("aaa");System.out.println(strs.size());} } 9、特殊的阻塞队列4：TransferQueue 传递队列 此队列加入了一个方法transfer()用来向队列添加元素 但是和put()方法不同的是，put添加完元素就走了 而这个方法，添加完自己就阻塞了，直到有人将这个元素取走，它才继续工作(省去我们手动阻塞) import java.util.concurrent.LinkedTransferQueue;public class T09_TransferQueue {public static void main(String[] args) throws InterruptedException {LinkedTransferQueue<String> strs = new LinkedTransferQueue<>();new Thread(() -> {try {System.out.println(strs.take());} catch (InterruptedException e) {e.printStackTrace();} }).start();strs.transfer("aaa");//放东西到队列，同时阻塞等待消费者线程，取走元素//strs.put("aaa");//如果用put就和普通队列一样，放完东西就走了/new Thread(() -> {try {System.out.println(strs.take());} catch (InterruptedException e) {e.printStackTrace();} }).start();/} } 3、线程池 线程池 由于单独创建线程，十分影响效率，而且无法对线程集中管理，一旦疏落，可能线程无限执行，浪费资源 线程池就是一个存储线程的游泳池，而每个线程就是池子里面的赛道 池子里的线程不执行任何任务，只是提供一个资源 而谁提交了任务，比如我想来游泳，那么池子就给你一个赛道，让你游泳 比如它想练憋气，那么给它一个赛道练憋气 当他们用完，走了，那么后面其它人再过来继续用 这就是线程池，始终只有这几个线程，不做实现，而是借用这几个线程的用户，自己掌控用这些线程资源做什么（提交任务给线程,线程空闲就帮他们完成任务） 线程池的两种类型（两类，不是两个） ThreadPoolExecutor（简称TPE） ForkJoinPool（分解汇总任务(将任务细化，最后汇总结果)，少量线程执行多个任务（子任务，TPE做不到先执行子任务），CPU密集型） Executors（注意这后面有s） 它可以说是线程池工厂类，我们一般通过它创建线程池，并且它为我们封装了线程 1、常用类 Executor ExecutorService 扩展了execute方法，具有一个返回值 规定了异步执行机制，提供了一些执行器方法，比如shutdown()关闭等 但是它不知道执行器中的线程何时执行完 Callable 对Runnable进行了扩展,实现Callable的调用，可以有返回值，表示线程的状态 但是无法返回线程执行结果 Future 获得未来线程执行结果 由此，我们可以得知线程池基本的一个使用步骤 其中service.submit（）:为异步提交，也就是说，主线程该干嘛干嘛，我是异步执行的，和同步不一样（当前线程执行完，主线程才能继续执行，叫同步） futuer.get():获取结果集结果，此时因为异步，主线程执行到这里，结果集可能还没封装好，所以此时如果没有值，就阻塞，直到结果集出来 public static void main(String[] args) throws ExecutionException, InterruptedException {Callable<String> c = new Callable() {@Overridepublic String call() throws Exception {return "Hello Callable";} };ExecutorService service = Executors.newCachedThreadPool();Future<String> future = service.submit(c); //异步System.out.println(future.get());//阻塞service.shutdown();} 2、FutureTask 可充当任务的结果集 上面我们介绍Future是用来得到任务的执行结果的 而FutureTask，可以当做一个任务用，并且返回任务的结果，也就是可以跑线程，然后还可以得到线程结果 public static void main(String[] args) throws InterruptedException, ExecutionException {FutureTask<Integer> task = new FutureTask<>(()->{TimeUnit.MILLISECONDS.sleep(500);return 1000;}); //new Callable () { Integer call();}new Thread(task).start();System.out.println(task.get()); //阻塞} 3、CompletableFuture 非常灵活的任务结果集 一个非常灵活的结果集 他可以将很多执行不同任务的线程的结果进行汇总 比如一个网站，它可以启动多个线程去各大电商网站，比如淘宝，京东，收集某些或某一个商品的价格 最后，将获取的数据进行整合封装 最终，客户就可以通过此网站，获取某类商品在各网站的价格信息 / 假设你能够提供一个服务 这个服务查询各大电商网站同一类产品的价格并汇总展示 @author 马士兵 http://mashibing.com/import java.io.IOException;import java.util.Random;import java.util.concurrent.CompletableFuture;import java.util.concurrent.ExecutionException;import java.util.concurrent.TimeUnit;public class T06_01_CompletableFuture {public static void main(String[] args) throws ExecutionException, InterruptedException {long start, end;/start = System.currentTimeMillis();priceOfTM();priceOfTB();priceOfJD();end = System.currentTimeMillis();System.out.println("use serial method call! " + (end - start));/start = System.currentTimeMillis();CompletableFuture<Double> futureTM = CompletableFuture.supplyAsync(()->priceOfTM());CompletableFuture<Double> futureTB = CompletableFuture.supplyAsync(()->priceOfTB());CompletableFuture<Double> futureJD = CompletableFuture.supplyAsync(()->priceOfJD());CompletableFuture.allOf(futureTM, futureTB, futureJD).join();//当所有结果集都获取到，才汇总阻塞CompletableFuture.supplyAsync(()->priceOfTM()).thenApply(String::valueOf).thenApply(str-> "price " + str).thenAccept(System.out::println);end = System.currentTimeMillis();System.out.println("use completable future! " + (end - start));try {System.in.read();} catch (IOException e) {e.printStackTrace();} }private static double priceOfTM() {delay();return 1.00;}private static double priceOfTB() {delay();return 2.00;}private static double priceOfJD() {delay();return 3.00;}/private static double priceOfAmazon() {delay();throw new RuntimeException("product not exist!");}/private static void delay() {int time = new Random().nextInt(500);try {TimeUnit.MILLISECONDS.sleep(time);} catch (InterruptedException e) {e.printStackTrace();}System.out.printf("After %s sleep!\n", time);} } 4、TPE型线程池1：ThreadPoolExecutor 原理及其参数 线程池由两个集合组成，一个集合存储线程，一个集合存储任务 存储线程：可以规定大小，最多可以有多少个，以及指定核心线程数量（不会被回收） 任务队列：存储任务 细节：初始线程池没有线程，当有一个任务来，线程池起一个线程，又有一个任务来，再起一个线程，直到达到核心线程数量 核心线程数量达到时，新来的任务将存储到任务队列中等待核心线程处理完成，直到任务队列也满了 当任务队列满了，此时再次启动一个线程（非核心线程，一旦空闲，达到指定时间将会消失），直到达到线程最大数量 当线程容器和任务容器都满了，又来了线程，将会执行拒绝策略 上面的细节涉及的所有步骤内容，均由创建线程池的参数执行 下面是ThreadPoolExecutor构造方法参数的源码注释 / 用给定的初始值，创建一个新的线程池 @param corePoolSize 核心线程数量 @param maximumPoolSize 最大线程数量 @param keepAliveTime 当线程数大于核心线程数量时，空闲的线程可生存的时间 @param unit 时间单位 @param workQueue 任务队列，只能包含由execute提交的Runnable任务 @param threadFactory 工厂，用于创建线程给线程池调度的工厂，可以自定义 @param handler 拒绝策略(可以自定义，JDK默认提供4种)，当线程边界和队列容量已经满了，新来线程被阻塞时使用的处理程序/public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler) JDK提供的4种拒绝策略，不常用，一般都是自己定义拒绝策略 Abort：抛异常 Discard：扔掉，不抛异常 DiscardOldest：扔掉排队时间最久的（将队列中排队时间最久的扔掉，然后让新来的进来） CallerRuns：调用者处理任务（谁通过execute方法提交任务，谁处理） ThreadPoolExecutor继承关系 继承关系：ThreadPoolExecutor->AbstractExectorService类->ExectorService接口->Exector接口 Executors（注意这后面有s） 它可以说是线程池工厂类，我们一般通过它创建线程池，并且它为我们封装了线程 看看下面创建线程池，哪里用到了它 使用实例 import java.io.IOException;import java.util.concurrent.;public class T05_00_HelloThreadPool {static class Task implements Runnable {private int i;public Task(int i) {this.i = i;}@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + " Task " + i);try {System.in.read();} catch (IOException e) {e.printStackTrace();} }@Overridepublic String toString() {return "Task{" +"i=" + i +'}';} }public static void main(String[] args) {ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 4,60, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(4),Executors.defaultThreadFactory(),new ThreadPoolExecutor.CallerRunsPolicy());//创建线程池，核心2个，最大4个，空闲线程存活时间60s，任务队列容量4，使用默认线程工程，创建线程。拒绝策略是JDK提供的for (int i = 0; i < 8; i++) {tpe.execute(new Task(i));//供提交8次任务}System.out.println(tpe.getQueue());//查看任务队列tpe.execute(new Task(100));//提交新的任务System.out.println(tpe.getQueue());tpe.shutdown();//关闭线程池} } 5、TPE型线程池2：SingleThreadPool 单例线程池(只有一个线程) 为什么有单例线程池 有任务队列，有线程池管理机制 Executors（注意这后面有s） 它可以说是线程池工厂类，我们一般通过它创建线程池，并且它为我们封装了线程 看看下面哪里用到了它 /创建单例线程池，扔5个任务进去，查看输出结果，看看有几个线程执行任务/import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class T07_SingleThreadPool {public static void main(String[] args) {ExecutorService service = Executors.newSingleThreadExecutor();for(int i=0; i<5; i++) {final int j = i;service.execute(()->{System.out.println(j + " " + Thread.currentThread().getName());});} }} 6、TPE型线程池3：CachedPool 缓存，存储线程池 此线程池没有核心线程，来一个任务启动一个线程（最多Integer.MaxValue，不会放在任务队列，因为任务队列容量为0），每个线程空闲后，只能活60s 实例 import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class T07_SingleThreadPool {public static void main(String[] args) {ExecutorService service = Executors.newSingleThreadExecutor();//通过Executors获取池子for(int i=0; i<5; i++) {final int j = i;service.execute(()->{//提交任务System.out.println(j + " " + Thread.currentThread().getName());});}service.shutdown();} } 7、TPE型线程池4：FixedThreadPool 固定线程池 此线次池，用于创建一个固定线程数量的线程池，不会回收 实例 import java.util.ArrayList;import java.util.List;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;public class T09_FixedThreadPool {public static void main(String[] args) throws InterruptedException, ExecutionException {//并发执行long start = System.currentTimeMillis();getPrime(1, 200000); long end = System.currentTimeMillis();System.out.println(end - start);//输出并发执行耗费时间final int cpuCoreNum = 4;//并行执行ExecutorService service = Executors.newFixedThreadPool(cpuCoreNum);MyTask t1 = new MyTask(1, 80000); //1-5 5-10 10-15 15-20MyTask t2 = new MyTask(80001, 130000);MyTask t3 = new MyTask(130001, 170000);MyTask t4 = new MyTask(170001, 200000);Future<List<Integer>> f1 = service.submit(t1);Future<List<Integer>> f2 = service.submit(t2);Future<List<Integer>> f3 = service.submit(t3);Future<List<Integer>> f4 = service.submit(t4);start = System.currentTimeMillis();f1.get();f2.get();f3.get();f4.get();end = System.currentTimeMillis();System.out.println(end - start);//输出并行耗费时间}static class MyTask implements Callable<List<Integer>> {int startPos, endPos;MyTask(int s, int e) {this.startPos = s;this.endPos = e;}@Overridepublic List<Integer> call() throws Exception {List<Integer> r = getPrime(startPos, endPos);return r;} }static boolean isPrime(int num) {for(int i=2; i<=num/2; i++) {if(num % i == 0) return false;}return true;}static List<Integer> getPrime(int start, int end) {List<Integer> results = new ArrayList<>();for(int i=start; i<=end; i++) {if(isPrime(i)) results.add(i);}return results;} } 8、TPE型线程池5：ScheduledPool 预定，延时线程池 根据延时时间（隔多长时间后运行），排序，哪个线程先执行,用户只需要指定核心线程数量 此线程池返回的池对象，和提交任务方法都不一样，比较涉及到时间 import java.util.Random;import java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.TimeUnit;public class T10_ScheduledPool {public static void main(String[] args) {ScheduledExecutorService service = Executors.newScheduledThreadPool(4);service.scheduleAtFixedRate(()->{//提交延时任务try {TimeUnit.MILLISECONDS.sleep(new Random().nextInt(1000));} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName());}, 0, 500, TimeUnit.MILLISECONDS);//指定延时时间和单位，第一个任务延时0毫秒，之后的任务，延时500毫秒} } 9、手写拒绝策略小例子 import java.util.concurrent.;public class T14_MyRejectedHandler {public static void main(String[] args) {ExecutorService service = new ThreadPoolExecutor(4, 4,0, TimeUnit.SECONDS, new ArrayBlockingQueue<>(6),Executors.defaultThreadFactory(),new MyHandler());//将手写拒绝策略传入}static class MyHandler implements RejectedExecutionHandler {//1、继承RejectedExecutionHandler@Overridepublic void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {//2、重写方法//log("r rejected")//伪代码，表示通过log4j.log()报一下日志，拒绝的时间，线程名//save r kafka mysql redis//可以尝试保存队列//try 3 times //可以尝试几次，比如3次，重新去抢队列，3次还不行就丢弃if(executor.getQueue().size() < 10000) {//尝试条件，如果size>10000了,就执行拒绝策略//try put again();//如果小于10000，尝试将其放到队列中} }} } 10、ForkJoinPool线程池1：ForkJoinPool 前面我们讲过线程分为两大类，TPE和FJP ForkJoinPool（分解汇总任务(将任务细化，最后汇总结果)，少量线程执行多个任务（子任务，TPE做不到先执行子任务），CPU密集型） 适合将大任务切分成多个小任务运行 两个方法，fork()：分子任务，将子任务分配到线程池中 join()：当前任务的计算结果，如果有子任务，等子任务结果返回后再汇总 下面实例实现，一百万个随机数求和，由两种方法实现，一种ForkJoinPool分任务并行，一种使用单线程做 import java.io.IOException;import java.util.Arrays;import java.util.Random;import java.util.concurrent.ForkJoinPool;import java.util.concurrent.RecursiveAction;import java.util.concurrent.RecursiveTask;public class T12_ForkJoinPool {//1000000个随机数求和static int[] nums = new int[1000000];//一堆数static final int MAX_NUM = 50000;//分任务时，每个任务的操作量不能多于50000个，否则就继续细分static Random r = new Random();//使用随机数将数组初始化static {for(int i=0; i<nums.length; i++) {nums[i] = r.nextInt(100);}System.out.println("---" + Arrays.stream(nums).sum()); //stream api 单线程就这么做，一个一个加}//分任务，需要继承，可以继承RecursiveAction(不需要返回值，一般用在不需要返回值的场景)或//RecursiveTask(需要返回值，我们用这个，因为我们需要最后获取求和结果)两个更好实现的类，//他俩继承与ForkJoinTaskstatic class AddTaskRet extends RecursiveTask<Long> {private static final long serialVersionUID = 1L;int start, end;AddTaskRet(int s, int e) {start = s;end = e;}@Overrideprotected Long compute() {if(end-start <= MAX_NUM) {//如果任务操作数小于规定的最大操作数，就进行运算，long sum = 0L;for(int i=start; i<end; i++) sum += nums[i];return sum;//返回结果} //如果分配的操作数大于规定，就继续细分（简单的重中点分，两半）int middle = start + (end-start)/2;//获取中间值AddTaskRet subTask1 = new AddTaskRet(start, middle);//传入起始值和中间值，表示一个子任务AddTaskRet subTask2 = new AddTaskRet(middle, end);//中间值和结尾值，表示一个子任务subTask1.fork();//分任务subTask2.fork();//分任务return subTask1.join() + subTask2.join();//最后返回结果汇总} }public static void main(String[] args) throws IOException {/ForkJoinPool fjp = new ForkJoinPool();AddTask task = new AddTask(0, nums.length);fjp.execute(task);/ForkJoinPool fjp = new ForkJoinPool();//创建线程池AddTaskRet task = new AddTaskRet(0, nums.length);//创建任务fjp.execute(task);//传入任务long result = task.join();//返回汇总结果System.out.println(result);//System.in.read();} } 11、ForkJoinPool线程池2：WorkStealingPool 任务偷取线程池 原来的线程池，都是有一个任务队列，而这个不同，它给每个线程都分配了一个任务队列 当某一个线程的任务队列没有任务，并且自己空闲，它就去其它线程的任务队列中偷任务，所以叫任务偷取线程池 细节：当线程自己从自己的任务队列拿任务时，不需要加锁，但是偷任务时，因为有两个线程，可能发生同步问题，需要加锁 此线程继承FJP 实例 import java.io.IOException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.TimeUnit;public class T11_WorkStealingPool {public static void main(String[] args) throws IOException {ExecutorService service = Executors.newWorkStealingPool();System.out.println(Runtime.getRuntime().availableProcessors());service.execute(new R(1000));service.execute(new R(2000));service.execute(new R(2000));service.execute(new R(2000)); //daemonservice.execute(new R(2000));//由于产生的是精灵线程（守护线程、后台线程），主线程不阻塞的话，看不到输出System.in.read(); }static class R implements Runnable {int time;R(int t) {this.time = t;}@Overridepublic void run() {try {TimeUnit.MILLISECONDS.sleep(time);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(time + " " + Thread.currentThread().getName());} }} 12、流式API：ParallelStreamAPI 不懂的请参考：https://blog.csdn.net/grd_java/article/details/110265219 实例 import java.util.ArrayList;import java.util.List;import java.util.Random;public class T13_ParallelStreamAPI {public static void main(String[] args) {List<Integer> nums = new ArrayList<>();Random r = new Random();for(int i=0; i<10000; i++) nums.add(1000000 + r.nextInt(1000000));//System.out.println(nums);long start = System.currentTimeMillis();nums.forEach(v->isPrime(v));long end = System.currentTimeMillis();System.out.println(end - start);//使用parallel stream apistart = System.currentTimeMillis();nums.parallelStream().forEach(T13_ParallelStreamAPI::isPrime);//并行流，将任务切分成子任务执行end = System.currentTimeMillis();System.out.println(end - start);}static boolean isPrime(int num) {for(int i=2; i<=num/2; i++) {if(num % i == 0) return false;}return true;} } 13、总结 总结 Callable相当于一Runnable但是它有返回值 Future：存储执行完产生的结果 FutureTask 相当于Future+Runnable，既可以执行任务，又能获取任务执行的Future结果 CompletableFuture 可以多任务异步，并对多任务控制，整合任务结果，细化完美，比如可以一个任务完成就可以整合结果，也可以所有任务完成才整合结果 4、ThreadPoolExecutor源码解析 依然只讲重点，实际还需要大家按照上篇博客中看源码的方式来看 1、常用变量的解释 // 1. ctl，可以看做一个int类型的数字，高3位表示线程池状态，低29位表示worker数量private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));// 2. COUNT_BITS，Integer.SIZE为32，所以COUNT_BITS为29private static final int COUNT_BITS = Integer.SIZE - 3;// 3. CAPACITY，线程池允许的最大线程数。1左移29位，然后减1，即为 2^29 - 1private static final int CAPACITY = (1 << COUNT_BITS) - 1;// runState is stored in the high-order bits// 4. 线程池有5种状态，按大小排序如下：RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATEDprivate static final int RUNNING = -1 << COUNT_BITS;private static final int SHUTDOWN = 0 << COUNT_BITS;private static final int STOP = 1 << COUNT_BITS;private static final int TIDYING = 2 << COUNT_BITS;private static final int TERMINATED = 3 << COUNT_BITS;// Packing and unpacking ctl// 5. runStateOf()，获取线程池状态，通过按位与操作，低29位将全部变成0private static int runStateOf(int c) { return c & ~CAPACITY; }// 6. workerCountOf()，获取线程池worker数量，通过按位与操作，高3位将全部变成0private static int workerCountOf(int c) { return c & CAPACITY; }// 7. ctlOf()，根据线程池状态和线程池worker数量，生成ctl值private static int ctlOf(int rs, int wc) { return rs | wc; }/ Bit field accessors that don't require unpacking ctl. These depend on the bit layout and on workerCount being never negative./// 8. runStateLessThan()，线程池状态小于xxprivate static boolean runStateLessThan(int c, int s) {return c < s;}// 9. runStateAtLeast()，线程池状态大于等于xxprivate static boolean runStateAtLeast(int c, int s) {return c >= s;} 2、构造方法 public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler) {// 基本类型参数校验if (corePoolSize < 0 ||maximumPoolSize <= 0 ||maximumPoolSize < corePoolSize ||keepAliveTime < 0)throw new IllegalArgumentException();// 空指针校验if (workQueue == null || threadFactory == null || handler == null)throw new NullPointerException();this.corePoolSize = corePoolSize;this.maximumPoolSize = maximumPoolSize;this.workQueue = workQueue;// 根据传入参数unit和keepAliveTime，将存活时间转换为纳秒存到变量keepAliveTime 中this.keepAliveTime = unit.toNanos(keepAliveTime);this.threadFactory = threadFactory;this.handler = handler;} 3、提交执行task的过程 public void execute(Runnable command) {if (command == null)throw new NullPointerException();/ Proceed in 3 steps: 1. If fewer than corePoolSize threads are running, try to start a new thread with the given command as its first task. The call to addWorker atomically checks runState and workerCount, and so prevents false alarms that would add threads when it shouldn't, by returning false. 2. If a task can be successfully queued, then we still need to double-check whether we should have added a thread (because existing ones died since last checking) or that the pool shut down since entry into this method. So we recheck state and if necessary roll back the enqueuing if stopped, or start a new thread if there are none. 3. If we cannot queue task, then we try to add a new thread. If it fails, we know we are shut down or saturated and so reject the task./int c = ctl.get();// worker数量比核心线程数小，直接创建worker执行任务if (workerCountOf(c) < corePoolSize) {if (addWorker(command, true))return;c = ctl.get();}// worker数量超过核心线程数，任务直接进入队列if (isRunning(c) && workQueue.offer(command)) {int recheck = ctl.get();// 线程池状态不是RUNNING状态，说明执行过shutdown命令，需要对新加入的任务执行reject()操作。// 这儿为什么需要recheck，是因为任务入队列前后，线程池的状态可能会发生变化。if (! isRunning(recheck) && remove(command))reject(command);// 这儿为什么需要判断0值，主要是在线程池构造方法中，核心线程数允许为0else if (workerCountOf(recheck) == 0)addWorker(null, false);}// 如果线程池不是运行状态，或者任务进入队列失败，则尝试创建worker执行任务。// 这儿有3点需要注意：// 1. 线程池不是运行状态时，addWorker内部会判断线程池状态// 2. addWorker第2个参数表示是否创建核心线程// 3. addWorker返回false，则说明任务执行失败，需要执行reject操作else if (!addWorker(command, false))reject(command);} 4、addworker源码解析 private boolean addWorker(Runnable firstTask, boolean core) {retry:// 外层自旋for (;;) {int c = ctl.get();int rs = runStateOf(c);// 这个条件写得比较难懂，我对其进行了调整，和下面的条件等价// (rs > SHUTDOWN) || // (rs == SHUTDOWN && firstTask != null) || // (rs == SHUTDOWN && workQueue.isEmpty())// 1. 线程池状态大于SHUTDOWN时，直接返回false// 2. 线程池状态等于SHUTDOWN，且firstTask不为null，直接返回false// 3. 线程池状态等于SHUTDOWN，且队列为空，直接返回false// Check if queue empty only if necessary.if (rs >= SHUTDOWN &&! (rs == SHUTDOWN &&firstTask == null &&! workQueue.isEmpty()))return false;// 内层自旋for (;;) {int wc = workerCountOf(c);// worker数量超过容量，直接返回falseif (wc >= CAPACITY ||wc >= (core ? corePoolSize : maximumPoolSize))return false;// 使用CAS的方式增加worker数量。// 若增加成功，则直接跳出外层循环进入到第二部分if (compareAndIncrementWorkerCount(c))break retry;c = ctl.get(); // Re-read ctl// 线程池状态发生变化，对外层循环进行自旋if (runStateOf(c) != rs)continue retry;// 其他情况，直接内层循环进行自旋即可// else CAS failed due to workerCount change; retry inner loop} }boolean workerStarted = false;boolean workerAdded = false;Worker w = null;try {w = new Worker(firstTask);final Thread t = w.thread;if (t != null) {final ReentrantLock mainLock = this.mainLock;// worker的添加必须是串行的，因此需要加锁mainLock.lock();try {// Recheck while holding lock.// Back out on ThreadFactory failure or if// shut down before lock acquired.// 这儿需要重新检查线程池状态int rs = runStateOf(ctl.get());if (rs < SHUTDOWN ||(rs == SHUTDOWN && firstTask == null)) {// worker已经调用过了start()方法，则不再创建workerif (t.isAlive()) // precheck that t is startablethrow new IllegalThreadStateException();// worker创建并添加到workers成功workers.add(w);// 更新largestPoolSize变量int s = workers.size();if (s > largestPoolSize)largestPoolSize = s;workerAdded = true;} } finally {mainLock.unlock();}// 启动worker线程if (workerAdded) {t.start();workerStarted = true;} }} finally {// worker线程启动失败，说明线程池状态发生了变化（关闭操作被执行），需要进行shutdown相关操作if (! workerStarted)addWorkerFailed(w);}return workerStarted;} 5、线程池worker任务单元 private final class Workerextends AbstractQueuedSynchronizerimplements Runnable{/ This class will never be serialized, but we provide a serialVersionUID to suppress a javac warning./private static final long serialVersionUID = 6138294804551838833L;/ Thread this worker is running in. Null if factory fails. /final Thread thread;/ Initial task to run. Possibly null. /Runnable firstTask;/ Per-thread task counter /volatile long completedTasks;/ Creates with given first task and thread from ThreadFactory. @param firstTask the first task (null if none)/Worker(Runnable firstTask) {setState(-1); // inhibit interrupts until runWorkerthis.firstTask = firstTask;// 这儿是Worker的关键所在，使用了线程工厂创建了一个线程。传入的参数为当前workerthis.thread = getThreadFactory().newThread(this);}/ Delegates main run loop to outer runWorker /public void run() {runWorker(this);}// 省略代码...} 6、核心线程执行逻辑-runworker final void runWorker(Worker w) {Thread wt = Thread.currentThread();Runnable task = w.firstTask;w.firstTask = null;// 调用unlock()是为了让外部可以中断w.unlock(); // allow interrupts// 这个变量用于判断是否进入过自旋（while循环）boolean completedAbruptly = true;try {// 这儿是自旋// 1. 如果firstTask不为null，则执行firstTask；// 2. 如果firstTask为null，则调用getTask()从队列获取任务。// 3. 阻塞队列的特性就是：当队列为空时，当前线程会被阻塞等待while (task != null || (task = getTask()) != null) {// 这儿对worker进行加锁，是为了达到下面的目的// 1. 降低锁范围，提升性能// 2. 保证每个worker执行的任务是串行的w.lock();// If pool is stopping, ensure thread is interrupted;// if not, ensure thread is not interrupted. This// requires a recheck in second case to deal with// shutdownNow race while clearing interrupt// 如果线程池正在停止，则对当前线程进行中断操作if ((runStateAtLeast(ctl.get(), STOP) ||(Thread.interrupted() &&runStateAtLeast(ctl.get(), STOP))) &&!wt.isInterrupted())wt.interrupt();// 执行任务，且在执行前后通过beforeExecute()和afterExecute()来扩展其功能。// 这两个方法在当前类里面为空实现。try {beforeExecute(wt, task);Throwable thrown = null;try {task.run();} catch (RuntimeException x) {thrown = x; throw x;} catch (Error x) {thrown = x; throw x;} catch (Throwable x) {thrown = x; throw new Error(x);} finally {afterExecute(task, thrown);} } finally {// 帮助gctask = null;// 已完成任务数加一 w.completedTasks++;w.unlock();} }completedAbruptly = false;} finally {// 自旋操作被退出，说明线程池正在结束processWorkerExit(w, completedAbruptly);} } 本篇文章为转载内容。原文链接：https://blog.csdn.net/grd_java/article/details/113116244。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...许开发者创建线程池，控制线程的数量、任务队列策略以及线程的生命周期管理，从而提高并发任务的执行效率和资源利用率。 Actor模型 , 一种并发编程范式，强调轻量级、无共享状态的实体（Actor），它们通过发送消息彼此交互。Java 17引入的JSR 4204改进版Actor模型，旨在简化并发编程，减少同步开销，提高系统可扩展性和容错性。在分布式环境中，Actor模型有助于构建无状态且易于理解和调试的服务。

...章语境中，MySQL作为最广泛使用的关系型数据库管理系统，具备高性能和可扩展性等优点。 分布式系统 , 分布式系统是由多台计算机通过网络连接并协同工作，共同完成一个或多个任务的计算系统。在MySQL的分布式实现中，多台计算机组成集群，每台计算机处理部分数据库负载，它们之间相互协作，实现数据共享和高可用性，以此提高整个系统的处理能力和并发性能。 MySQL Proxy , MySQL Proxy是一款轻量级的中间件软件，设计用于MySQL数据库的负载均衡、读写分离以及访问控制等功能。在MySQL分布式架构中，MySQL Proxy接收客户端的所有数据库请求，根据预设策略将这些请求分发到不同的MySQL服务器上，从而实现数据库访问流量的均衡分布，保证系统整体性能和高可用性。此外，MySQL Proxy还支持复制和故障转移功能，增强了MySQL分布式环境下的稳定性和可靠性。

...nx是一款高性能、高并发的Web服务器和反向代理服务器软件，尤其擅长处理静态内容和作为HTTP负载均衡器。在本文中，Nginx被用作Web服务器，并通过配置解决浏览器跨域问题，同时利用其反向代理功能将请求转发到本地8080端口的服务器。 CORS（跨域资源共享） , CORS是一个W3C标准，用于定义浏览器与服务器之间如何实现跨域数据访问的一种机制。当网页从不同源（即协议、域名、端口任一不同）发起AJAX请求时，浏览器会根据CORS策略检查目标服务器是否允许该跨域请求。在本文情境下，通过在Nginx服务器上配置CORS响应头信息（如Access-Control-Allow-Origin和Access-Control-Allow-Methods），允许来自不同域名的客户端（如浏览器）安全地访问服务器资源，从而解决浏览器跨域问题。

...d关键字可以实现对共享资源的互斥访问，从而达到线程安全的目的。 Future模式 , Future模式是Java并发编程中的一个设计模式，它提供了一种异步编程机制，允许主线程提交任务后继续执行其他操作，而非等待该任务完成。通过调用ExecutorService的submit()方法提交一个Callable任务，系统会返回一个Future对象，这个对象代表了该异步计算的结果。主线程可以在任何时候通过调用Future.get()方法来获取计算结果，如果结果尚未准备好，该方法将会阻塞直到结果可用。 Callback模式（回调函数） , Callback模式是一种设计模式，常用于异步编程场景中处理异步操作的结果。在这种模式下，一个对象（通常是客户端）注册一个方法给另一个对象（服务端），当服务端完成特定的操作或事件发生时，会调用预先注册的方法（即回调函数）通知客户端，并将相关结果作为参数传递。在Java中，可以通过接口实现回调逻辑，使得异步任务完成后能够以非阻塞的方式通知并处理结果。例如，在网络请求、I/O操作等场景中广泛应用回调模式进行异步处理。

...步探索和关注搜索引擎并发处理性能优化的最新技术和实践。 近期，随着大数据应用的不断深化，搜索引擎架构设计与性能优化的重要性日益凸显。Solr作为开源搜索服务器，其对高并发场景的支持能力一直是社区及企业用户关注的重点。最新的Solr 8.x版本引入了一系列性能改进措施，如分布式索引机制的升级、内存管理的优化以及更精细的并发控制策略等，这些都为有效防止和处理ConcurrentUpdateRequestHandlerNotAvailableCheckedException等问题提供了新的解决方案。 同时，针对大型互联网企业的应用场景，有研究者提出了结合云计算技术进行Solr集群扩展和负载均衡的策略，通过容器化部署和动态资源调度，实现并发更新请求的高效处理与故障隔离，从而避免因并发过高导致的各种异常情况。 此外，对于那些需要频繁进行大量数据更新的业务场景，业界也在积极探索采用异步队列、批处理更新等模式来提升系统的吞吐量和响应速度，减少由于并发写入冲突引发的问题。 综上所述，在实际运维和开发过程中，持续跟踪Apache Solr项目的最新进展，深入研究和借鉴相关领域的最佳实践，将有助于我们更好地应对包括ConcurrentUpdateRequestHandlerNotAvailableCheckedException在内的各种并发处理挑战，以确保搜索引擎服务在大数据环境下的稳定性和高性能。

...同时挤在一起干活的高并发情况下，Pig这小子的表现可能就不太给力了，运行效率可能会掉链子，这样一来，咱们的工作效率自然也就跟着受影响啦。本文将探讨并发执行时性能下降的原因，并提供一些解决方案。 二、并发执行中的性能问题 1. 并发冲突 在多线程环境中，Pig可能会遇到并发冲突的问题。比如说，就好比两个人同时看同一本书、或者同时修改同一篇文章一样，如果两个任务同步进行，都去访问一份数据的话，那很可能就会出现读取的内容乱七八糟，或者是更新的信息对不上号的情况。这种情况在并行执行多个任务时尤其常见。 2. 资源竞争 随着并发任务数量的增加，资源的竞争也越来越激烈。例如，内存资源、CPU资源等。如果不能有效地管理这些资源，可能会导致性能下降甚至系统崩溃。 三、原因分析 那么，是什么原因导致了Pig在并发执行时的性能下降呢？ 1. 数据冲突 由于Pig的调度机制，不同的任务可能会访问到相同的数据。这就可能导致数据冲突，从而降低整体的执行效率。 2. 线程安全问题 Pig中的很多操作都是基于Java进行的，而Java的线程安全问题是我们需要关注的一个重要点。如果Pig的代码中存在线程安全问题，就可能导致性能下降。 3. 资源管理问题 在高并发环境下，如果没有有效的资源管理策略，就可能导致资源竞争，进而影响性能。 四、解决方案 1. 数据分片 一种有效的解决方法是数据分片。把数据分成若干份，就像是把大蛋糕切成小块儿一样，这样一来，每个任务就不用全部啃完整个蛋糕了，而是各自处理一小块儿。这样做呢，能够有效地避免单个任务对整个数据集“寸步不离”的依赖状况，自然而然地也就减少了数据之间产生冲突的可能性，让它们能更和谐地共处和工作。 2. 线程安全优化 对于可能出现线程安全问题的部分，我们可以通过加锁、同步等方式来保证线程安全。例如，我们可以使用synchronized关键字来保护共享资源，或者使用ReentrantLock类来实现更复杂的锁策略。 3. 资源管理优化 我们还可以通过合理的资源分配策略来提高性能。比如，我们可以借助线程池这个小帮手来控制同时进行的任务数量，不让它们一拥而上；或者，我们也能灵活运用内存管理工具，像变魔术一样动态地调整内存使用状况，让系统更加流畅高效。 五、总结 总的来说，虽然Apache Pig在并发执行时可能会面临一些性能问题，但只要我们能够理解这些问题的原因，并采取相应的措施，就可以有效地解决问题，提高我们的工作效率。此外，我们还应该注意保持良好的编程习惯，避免常见的并发问题，如数据竞争、死锁等。

一、引言 作为一位开发者，你可能曾经遇到过这样的问题：当应用程序接收到大量的消息时，该如何处理？特别是当这些消息的量远远超过应用程序可以处理的极限时，我们又该怎样应对呢？ 这就是今天我们要讨论的主题：如何在突发大流量消息场景中使用RabbitMQ。 二、什么是RabbitMQ RabbitMQ是一个开源的消息队列系统，它基于AMQP协议（高级消息队列协议），支持多种语言的客户端，如Java、Python、Ruby等。RabbitMQ的主要功能是提供一个中间件，帮助我们在发送者和接收者之间传输消息。 三、如何处理突发大流量消息场景 1. 使用消息队列 首先，我们需要将应用程序中的所有请求都通过消息队列来处理。这样一来，即使咱们的应用程序暂时有点忙不过来，处理不完所有的请求，我们也有办法，就是先把那些请求放到一个队列里边排队等候，等应用程序腾出手来再慢慢处理它们。 例如，我们可以使用以下Python代码将一个消息放入RabbitMQ： python import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() channel.queue_declare(queue='hello') channel.basic_publish(exchange='', routing_key='hello', body='Hello World!') print(" [x] Sent 'Hello World!'") connection.close() 2. 设置最大并发处理数量 接下来，我们需要设置应用程序的最大并发处理数量。这可以帮助我们在处理大量请求时避免资源耗尽的问题。 例如，在Python中，我们可以使用concurrent.futures模块来限制同时运行的任务数量： python from concurrent.futures import ThreadPoolExecutor, as_completed with ThreadPoolExecutor(max_workers=5) as executor: futures = {executor.submit(my_function, arg): arg for arg in args} for future in as_completed(futures): print(future.result()) 3. 异步处理 最后，我们可以考虑使用异步处理的方式来提高应用程序的性能。这种方式就像是让我们的程序学会“一心多用”，在等待硬盘、网络这些耗时的I/O操作慢慢完成的同时，也能灵活地跑去执行其他的任务，一点也不耽误工夫。 例如，在Python中，我们可以使用asyncio模块来进行异步编程： python import asyncio async def my_function(arg): await asyncio.sleep(1) return f"Processed {arg}" loop = asyncio.get_event_loop() result = loop.run_until_complete(asyncio.gather([my_function(i) for i in range(10)])) print(result) 四、结论 总的来说，使用RabbitMQ和一些基本的技术，我们可以在突发大流量消息场景中有效地处理请求。但是呢，咱也得明白，这只是个临时抱佛脚的办法，骨子里的问题还是没真正解决。因此，我们还需要不断优化我们的应用程序，提高其性能和可扩展性。

...成的系统，这些计算机共享资源、协同工作以完成共同的任务。在本文语境下，提到的分布式系统中的各个服务需要借助Nacos进行服务注册与发现，确保服务间的高效通信和协调运作。 JSON（JavaScript Object Notation） , JSON是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。在Nacos支持的数据格式中，客户端可以将服务相关信息按照JSON规范组织并提交给Nacos服务器，以便存储和管理。 RBAC（Role-Based Access Control） , 基于角色的访问控制是一种权限管理机制，用于控制用户对系统资源的访问权限。在实际应用如Kubernetes等场景中，RBAC通过为不同角色分配不同的操作权限，来细化和增强服务组件的安全管控，防止未经授权的访问或修改行为发生。虽然原文未直接提及Nacos使用RBAC，但这种权限管理模式对于类似Nacos的服务治理工具具有借鉴意义。

...分析 1. 资源不足 HBase对硬件资源的要求较高，包括内存、CPU、硬盘等。如果这些资源不足，可能会导致HBase服务无法正常运行。比如说，如果内存不够用，HBase可能没法把数据好好地缓存起来，这样一来，它的运行速度就会“唰”地慢下来了。 java //创建一个没有足够内存的HBase实例 Configuration config = new Configuration(); config.set("hbase.regionserver.global.memstore.size", "500m"); HBaseTestingUtility htu = new HBaseTestingUtility(config); htu.startMiniCluster(); 2. 网络问题 HBase是一个分布式系统，需要依赖网络进行通信。要是网络闹情绪，出现丢包或者延迟飙升的情况，那可能就会影响到HBase服务的正常运行，搞不好还会让它罢工呢。 java //模拟网络丢包 Mockito.when(client.sendRequest(any(Request.class))).thenThrow(new IOException("Network error")); 3. 数据一致性问题 HBase采用基于时间戳的强一致性模型，当多个节点同时修改相同的数据时，如果没有正确的协调机制，可能会导致数据不一致。 java //模拟并发写入导致的数据冲突 ConcurrentModificationException exception = new ConcurrentModificationException("Data conflict"); doThrow(exception).when(store).put(eq(row), eq(values)); 4. 配置错误 配置错误是常见的问题，如未正确设置参数，或者误删了重要的配置文件等，都可能导致HBase服务中断。 java //删除配置文件 File file = new File("/path/to/config/file"); if (file.exists()) { file.delete(); } 三、HBase服务异常中断解决方案 针对上述的HBase服务异常中断原因，可以采取以下几种解决方案： 1. 提升硬件资源 增加内存、CPU、硬盘等硬件资源，确保HBase能够有足够的资源来运行。 2. 解决网络问题 优化网络环境，提高网络带宽和稳定性，减少丢包和延迟。 3. 强化数据一致性管理 引入事务机制，确保数据的一致性。比如，我们可以利用HBase的MVCC（多版本并发控制）技术，或者请Zookeeper这位大管家帮忙，协调各个节点间的数据同步工作。就像是在一群小伙伴中，有人负责记录不同版本的信息，有人负责确保大家手里的数据都是最新最准确的那样。 4. 检查并修复配置错误 定期检查和维护配置文件，避免因配置错误而导致的服务中断。 以上就是对HBase服务异常中断的一些分析和解决方案。在实际操作的时候，咱们还要看具体情况、瞅准真实需求，像变戏法一样灵活挑拣并运用这些方法。

...个Web项目是否应该共享同一个PHP监听的端口，还是每个项目单独分配一个端口。这个问题呀，其实跟咱们平时用电脑似的，牵扯到不少东西。就好比说，得琢磨怎么让服务器这个“大主机”更高效地分配和使用资源，有点像整理房间，把有限的空间利用到极致；再者呢，就是保证各个项目之间互不干扰，就像每本书都有自己专属的书架，这就是所谓的“项目隔离性”；最后，还希望管理起来轻松便捷，别搞得像解谜游戏似的，让人摸不着头脑。所以呀，归根结底，咱就是要解决服务器资源优化、项目独立运作以及管理简便化这几个关键问题。让我们一起深入探讨并结合实例来解析这一问题。 1. 单一端口多项目共用 首先，我们来看看多个Web项目通过单一PHP端口（通常为80或443）运行的情况： bash 使用Apache作为Web服务器，配置虚拟主机在同一端口上服务多个项目 ServerName project1.example.com DocumentRoot /var/www/project1/public_html ServerName project2.example.com DocumentRoot /var/www/project2/public_html 在这种模式下，不同的项目可以通过不同的域名或者子域名进行区分和访问，Apache/Nginx等Web服务器通过虚拟主机设置将请求路由到相应的项目目录。这样做的好处是，节省了系统资源，特别是对于端口资源有限的情况。同时，统一的端口也简化了防火墙规则和SSL证书的配置。 然而，这种方式存在一定的风险，如若某项目出现安全问题，可能会对同一端口上的其他项目产生影响。此外，如果不同项目的并发处理需求差异较大，可能导致资源调度不均衡。 2. 每个项目独立端口 再来看一下每个Web项目各自使用独立PHP端口的情况： bash 同样以Apache为例，但为每个项目分配独立端口 Listen 8080 ServerName project1.example.com DocumentRoot /var/www/project1/public_html Listen 8081 ServerName project2.example.com DocumentRoot /var/www/project2/public_html 每个项目都有自己的监听端口，这样可以更好地实现项目之间的隔离，提高安全性。而且，对于那些对并发处理能力或者性能要求贼高的项目，咱们完全可以根据实际情况，灵活地给各个项目独立分配资源，想怎么调就怎么调。 不过，这样做会消耗更多的端口资源，并且可能增加管理和维护的复杂度，例如需要额外配置NAT转换或防火墙规则，同时也可能使SSL证书配置变得繁琐。 3. 思考与权衡 在这场讨论中，没有绝对的“正确”答案，更多的是根据实际情况权衡利弊。如果你追求的是资源利用的最大化，希望运维管理能够轻松简单，那么选择共享端口绝对是个靠谱的方案。当你特别看重项目的自主权和安全性，或者有那种“各扫门前雪”，需要明确隔离开不同项目性能的情况时，给每个项目单独分配一个端口就显得超级合理，跟给每个人一间独立办公室一样，互不影响，各得其所。 总结来说，在Linux环境下，如何配置PHP端口服务于多个Web项目，关键在于理解你的业务需求、资源限制以及安全管理策略。在这个过程里，咱们得不断摸爬滚打、尝试各种可能，有时也得鼓起勇气做出一些妥协，就像找寻那个专属于自己的、恰到好处的平衡支点一样。

...，从而实现更细粒度的控制。这项更新对Kubernetes API Server的访问控制和安全性带来了显著提升，尤其对于那些需要高度安全性的企业级应用场景。 此外，近期有一篇深度解读文章，详细分析了Kubernetes API Server在大规模部署中的性能瓶颈及其优化方案。该研究指出，随着集群规模的扩大，API Server面临的主要问题是请求延迟增加和资源消耗过高。通过对API Server的负载均衡、缓存策略以及并发控制的优化，研究团队成功将性能提升了30%以上。这一成果为Kubernetes用户提供了宝贵的实践经验，尤其是在构建高可用和高性能的Kubernetes集群方面。 同时，值得注意的是，Kubernetes社区也在积极探讨如何通过集成更多先进的认证和授权机制，进一步提升API Server的安全性。例如，引入OAuth 2.0和OpenID Connect标准，使得认证过程更加灵活和安全。这些改进不仅提高了系统的安全性，也为用户提供了更加多样化的选择。 综上所述，Kubernetes API Server的持续优化和发展，为用户提供了更加高效、安全和灵活的服务。对于希望深入了解Kubernetes API Server的读者来说，这些最新的进展无疑提供了丰富的参考资料和实践指导。

...而大大提高了系统处理并发请求的能力。 npm（Node包管理器） , npm是Node.js的默认包管理器，是一个用于JavaScript编程语言的软件包生态系统。它提供了便捷的方式来安装、共享和版本控制Node.js模块。通过npm，开发者可以方便地查找、下载并使用他人开发的高质量第三方库或工具，同时也可以发布自己的模块给社区，极大地提升了开发效率和协作便利性。在构建命令行工具的过程中，npm可以帮助我们初始化项目、管理依赖关系以及发布最终的工具包。

...版本引入的核心组件，作为下一代Hadoop资源管理系统，负责在整个集群中高效地管理和分配计算资源。YARN将资源管理与任务调度解耦，允许多个数据处理框架（如MapReduce、Spark、Tez等）共享集群资源，每个应用通过向YARN请求并获取资源来运行其任务。 容量调度器（Capacity Scheduler） , 在YARN中，容量调度器是一种主要的资源调度策略，它支持多队列层次结构和多用户资源共享。每个队列都有预定义的最大容量限制，以保证不同队列间的资源公平分配。同时，每个队列内部还设有访问控制列表（ACL），确保只有授权的用户或用户组才能提交应用程序到该队列，并按需使用队列中的资源来执行大数据作业，如Apache Pig作业。

...ng）凭着它那超凡的并发处理能力和无比强大的网络功能，成功圈粉了一大批开发者，让他们爱不释手呢！今天，我们就来看看如何使用Go处理多进程间的通信和同步。 二、使用channel进行通信和同步 1. channel的基本概念 在Go中，channel是一种特殊的类型，它可以让不同的goroutine（Go程序中的轻量级线程）之间进行数据传递和同步操作。你可以把channel想象成是goroutine之间的秘密小隧道，它们通过这个隧道来传递信息和交换数据，就像我们平时排队传话或者扔纸飞机那样，只不过在程序的世界里，它们是在通过管道进行通信啦。如下是一个简单的channel的例子： go package main import ( "fmt" "time" ) func send(msg string, ch chan<- string) { fmt.Println("Sending:", msg) ch <- msg } func receive(ch <-chan string) string { msg := <-ch fmt.Println("Receiving:", msg) return msg } func main() { ch := make(chan string) go send("Hello", ch) msg := receive(ch) fmt.Println("Done:", msg) } 在这个例子中，我们定义了一个send函数和一个receive函数，分别用来发送和接收数据。然后我们捣鼓出了一个channel，就像建了个信息传输的通道。在程序的大脑——主函数那里，我们让它同时派出两个“小分队”——也就是goroutine，一个负责发送数据，另一个负责接收数据，这样一来，数据就在它们之间飞快地穿梭起来了。运行这个程序，我们会看到输出结果为： makefile Sending: Hello Receiving: Hello Done: Hello 可以看到，两个goroutine通过channel成功地进行了数据交换。 2. 使用channel进行同步 除了用于数据交换外，channel还可以用于同步goroutine。当一个goroutine在channel那儿卡壳了，等待着消息时，其他goroutine完全不受影响，可以该干嘛干嘛，继续欢快地执行任务。这样一来，咱们就能妥妥地防止多个并发执行的小家伙（goroutine）一起挤进共享资源的地盘，从而成功避开那些让人头疼的数据冲突问题啦。例如，我们可以使用channel来控制任务的执行顺序： go package main import ( "fmt" "time" ) func worker(id int, jobs <-chan int, results chan<- int) { for j := range jobs { time.Sleep(time.Duration(j)time.Millisecond) results <- id j } } func main() { jobs := make(chan int, 100) results := make(chan int, 100) for i := 0; i < 10; i++ { go worker(i, jobs, results) } for i := 0; i < 50; i++ { jobs <- i } close(jobs) var sum int for r := range results { sum += r } fmt.Println("Sum:", sum) } 在这个例子中，我们定义了一个worker函数，用来处理任务。每个worker都从jobs channel读取任务，并将结果写入results channel。然后呢，我们在main函数里头捣鼓出10个小弟worker，接着一股脑向那个叫jobs的通道塞了50个活儿。最后一步，咱们先把那个jobs通道给关了，然后从results通道里把所有结果都捞出来，再把这些结果加一加算个总数。运行这个程序，我们会看到输出结果为： python Sum: 12750 可以看到，所有的任务都被正确地处理了，并且处理顺序符合我们的预期。 三、使用waitgroup进行同步 除了使用channel外，Go还提供了一种更高级别的同步机制——WaitGroup。WaitGroup允许我们在一组goroutine完成前等待其全部完成。比如，我们可以在主程序里头创建一个WaitGroup对象，然后每当一个新的并发任务（goroutine）开始执行时，就像在小卖部买零食前先拍一下人数统计器那样，给这个WaitGroup调用Add方法加一记数。等到所有并发任务都嗨皮地完成它们的工作后，再挨个儿调用Done方法，就像任务们一个个走出门时，又拍一下统计器减掉一个人数。当计数器变为0时，主函数就会结束。 go package main import ( "fmt" "sync" ) func worker(id int, wg sync.WaitGroup) { defer wg.Done() for i := 0; i < 10; i++ { fmt.Printf("Worker %d did something.\n", id) } } func main() { wg := sync.WaitGroup{} for i := 0; i < 10; i++ { wg.Add(1) go worker(i, &wg)

...，Greenplum作为一款开源且高度可扩展的MPP（大规模并行处理）数据库，以其卓越的大规模数据分析能力深受广大用户的青睐。在实际操作时，我们可能会遇到需要对表格里的数据类型或者精度进行微调的情况。这背后的原因五花八门，可能是为了更有效地利用存储空间，让查询速度嗖嗖提升；也可能是为了更好地适应业务发展，满足那些新冒出来的需求点。这篇内容，咱们会手把手地通过一些实实在在的代码实例，带你逐个步骤掌握如何在Greenplum里搞定这个操作。同时，咱们还会边走边聊，一起探讨在这个过程中可能会踩到的坑以及相应的填坑大法。 2. 理解Greenplum的数据类型与精度 在Greenplum中，每列都有特定的数据类型，如整数（integer）、浮点数（real）、字符串（varchar）等，而精度则是针对数值型数据类型的特性，如numeric(10,2)表示最大整数位数为10，小数位数为2。理解这些基础概念是进行调整的前提。 sql -- 创建一个包含不同数据类型的表 CREATE TABLE test_data_types ( id INT, name VARCHAR(50), salary NUMERIC(10,2) ); 3. 调整Greenplum中的数据类型 场景一：改变数据类型 例如，假设我们的salary字段原先是INTEGER类型，现在希望将其更改为NUMERIC以支持小数点后的精度。 sql -- 首先，我们需要确保所有数据都能成功转换到新类型 ALTER TABLE test_data_types ALTER COLUMN salary TYPE NUMERIC; -- 或者，如果需要同时指定精度 ALTER TABLE test_data_types ALTER COLUMN salary TYPE NUMERIC(10,2); 注意，修改数据类型时必须保证现有数据能成功转换到新的类型，否则操作会失败。在执行上述命令前，最好先运行一些验证查询来检查数据是否兼容。 场景二：增加或减少数值类型的精度 若要修改salary字段的小数位数，可以如下操作： sql -- 增加salary字段的小数位数 ALTER TABLE test_data_types ALTER COLUMN salary TYPE NUMERIC(15,4); -- 减少salary字段的小数位数，系统会自动四舍五入 ALTER TABLE test_data_types ALTER COLUMN salary TYPE NUMERIC(10,1); 4. 考虑的因素与挑战 - 数据完整性与一致性：在调整数据类型或精度时，务必谨慎评估变更可能带来的影响，比如精度降低可能导致的数据丢失。 - 性能开销：某些数据类型之间的转换可能带来额外的CPU计算资源消耗，尤其是在大表上操作时。 - 索引重建：更改数据类型后，原有的索引可能不再适用，需要重新创建。 - 事务与并发控制：对于大型生产环境，需规划合适的维护窗口期，以避免在数据类型转换期间影响其他业务流程。 5. 结语 调整Greenplum中的数据类型和精度是一个涉及数据完整性和性能优化的关键步骤。在整个这个过程中，我们得像个侦探一样，深入地摸透业务需求，把数据验证做得像查户口似的，仔仔细细，一个都不能放过。同时，咱们还要像艺术家设计蓝图那样，精心策划每一次的变更方案。为啥呢？就是为了在让系统跑得飞快的同时，保证咱的数据既整齐划一又滴水不漏。希望这篇东西里提到的例子和讨论能实实在在帮到你，让你在用Greenplum处理数据的时候，感觉就像个武林高手，轻松应对各种挑战，游刃有余，毫不费力。