张哈希的博客

曾任职于顺丰,华为,网易等公司,从Java小白,成长为资深开发与项目组首席架构师。喜欢源码与开源,曾贡献 MyCat1.6 与 JFRUnit 核心源码,贡献过Spring Cloud,Apache RocketMQ,Apache Bookeeper,Du
私信 关注
干货满满张哈希
码龄12年

曾任职于顺丰,华为,网易等公司,从Java小白,成长为资深开发与项目组首席架构师。喜欢源码与开源,曾贡献 MyCat1.6 核心源码,贡献过druid,Spring Cloud,dubbox,Apache RocketMQ,Apache Bookeeper 等多开源项目。

  • 3,517,387
    被访问量
  • 302
    原创文章
  • 1,095
    作者排名
  • 1,679
    粉丝数量
  • 目前就职 网易
  • 于 2008-10-27 加入CSDN
获得成就
  • 博客专家认证
  • 获得399次点赞
  • 内容获得466次评论
  • 获得287次收藏
荣誉勋章
兴趣领域
  • #大数据
    #storm#hadoop#spark
TA的专栏
  • 每日一面
    58篇
  • 深入OpenJDK 11+
  • 通过JFR与日志深入探索JVM
    6篇
  • Java GC详解
    4篇
  • 全网最硬核 OpenJDK 分析
    10篇
  • 分布式系统设计模式
    5篇
  • Spring Cloud相关
    37篇
  • Spring全解
    3篇
  • JDK框架JAVA源码解析
    20篇
  • 微服务系统架构设计
    1篇
  • Java 监控 JFR
    8篇
  • Project Reactor全解
    2篇
  • Spring Cloud 升级之路
    10篇
  • 本地缓存框架
    1篇
  • JEP解读与尝鲜
    5篇
  • MyCat全面解析
    26篇
  • 数据库分库分表(Mycat等)
    29篇
  • 数据库同步(otter等)
    3篇
  • 高并发数据结构(disruptor)
    6篇
  • (转载)微服务实战
    6篇
  • JDK源码剖析
    22篇
  • 分布式协同服务(zookeeper与ETCD)
    8篇
  • 数据库总览
    1篇
  • 分布式键值对数据库(Riak)
    4篇
  • 函数式编程(Clojure)
    1篇
  • 读书笔记(文档型数据库MongoDB)
    1篇
  • 高性能网络通信框架(netty)
    3篇
  • SQL解析器(Druid SQLParser)
    2篇
  • git
    1篇
  • c++温习
    3篇
  • MySQL相关
    7篇
  • UML
    1篇
  • html5
    1篇
  • java碎片收集
    26篇
  • linux命令
    2篇
  • 大数据平台Hadoop
    5篇
  • 大数据流式实时处理Spark
    7篇
  • 搜索引擎ES
    2篇
  • 前端收集
    3篇
  • webkit相关
    2篇
  • 分布式对象存储Ambry
    9篇
  • go语言
    1篇
  • GC与Java内存
    4篇
  • 好的架构实践
    1篇
  • 问题定位
    12篇
  • 序列化
    2篇
  • 微服务SpringBoot/Cloud
    28篇
  • 概率论与数理统计
    4篇
  • Spring Cloud 服务注册发现eureka
    10篇
  • http碎片收集
    1篇
  • Spring Cloud Restful客户端 feign
    2篇
  • Spring Cloud API网关 zuul
    3篇
  • Nosql缓存 redis
    7篇
  • spring碎片收集
    2篇
  • Spring Cloud 负载均衡ribbon
    10篇
  • log4j2
    1篇
  • Java类加载原理
    1篇
  • Spring Cloud断路器Hystrix 
    1篇
  • 心路日记
    3篇
  • Java监控相关JMX解析
  • 日志类型存储BookKeeper
    1篇
  • 新型消息队列Pulsar
    2篇
  • Java在线问题定位工具Arthas
    2篇
  • 高性能web容器undertow
    1篇
  • 新闻去重方案
    1篇
  • Spring Cloud RPC调用封装OpenFeign
    1篇
  • OpenJDK11
    4篇
关于我

曾任职于顺丰,华为,网易等公司,从Java小白,成长为资深开发与项目组首席架构师

喜欢源码与开源,曾贡献 MyCat1.6 与 Java JFR unit 核心源码,贡献过druid,Spring Cloud,dubbox,Apache RocketMQ,Apache Bookeeper 等多开源项目。

我的Github

我的知乎

我的StackOverFlow

我的Github贡献汇总

每日一刷,轻松提升技术,斩获各种offer(有收费专栏福利哟~): 我的公众号
  • 最近
  • 文章
  • 资源
  • 问答
  • 课程
  • 帖子
  • 收藏
  • 关注/订阅

2021-2-28:调用 System.gc() 后究竟发生了什么?

首先,根据 DisableExplicitGC 这个 JVM 启动参数的状态,确定是否会 GC,如果需要 GC,不同 GC 会有不同的处理。1. G1 GC 的处理如果是 System.gc() 触发的 GC,G1 GC 会根据 ExplicitGCInvokesConcurrent 这个 JVM 参数决定是默认 GC (轻量 GC,YoungGC)还是 FullGC。参考代码g1CollectedHeap.cpp://是否应该并行 GC,也就是较为轻量的 GC,对于 GCCause::_java_
原创
2243阅读
0评论
0点赞
发布博客于 3 天前

2021-2-27:Linux 下如何优化 Java MMAP 写入

主要是调整 pdflush 相关参数。在linux操作系统中,写操作是异步的,即写操作返回的时候数据并没有真正写到磁盘上,而是先写到了系统cache里,随后由pdflush内核线程将系统中的脏页写到磁盘上,在下面几种情况下:定时方式: 定时机制定时唤醒pdflush内核线程,周期为/proc/sys/vm/dirty_writeback_centisecs ,单位是(1/100)秒,每次周期性唤醒的pdflush线程并不是回写所有的脏页,而是只回写变脏时间超过/proc/sys/vm/dirty
原创
3064阅读
0评论
0点赞
发布博客于 4 天前

2021-2-26:为什么需要 System.gc() ?

JVM 默认启动参数中,DisableExplicitGC 为 false,ExplicitGCInvokesConcurrent 为 false,对于大多数 GC (除了 ZGC 的其他 GC,包括 CMS,G1,Shenandoah GC 等等),都是会进行 FullGC 的,并且都是同步 GC 的,其中底层的原理会在另一篇详细分析,我们先来搞清楚为什么要留这样一个接口呢?1. 使用并管理堆外内存的框架,需要 Full GC 的机制触发堆外内存回收JVM 的内存,不止堆内存,还有其他很多块,通过
原创
3897阅读
0评论
0点赞
发布博客于 5 天前

JVM相关 - 深入理解 System.gc()

本文基于 Java 17-ea,但是相关设计在 Java 11 之后是大致一样的我们经常在面试中询问 System.gc() 究竟会不会立刻触发 Full GC,网上也有很多人给出了答案,但是这些答案都有些过时了。本文基于最新的 Java 的下一个即将发布的 LTS 版本 Java 17(ea)的源代码,深入解析 System.gc() 背后的故事。为什么需要System.gc()1. 使用并管理堆外内存的框架,需要 Full GC 的机制触发堆外内存回收JVM 的内存,不止堆内存,还有其他很多.
原创
5602阅读
0评论
0点赞
发布博客于 5 天前

2021-2-25:对于 Java MMAP,如何查看文件映射脏页,如何统计MMAP的内存大小?

我们写一个测试程序:public static void main(String[] args) throws Exception { RandomAccessFile randomAccessFile = new RandomAccessFile("./FileMmapTest.txt", "rw"); FileChannel channel = randomAccessFile.getChannel(); MappedByteBuffer []mappedByteBuffers
原创
2078阅读
0评论
0点赞
发布博客于 6 天前

2021-2-24:请问你知道 CPU SMP 架构么?

为了扩展单核 CPU 的性能,现在的服务器架构多采用多核 CPU 架构。一个比较经典的 CPU 架构就是对称多处理(Symmetric Multi-Processing,SMP)架构。与之相对应的就是非对称多处理(Asym-metrical Mulit-Processing)结构。这个对称是什么意思?即处理器与处理器的关系,在对称多处理架构中,处理器之间是相同等级的,所有处理器都可以访问相同的资源。与之相应的,非对称多处理架构,各处理器之间形成简单的主从设备关系,访问有限的资源。一个 SMP CPU 架
原创
2092阅读
0评论
0点赞
发布博客于 7 天前

2021-2-23:Java 文件映射内存是如何更新到硬盘文件的,什么情况下会丢失?

对于 Java MMAp,修改 MappedByteBuffer 就相当于修改了文件。之后操作系统根据优先搜索树的算法,通过pdflush进程刷入磁盘。就算我们的程序挂了,操作系统也会把这部分内存的脏页刷入磁盘。但是如果系统挂了,重启等,这部分数据会丢失。那我们有强制刷入磁盘的方法么?linux对应的系统调用是msync()函数(参考:http://man7.org/linux/man-pages/man2/msync.2.html)。对应的Java方法是MappedByteBuffer.force(
原创
2894阅读
0评论
0点赞
发布博客于 8 天前

2021-2-22:请你说下 CAP 理论并举例

CAPCAP 理论是分布式系统中的一个老生常谈的理论了,最早由 Eric Brewer 在一个讲座中提出。在这个讲座中,在传统 ACID 理论以及当时比较流行但是比较抽象的的设计指导理论 BASE 理论(当时的 BASE 理论还很抽象,直到好几年后才出现一份比较权威的被广泛接受的 BASE 理论完整解释和设计)的类比中,提出C(Consistency,一致性):在一个分布式的系统中,同一个数据的所有备份,在同一时刻是否有相同的值。也就是,对于同一个数据的读写,是否立刻对于所有副本都能看到一致的结果。一
原创
1045阅读
0评论
0点赞
发布博客于 9 天前

2021-2-21:Java File MMAP 中,对 MappedByteBuffer 进行读写,为何最大只能2GB-1B?

我们来看底层实现:对于所有DirectByteBuffer的读写,都用到了Unsafe类的public native void putByte(Object o, long offset, byte x);方法,底层实现是:unsafe.cpp:UNSAFE_ENTRY(void, Unsafe_SetNative##Type(JNIEnv *env, jobject unsafe, jlong addr, java_type x)) \ UnsafeWrapper("Unsafe_SetNativ
原创
2483阅读
0评论
0点赞
发布博客于 10 天前

2021-2-20:请你说说分布式系统 BASE 理论是什么?

BASE 理论是由 Dan Pritchett 在 ACM 上发表的一篇论文中提出的理论。是在 CAP 理论基础上提出的一种更实际的理论指导,和 PACELC 理论是有些相近的地方的。BASE 是指 基本可用(Basically Available)、软状态( Soft State)、最终一致性( Eventual Consistency)。对于目前的互联网应用,基本上都不会是单机系统,而是多机分布式系统,所以 CAP 中的 P 是一定要的特性。剩下的 C P 根据实际场景取舍。BASE 就是一种取舍方
原创
576阅读
0评论
1点赞
发布博客于 11 天前

2021-2-19:请问你知道 Java 如何高性能操作文件么?

一般高性能的涉及到存储框架,例如 RocketMQ,Kafka 这种消息队列,存储日志的时候,都是通过 Java File MMAP 实现的,那么什么是 Java File MMAP 呢?什么是 Java File MMAP尽管从JDK 1.4版本开始,Java 内存映射文件(Memory Mapped Files)就已经在java.nio包中,但它对很多程序开发者来说仍然是一个相当新的概念。引入 NIO 后,Java IO 已经相当快,而且内存映射文件提供了 Java 有可能达到的最快 IO 操作,这
原创
3837阅读
0评论
0点赞
发布博客于 12 天前

2021-2-18:请你说说MySQL的字符集与排序规则对开发有哪些影响?

任何计算机存储数据,都需要字符集,因为计算机存储的数据其实都是二进制编码,将一个个字符,映射到对应的二进制编码的这个映射就是字符编码(字符集)。这些字符如何排序呢?决定字符排序的规则就是排序规则。查看内置字符集与比较规则通过show charset;命令,可以查看所有的字符集。以下仅展示了我们常用的字符集:+----------+---------------------------------+---------------------+--------+| Charset | Descrip
原创
1546阅读
0评论
0点赞
发布博客于 13 天前

2021-2-17:Java HashMap 的中 key 的哈希值是如何计算的,为何这么计算?

首先,我们知道 HashMap 的底层实现是开放地址法 + 链地址法的方式来实现。即数组 + 链表的实现方式,通过计算哈希值,找到数组对应的位置,如果已存在元素,就加到这个位置的链表上。在 Java 8 之后,链表过长还会转化为红黑树。这个数组并不是一开始就很大,而是随着 HashMap 里面的值变多,达到 LoadFactor 的界限之后,就会扩容。刚开始的数组很小,默认只有 16。这个数组大小一定是 2 的 n 次方,因为找到数组对应的位置需要通过取余计算,取余计算是一个很耗费性能的计算,而对
原创
1407阅读
0评论
0点赞
发布博客于 14 天前

2021-2-16:请问你知道分布式设计模式中的Quorum思想么?

有效个数(Quorum)有效个数(Quorum)这个设计模式一般是指分布式系统的每一次修改都要在大多数实例上通过来确定修改通过。问题背景在一个分布式存储系统中,用户请求会发到一个实例上。通常在一个实例上面执行的修改,需要复制到其他的实例上,这样可以保证在原实例挂了的情况下,用户依然可以看到这个修改。这就涉及到一个问题,究竟复制到多少个其他实例上之后,用户请求才会返回成功呢?如果复制的实例个数过多,那么请求响应时间就会更长;如果复制的实例过少,则这个修改可能会丢失。取得这个平衡性很重要,这也是分布式 P
原创
972阅读
0评论
1点赞
发布博客于 15 天前

Java 对象的哈希值是每次 hashCode() 方法调用重计算么?

对于没有覆盖hashCode()方法的对象如果没有覆盖 hashCode() 方法,那么哈希值为底层 JDK C++ 源码实现,实例每次调用hashcode()方法,只有第一次计算哈希值,之后哈希值会存储在对象头的 标记字(MarkWord) 中。如果进入各种锁状态,那么会缓存在其他地方,一般是获取锁的线程里面存储,恢复无锁(即释放锁)会改回原有的哈希值。对应源码synchronizer.cpp://如果是无锁状态if (mark.is_neutral()) { hash
原创
1069阅读
0评论
0点赞
发布博客于 16 天前

请问你知道分布式系统设计模式的最低水位线思想么?

最低水位线(Low-Water Mark)最低水位线是指在 WAL(Write Ahead Log)预写日志这种设计模式中,标记在这个位置之前的日志可以被丢弃。问题背景WAL(Write Ahead Log)预写日志维护了对于存储的每次更新,随着时间不断增长,这个日志文件会变得无限大。Segmented Log 分割日志这种设计模式可以让我们每次只处理一个更小的文件,但是日志如果不清理,会无休止增长以至于硬盘被占满。解决方案最低水位线这种设计模式会告诉系统哪一部分的日志可以被删除了,即在最低水位线
原创
1254阅读
0评论
0点赞
发布博客于 17 天前

JVM 报 GC Overhead limit exceeded 是什么意思?

默认情况下,并不是等堆内存耗尽,才会报 OutOfMemoryError,而是如果 JVM 觉得 GC 效率不高,也会报这个错误。那么怎么评价 GC 效率不高呢?来看下源码:呢?来看下源码gcOverheadChecker.cpp:void GCOverheadChecker::check_gc_overhead_limit(GCOverheadTester* time_overhead, GCOverhe
原创
1151阅读
0评论
0点赞
发布博客于 17 天前

JVM ZeroTLAB 是什么意思呢?

ZeroTLAB 是 JVM 的一个布尔型 Flag,意思是是否将新创建的 TLAB 内的所有字节归零。默认:false举例:-XX:+ZeroTLAB当分配出来 TLAB 之后,根据 ZeroTLAB 配置,决定是否将每个字节赋 0。在 TLAB 申请时,由于申请 TLAB 都发生在对象分配的时候,也就是这块内存会立刻被使用,并修改赋值。操作内存,涉及到 CPU 缓存行,如果是多核环境,还会涉及到 CPU 缓存行 false sharing,为了优化,JVM 在这里做了 Allocation Pre
原创
1468阅读
0评论
1点赞
发布博客于 19 天前

请问你知道分布式系统设计模式的分割日志思想么?

分割日志(Segmented Log)将大文件切分为更容易处理的多个更小的文件。问题背景单一的日志文件可能会增长到很大,并且在程序启动时读取从而成为性能瓶颈。老的日志需要定时清理,但是对于一个大文件进行清理操作很费劲。解决方案将单一日志切分为多个,日志在达到一定大小时,会切换到新文件继续写。//写入日志public Long writeEntry(WALEntry entry) { //判断是否需要另起新文件 maybeRoll(); //写入文件 return
原创
2162阅读
0评论
1点赞
发布博客于 20 天前

请问什么时候对象分配会不在 TLAB 内分配

Java 对象分配流程我们这里不考虑栈上分配,这些会在 JIT 的章节详细分析,我们这里考虑的是无法栈上分配需要共享的对象。对于 HotSpot JVM 实现,所有的 GC 算法的实现都是一种对于堆内存的管理,也就是都实现了一种堆的抽象,它们都实现了接口 CollectedHeap。当分配一个对象堆内存空间时,在 CollectedHeap 上首先都会检查是否启用了 TLAB,如果启用了,则会尝试 TLAB 分配;如果当前线程的 TLAB 大小足够,那么从线程当前的 TLAB 中分配;如果不够,但是
原创
2785阅读
0评论
1点赞
发布博客于 21 天前

请问你知道分布式系统的预写日志设计模式么?

Write-Ahead log 预写日志预写日志(WAL,Write-Ahead Log)将每次状态更新抽象为一个命令并追加写入一个日志中,这个日志只追加写入,也就是顺序写入,所以 IO 会很快。相比于更新存储的数据结构并且更新落盘这个随机 IO 操作,写入速度更快了,并且也提供了一定的持久性,也就是数据不会丢失,可以根据这个日志恢复数据。背景介绍如果遇到了服务器存储数据失败,例如已经确认客户端的请求,但是存储过程中,重启进程导致真正存储的数据没有落盘,在重启后,也需要保证已经答应客户端的请求数据更新
原创
3168阅读
0评论
1点赞
发布博客于 22 天前

为何现在响应式编程在业务开发微服务开发不普及

为何现在响应式编程在业务开发微服务开发不普及主要因为数据库 IO,不是 NIO。不论是Java自带的Future框架,还是 Spring WebFlux,还是 Vert.x,他们都是一种非阻塞的基于Ractor模型的框架(后两个框架都是利用netty实现)。在阻塞编程模式里,任何一个请求,都需要一个线程去处理,如果io阻塞了,那么这个线程也会阻塞在那。但是在非阻塞编程里面,基于响应式的编程,线程不会被阻塞,还可以处理其他请求。举一个简单例子:假设只有一个线程池,请求来的时候,线程池处理,需要读取数据库
原创
3342阅读
0评论
1点赞
发布博客于 23 天前

为何 JVM TLAB 在线程退还给堆的时候需要填充 dummy object

TLAB 全网最硬核的解析,请参考:全网最硬核 JVM TLAB 分析TLAB 在何时退还给堆?有两种情况:当前 TLAB 不足分配,并且剩余空间小于当前线程最大浪费空间限制时。发生 GC 时,在 GC 扫描前的时候。什么是 dummy object?是一个被标记为可回收的 int[] 数组。填充后, GC 扫描会直接标记为可回收。为何填充 dummy object主要保证 GC 的时候扫描高效。由于 TLAB 仅线程内知道哪些被分配了,在 GC 扫描发生时返回 Eden 区,如果不填充
原创
19130阅读
0评论
1点赞
发布博客于 24 天前

什么是响应式编程,Java 如何实现

我们这里用通过唯一 id 获取知乎的某个回答作为例子,首先我们先明确下,一次HTTP请求到服务器上处理完之后,将响应写回这次请求的连接,就是完成这次请求了,如下:public void request(Connection connection, HttpRequest request) { //处理request,省略代码 connection.write(response);//完成响应}假设获取回答需要调用两个接口,获取评论数量还有获取回答信息,传统的代码可能会这么去写://
原创
9234阅读
1评论
1点赞
发布博客于 25 天前

90% 的 Java 程序员都说不上来的为何 Java 代码越执行越快(2)- TLAB预热

经常听到 Java 性能不如 C/C++ 的言论,也经常听说 Java 程序需要预热,那么其中主要原因是啥呢?面试的时候谈到 JVM,也有很多面试官喜欢问,为啥 Java 程序越执行越快呢?一般人都能回答上来,类加载,缓存预热等等,但是深入下去,最重要的却没有答上来,今天本系列文章就来帮助大家理解这个问题的关键。本篇文章是 TLAB 预热。TLAB(Thread Local Allocation Buffer)线程本地分配缓存区,这是一个线程专用的内存分配区域。既然是一个内存分配区域,我们就先要搞
原创
8854阅读
0评论
1点赞
发布博客于 26 天前

全网最硬核 JVM TLAB 分析(额外加菜) 8. 通过 JFR 监控 TLAB

今天,又是干货满满的一天。这是全网最硬核 JVM 系列的开篇,首先从 TLAB 开始。由于文章很长,每个人阅读习惯不同,所以特此拆成单篇版和多篇版全网最硬核 JVM TLAB 分析(单篇版不包含额外加菜)全网最硬核 JVM TLAB 分析 1. 内存分配思想引入全网最硬核 JVM TLAB 分析 2. TLAB生命周期与带来的问题思考全网最硬核 JVM TLAB 分析 3. JVM EMA期望算法与TLAB相关JVM启动参数全网最硬核 JVM TLAB 分析 4. TLAB 基本流程全分析.
原创
22630阅读
0评论
0点赞
发布博客于 27 天前

全网最硬核 JVM TLAB 分析(额外加菜) 7. TLAB 相关 JVM 日志解析

今天,又是干货满满的一天。这是全网最硬核 JVM 系列的开篇,首先从 TLAB 开始。由于文章很长,每个人阅读习惯不同,所以特此拆成单篇版和多篇版全网最硬核 JVM TLAB 分析(单篇版不包含额外加菜)全网最硬核 JVM TLAB 分析 1. 内存分配思想引入全网最硬核 JVM TLAB 分析 2. TLAB生命周期与带来的问题思考全网最硬核 JVM TLAB 分析 3. JVM EMA期望算法与TLAB相关JVM启动参数全网最硬核 JVM TLAB 分析 4. TLAB 基本流程全分析.
原创
22598阅读
3评论
1点赞
发布博客于 27 天前

全网最硬核 JVM TLAB 分析 6. TLAB 相关热门Q&A汇总

今天,又是干货满满的一天。这是全网最硬核 JVM 系列的开篇,首先从 TLAB 开始。由于文章很长,每个人阅读习惯不同,所以特此拆成单篇版和多篇版全网最硬核 JVM TLAB 分析(单篇版不包含额外加菜)全网最硬核 JVM TLAB 分析 1. 内存分配思想引入全网最硬核 JVM TLAB 分析 2. TLAB生命周期与带来的问题思考全网最硬核 JVM TLAB 分析 3. JVM EMA期望算法与TLAB相关JVM启动参数全网最硬核 JVM TLAB 分析 4. TLAB 基本流程全分析.
原创
22415阅读
0评论
0点赞
发布博客于 27 天前

全网最硬核 JVM TLAB 分析 5. TLAB 源代码全解析

今天,又是干货满满的一天。这是全网最硬核 JVM 系列的开篇,首先从 TLAB 开始。由于文章很长,每个人阅读习惯不同,所以特此拆成单篇版和多篇版全网最硬核 JVM TLAB 分析(单篇版不包含额外加菜)全网最硬核 JVM TLAB 分析 1. 内存分配思想引入全网最硬核 JVM TLAB 分析 2. TLAB生命周期与带来的问题思考全网最硬核 JVM TLAB 分析 3. JVM EMA期望算法与TLAB相关JVM启动参数全网最硬核 JVM TLAB 分析 4. TLAB 基本流程全分析.
原创
22545阅读
0评论
0点赞
发布博客于 27 天前

全网最硬核 JVM TLAB 分析 4. TLAB 基本流程全分析

今天,又是干货满满的一天。这是全网最硬核 JVM 系列的开篇,首先从 TLAB 开始。由于文章很长,每个人阅读习惯不同,所以特此拆成单篇版和多篇版全网最硬核 JVM TLAB 分析(单篇版不包含额外加菜)全网最硬核 JVM TLAB 分析 1. 内存分配思想引入全网最硬核 JVM TLAB 分析 2. TLAB生命周期与带来的问题思考全网最硬核 JVM TLAB 分析 3. JVM EMA期望算法与TLAB相关JVM启动参数全网最硬核 JVM TLAB 分析 4. TLAB 基本流程全分析.
原创
22586阅读
0评论
1点赞
发布博客于 27 天前

全网最硬核 JVM TLAB 分析 3. JVM EMA期望算法与TLAB相关JVM启动参数

今天,又是干货满满的一天。这是全网最硬核 JVM 系列的开篇,首先从 TLAB 开始。由于文章很长,每个人阅读习惯不同,所以特此拆成单篇版和多篇版全网最硬核 JVM TLAB 分析(单篇版不包含额外加菜)全网最硬核 JVM TLAB 分析 1. 内存分配思想引入全网最硬核 JVM TLAB 分析 2. TLAB生命周期与带来的问题思考全网最硬核 JVM TLAB 分析 3. JVM EMA期望算法与TLAB相关JVM启动参数全网最硬核 JVM TLAB 分析 4. TLAB 基本流程全分析.
原创
22582阅读
0评论
1点赞
发布博客于 27 天前

全网最硬核 JVM TLAB 分析 2. TLAB生命周期与带来的问题思考

今天,又是干货满满的一天。这是全网最硬核 JVM 系列的开篇,首先从 TLAB 开始。由于文章很长,每个人阅读习惯不同,所以特此拆成单篇版和多篇版全网最硬核 JVM TLAB 分析(单篇版不包含额外加菜)全网最硬核 JVM TLAB 分析 1. 内存分配思想引入全网最硬核 JVM TLAB 分析 2. TLAB生命周期与带来的问题思考全网最硬核 JVM TLAB 分析 3. JVM EMA期望算法与TLAB相关JVM启动参数全网最硬核 JVM TLAB 分析 4. TLAB 基本流程全分析.
原创
22422阅读
0评论
1点赞
发布博客于 27 天前

全网最硬核 JVM TLAB 分析 1. 内存分配思想引入

今天,又是干货满满的一天。这是全网最硬核 JVM 系列的开篇,首先从 TLAB 开始。由于文章很长,每个人阅读习惯不同,所以特此拆成单篇版和多篇版全网最硬核 JVM TLAB 分析(单篇版不包含额外加菜)全网最硬核 JVM TLAB 分析 1. 内存分配思想引入全网最硬核 JVM TLAB 分析 2. TLAB生命周期与带来的问题思考全网最硬核 JVM TLAB 分析 3. JVM EMA期望算法与TLAB相关JVM启动参数全网最硬核 JVM TLAB 分析 4. TLAB 基本流程全分析.
原创
22519阅读
0评论
2点赞
发布博客于 27 天前

全网最硬核 JVM TLAB 分析(单篇版不包含额外加菜)

今天,又是干货满满的一天。这是全网最硬核 JVM 系列的开篇,首先从 TLAB 开始。由于文章很长,每个人阅读习惯不同,所以特此拆成单篇版和多篇版全网最硬核 JVM TLAB 分析(单篇版不包含额外加菜)全网最硬核 JVM TLAB 分析 1. 内存分配思想引入全网最硬核 JVM TLAB 分析 2. TLAB生命周期与带来的问题思考全网最硬核 JVM TLAB 分析 3. JVM EMA期望算法与TLAB相关JVM启动参数全网最硬核 JVM TLAB 分析 4. TLAB 基本流程全分析.
原创
22558阅读
0评论
1点赞
发布博客于 27 天前

分布式理论 PACELC 了解么?

PACELC 基于 CAP 理论演进而来。CAP 理论是一个分布式系统中老生常谈的理论了:C(Consistency):一致性,所有节点在同一时间的数据完全一致。A(Availability):可用性,服务一直可用。P(Partition tolerance):分区容错性,遇到某节点或网络分区故障的时候,仍然能够对外提供满足一致性和可用性的服务系统设计中,这三点只能取其二,一般的分布式系统要求必须有分区容错性。剩下的只能从 C 或者 A 中取舍。但是这个理论并不能很好地应用于实际,首先, A
原创
44阅读
0评论
0点赞
发布博客于 28 天前

哈哈哈,带阴阳师

发布Blink于 29 天前

知道 Redis-Cluster 么?说说其中可能不可用的情况

Redis 集群模式简述一个集群模式的官方推荐最小最佳实践方案是 6 个节点,3 个 Master 3 个 Slave 的模式,如 图00 所示。key 分槽与转发机制Redis 将键空间分为了 16384 个槽,通过以下算法确定每一个 key 的槽:CRC16(key) mod 16384由于 16384 = 2 的 14 次方,对一个 2 的 n 次方取余相当于对于它的 2 的 n 次方减一取与运算。所以优化为:CRC16(key) & 16383当 key 包含 hash
原创
1068阅读
0评论
0点赞
发布博客于 29 天前

请你讲讲分布式系统中的限流器一般如何实现?

限流器相关算法一般限流器有五种算法,分别是:令牌桶,漏斗桶,固定窗口,滑动日志(指的其实是广义上的滑动窗口),滑动窗口(这里指的是滑动日志+固定窗口结合的一种算法)。1. 令牌桶(Token bucket)令牌桶算法用来控制一段时间内发送到网络上的数据的数目,并允许突发数据的发送。算法大概是: 假设允许的请求速率为r次每秒,那么每过1/r秒就会向桶里面添加一个令牌。桶的最大大小是b。当一个大小为n的请求到来时,检查桶内令牌数是否足够,如果足够,令牌数减少n,请求通过。不够的话就会触发拒绝策略。令
原创
1704阅读
0评论
0点赞
发布博客于 1 月前

请你尽量全面的说一个对象在 JVM 内存中的结构?

从 Java 14 开始,Project Valhala引入了 Value Type(或者称为 inline type),参考: Valhalla: https://openjdk.java.net/projects/valhalla/ ,这里不讨论 Value Type 也就是 record 类型。首先,Java 对象在堆内存内存中结构包括:类型指针: 一个指向类信息的指针,描述了对象的类型。标记字(Mark Word): 一组标记,描述了对象的状态,包括对象散列码(如果有)、对象的形状(是否是
原创
10892阅读
0评论
0点赞
发布博客于 2 月前

请你谈谈为什么分布式系统需要限流器

什么是限流器?限流器是一种限制某种操作在一定时间内的执行次数(例如每秒钟5次)或者执行量(例如每秒钟1G大小的数据)的机制。限流器是一种防御性的编程实现方式,在大数据量高并发访问时,经常会出现服务或接口面对暴涨的请求而不可用的情况,甚至引发连锁反映导致整个系统崩溃。此时你需要使用的技术手段之一就是限流,当请求达到一定的并发数或速率,就进行等待、排队、降级、拒绝服务等。为什么需要限流器在一个大型的分布式系统,系统设计要考虑很多很多方面:系统动态扩容缩容,总会有滞后性。业务总会有高峰有低谷。集群大小
原创
10729阅读
0评论
0点赞
发布博客于 2 月前

急~为啥我指定的的maven依赖版本没有生效?不是最短路径原则吗?

女朋友他们项目用了 spring-boot,以 spring-boot-parent 作为 parent:<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.9</version></parent>女
原创
12093阅读
1评论
0点赞
发布博客于 2 月前

90% 的 Java 程序员都说不上来的为何 Java 代码越执行越快(1)- JIT编译优化

麻烦大家帮我投一票哈,谢谢经常听到 Java 性能不如 C/C++ 的言论,也经常听说 Java 程序需要预热,那么其中主要原因是啥呢?面试的时候谈到 JVM,也有很多面试官喜欢问,为啥 Java 程序越执行越快呢?一般人都能回答上来,类加载,缓存预热等等,但是深入下去,最重要的一点却没有答上来,今天本篇文章就来帮助大家理解这个问题的关键。首先,我们从一个简单的例子看起,来感受下程序是否越来越快:package com.test;import java.util.concurrent.Ti.
原创
11306阅读
0评论
1点赞
发布博客于 2 月前

感谢大家之前的建议,最后选用了 draw.io 作为画图软件,感觉好多了,嘻嘻

发布Blink于 2 月前

Spring Cloud系列之Commons - 2. 服务发现 - 如何通过配置文件配置服务实例?

Spring Cloud Commons 主要包括如下模块的接口和默认实现:其中的限流策略以及重试策略是没有天然带的,但是其他模块的实现一般会带上这些功能。我们先从服务发现相关接口开始分析服务发现相关核心接口DiscoveryClientDiscoveryClientpublic interface DiscoveryClient extends Ordered { int DEFAULT_ORDER = 0; //描述 String description(); //通过
原创
11897阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - 下面这个 maven 依赖,我们有两个一样的依赖,但是不同的版本,最后项目会依赖哪个版本呢?

下面这个 maven 依赖,我们有两个一样的依赖,但是不同的版本,最后项目会依赖哪个版本呢答案是 28.2-jre,相同依赖不同版本,以最后的为准,依赖会被替换。验证:
原创
12036阅读
0评论
1点赞
发布博客于 2 月前

做专家?还是做企业家?

发布Blink于 2 月前

每日一面 - 假设 Redis 基本可靠,如何用单进程 Redis 实现分布式悲观锁

麻烦大家帮我投一票哈,谢谢什么是分布式锁针对共享内存模型的程序(例如JAVA程序),锁就是一个非常常用的机制。一般简单分为悲观锁和乐观锁。悲观锁就是你获取这块数据的锁之后,别人就无法访问或操作这块数据,直到你释放这个锁。乐观锁一般就是CAS更新。在单进程内内存的锁,只控制进程内数据的,就是非分布式锁。相反的,跨进程,需要锁住多个进程访问数据的锁就是分布式锁。悲观锁一般由Redis的SETNXEX实现,Key 为资源名,EX 设置一个合理的超时时间, Value 设置为一个客户端生成的在超时时间.
原创
12527阅读
0评论
1点赞
发布博客于 2 月前

知乎上收到这个回复,不太明白其中的意思,双层JIT优化应该说的是C1C2吧,对于 JVM 很感兴趣,业余研究下,可能真的有些误解,请大家多多帮忙指正哈: https://www.zhihu.com/question/440744426/answer/1693319892

发布Blink于 2 月前

知乎上收到这个回复,不太明白其中的意思,双层JIT优化应该说的是C1C2吧,对于 JVM 很感兴趣,业余研究下,可能真的有些误解,请大家多多帮忙指正哈: https://www.zhihu.com/question/440744426/answer/1693319892

发布Blink于 2 月前

每日一面 - 聊一聊Java为何需要平衡方法调用与内联

在 Java 中,方法调用一般通过 Virtual Call 还有 Classic Call。Classic Call 就是直接指向方法的地址,需要一次寻址到方法的地址,比直接执行代码慢。Virtual Call 需要通过 VMT(Virtual Method Table)。这个VMT存储的是该class对象中所有的Virtual Method,程序运行的时候首先加载实例对象,然后通过实例对象找到VMT,通过VMT再找到对应的方法地址,再执行代码。所以比 Classic Call 更慢。Java 中除
原创
12530阅读
0评论
0点赞
发布博客于 2 月前

每日一面 - java里的wait()和sleep()的区别有哪些?

一句话总结:sleep方法是当前线程休眠,让出cpu,不释放锁,这是Thread的静态方法;wait方法是当前线程等待,释放锁,这是Object的方法。同时要注意,Java 14 之后引入的 inline class 是没有 wait 方法的Sleep()原理public static native void sleep(long millis) throws InterruptedException;sleep()是Thread中的static方法,也是native实现。就是调用底层的 sleep
原创
12785阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - 求与数字最接近的 2 的 N 次方

对于 2 的 N 次方取余,相当于对 2 的 N 次方减一取与运算,这对于高并发分片计算的时候,很有用。为了对用户友好,我们让用户设置分片数量的时候可能不限制必须是 2 的 N 次方,但是内部我们设置分片的时候,将其设置为最近用户输入数字的 2 的 N 次方的值即可。那么如何计算呢?抽象为比较直观的理解就是,找一个数字最左边的 1 的左边一个 1 (大于 N 的最小的 2 的 N 次方),或者是最左边的1(小于N的最大的2的N次方),前提是这个数字本身不是2的n次方。那么,如何找呢?一种思路是,将这个
原创
12717阅读
0评论
1点赞
发布博客于 2 月前

想问问大家平常是怎么画这种图的呢?求推荐哈,我这写文章配图感觉画的很low

发布Blink于 2 月前

每日一面 - 为何我们经常使用 2 的 N 次方作为分片数量?

分片算法经常是计算一个值之后,对于分片个数取模,计算到底使用哪个分片。我们经常看到很多地方高性能的代码设计,都是将分片数量设置为 2 的 N 次方。例如 ForkJoinPool 的任务队列 WorkQueue 的大小,MyCat 的某些分片算法在计算分片的时候对于分片数量如果是 2 的 N 次方也有优化,那么为什么呢?对于 2 的 N 次方取余,相当于对 2 的 N 次方减一取与运算, N 为正整数。为什么呢?通过下图就能很容易理解:十进制中,对于 10 的 N 次方取余,直观来看就是:其实就是将
原创
12973阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - Spring Boot 中的 ApplicationContext 的分层是什么意思?

ApplicationContext 是 spring 用来容纳管理 beans 以及其生命周期的容器。ApplicationContext 的分层规定了bean的界限以及可以复用的 bean。关于 ApplicationContext 层级可以参考官方文档(http://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#howto-build-an-application-context-hierarchy),这里我们通过一个简单的
原创
12635阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - MySQL 大表添加一列

问题参考自: https://www.zhihu.com/question/440231149 ,mysql中,一张表里有3亿数据,未分表,要求是在这个大表里添加一列数据。数据库不能停,并且还有增删改操作。请问如何操作?答案为个人原创以前老版本 MySQL 添加一列的方式:ALTER TABLE 你的表 ADD COLUMN 新列 char(128);会造成锁表,简易过程如下:新建一个和 Table1 完全同构的 Table2对表 Table1 加写锁在表 Table2 上执行 ALTE.
原创
12471阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - mysql 大表批量删除大量数据

问题参考自:https://www.zhihu.com/question/440066129/answer/1685329456 ,mysql中,一张表里有3亿数据,未分表,其中一个字段是企业类型,企业类型是一般企业和个体户,个体户的数据量差不多占50%,根据条件把个体户的行都删掉。请问如何操作?答案为个人原创假设表的引擎是 Innodb, MySQL 5.7+删除一条记录,首先锁住这条记录,数据原有的被废弃,记录头发生变化,主要是打上了删除标记。也就是原有的数据 deleted_flag 变成 1.
原创
12278阅读
0评论
1点赞
发布博客于 2 月前

Spring Cloud系列之Commons - 1. 背景与基础知识准备

本文基于 Spring Cloud 2020.0 发布版的依赖本系列会深入分析 Spring Cloud 的每一个组件,从Spring Cloud Commons这个 Spring Cloud 所有元素的抽象说起,深入设计思路与源码,并结合实际使用例子深入理解。本系列适合有一定 Spring 或者 Spring Boot 使用经验的人阅读。什么是Spring Cloud CommonsSpring Cloud框架包括如下功能:分布式多版本配置管理服务注册与发现路由微服务调用负载均衡断.
原创
15933阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - 什么是 Safepoint?

我们先来设想下如下场景:当需要 GC 时,需要知道哪些对象还被使用,或者已经不被使用可以回收了,这样就需要每个线程的对象使用情况。对于偏向锁(Biased Lock),在高并发时想要解除偏置,需要线程状态还有获取锁的线程的精确信息。对方法进行即时编译优化(OSR栈上替换),或者反优化(bailout栈上反优化),这需要线程究竟运行到方法的哪里的信息。对于这些操作,都需要线程的各种信息,例如寄存器中到底有啥,堆使用信息以及栈方法代码信息等等等等,并且做这些操作的时候,线程需要暂停,等到这些操作完成
原创
12242阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - JVM 何时会 Stop the world

定时进入 SafePoint:每经过-XX:GuaranteedSafepointInterval 配置的时间,都会让所有线程进入 Safepoint,一旦所有线程都进入,立刻从 Safepoint 恢复。这个定时主要是为了一些没必要立刻 Stop the world 的任务执行,可以设置-XX:GuaranteedSafepointInterval=0关闭这个定时,我推荐是关闭。由于 jstack,jmap 和 jstat 等命令,也就是 Signal Dispatcher 线程要处理的大部分命令,都.
原创
12250阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - 限制用户设备

问题参考自:https://www.zhihu.com/question/439438146 ,答案为个人原创用户登录,保存30天的免登,只允许两个设备登录,如果有第三个设备登录,踢掉第一个。改密码的时候,所有设备需要下线。这个逻辑怎么实现呢?使用 Redis 存储用户 ,登录的设备实现,利用 ZSET。存储结构如下:每个用户一个 ZSET(假设就是以用户 id 作为 ZSET 的 KEY),里面的 KEY 为设备 id,value 为登录时间戳。当用户登录时,使用 lua 脚本(防止并发导.
原创
12222阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - Spring 的 @Import 注解的作用与用法

@Import注解@Import是Spring基于 Java 注解配置的主要组成部分。@Import注解提供了@Bean注解的功能,同时还有原来Spring基于 xml 配置文件里的<import>标签组织多个分散的xml文件的功能,当然在这里是组织多个分散的@Configuration的类。下面将分别说明@Import注解的功能。1. 引入其他的@Configuration假设有如下接口和两个实现类:package com.testinterface ServiceInterfac
原创
12225阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - JVM 类型字压缩指针与 JVM 最大内存有何关系?

压缩指针这个属性默认是打开的,可以通过-XX:-UseCompressedOops关闭。首先说一下为何需要压缩指针呢?32 位的存储,可以描述多大的内存呢?假设每一个1代表1字节,那么可以描述 0~2^32-1 这 2^32 字节也就是 4 GB 的内存。但是呢,Java 默认是 8 字节对齐的内存,也就是一个对象占用的空间,必须是 8 字节的整数倍,不足的话会填充到 8 字节的整数倍。也就是其实描述内存的时候,不用从 0 开始描述到 8(就是根本不需要定位到之间的1,2,3,4,5,6,7)因为对象
原创
12202阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - MySQL 的双一设置是什么?

问题参考自:https://www.zhihu.com/question/425704691/answer/1524724367 ,答案为个人原创其实就是innodb_flush_log_at_trx_commit和sync_binlog两个参数设置,都设置为 1 就是双 1 设置。MySQL 默认配置就是双 1 配置。innodb_flush_log_at_trx_commit 是 innodb 引擎的配置,sync_binlog 是 MySQL 引擎上层的配置,都是控制磁盘写入策略。MySQL.
原创
14015阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - JVM 内存一般包括什么?

我们一般通过两个工具 pmap 还有 jcmd 中的 VM.native_memory 命令去查看 Java 进程内存占用,由于 pmap 命令有点复杂而且很多内存映射是 anon 的,这里采用 jcmd 中的 VM.native_memory 命令,去看一下 JVM 内存的每一部分。Native Memory Tracking:Total: reserved=6308603KB, committed=4822083KB- Java Heap (reserved=41
原创
12217阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - sqrt (2)约等于 1.414,如何求sqrt (2)小数点后 10 位

本问题参考自:https://www.zhihu.com/question/410210858/answer/1365984008 答案为个人原创1.从 1.414 向下一位开始,二分法查找平方最接近2的数字。效率比较差。2.使用牛顿迭代法:x初始等于1.414不断令x等于x和2/x的平均数,然后求每次x的平方,看与2的差距这样比之前的二分法要精简很多次运算。这种算法的原理很简单,我们仅仅是不断用(x,f(x))的切线来逼近方程x^2-a=0的根。根号a实际上就是x^2-a=0的一个正.
原创
12290阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - 为何hashmap默认的负载因子是0.75?应该是空间和时间的折中,背后的统计原理是什么呢?

1. 为啥需要 负载因子(defaultLoadFactor)现在主流的 HashMap,一般的实现思路都是开放地址法+链地址法的方式来实现。即数组 + 链表的实现方式,通过计算哈希值,找到数组对应的位置,如果已存在元素,就加到这个位置的链表上。在 Java 8 之后,链表过长还会转化为红黑树。红黑树相较于原来的链表,多占用了一倍的空间,但是查询速度快乐一个数量级,属于空间换时间。 同时,链表转换红黑树也是一个耗时的操作。并且,一个效率高的哈希表,这个链表不应该过长。所以,如果数组的很多元素上面已经
原创
12178阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - 从 innodb 的索引结构分析,为什么索引的 key 长度不能太长?

本问题参考: https://www.zhihu.com/question/410506694/answer/1368215298 ,答案为个人原创MySQL innoDB引擎索引基于 B+树,B+树有以下特点:图片参考自:链接每个节点中子节点的个数不能超过 N,也不能小于 N/2(不然会造成页分裂或页合并)根节点的子节点个数可以不超过 m/2,这是一个例外m 叉树只存储索引,并不真正存储数据,只有最后一行的叶子节点存储行数据。通过链表将叶子节点串联在一起,这样可以方便按区间查找同时,.
原创
17575阅读
1评论
1点赞
发布博客于 2 月前

每日一面 - mysql中,innodb表里,某一条数据删除了之后,这条数据会被真实的擦掉吗,还是删除了关系?

以 Compact 行格式为例:总结删除一条记录,数据原有的被废弃,记录头发生变化,主要是打上了删除标记。也就是原有的数据 deleted_flag 变成 1,代表数据被删除。但是数据没有被清空,在新一行数据大小小于这一行的时候,可能会占用这一行。这样其实就是存储碎片,要想减少存储碎片,可以通过重建表来实现(例如对于高并发大数据量表,除了归档,还可以通过利用无锁算法Alter修改字段来重建表增加表性能)。Compact 行格式存储我们来创建一个包含几乎所有基本数据类型的表,其他的例如 geometr
原创
12488阅读
0评论
1点赞
发布博客于 2 月前

我刚在知乎发布文章,这公众号就转载还标原创。你这公众号每日一更,是大部分都抄袭来的么????郭敬明于正都道歉了喂~~~~

发布Blink于 2 月前

每日一面 - Java OOM都有哪些,说出几种?

Key TakeAwaysStackOverflowError: 调用栈过深,导致线程栈占用大小超过-Xss(或者是-XX:ThreadStackSize)的限制OutOfMemoryError: Java heap space:堆内存不够用,无法分配更多内存,就会抛出这个异常。OutOfMemoryError: unable to create native thread:这个在创建太多的线程,超过系统配置的极限。如Linux默认允许单个进程可以创建的线程数是1024个。OutOfMemoryE
原创
12416阅读
0评论
1点赞
发布博客于 2 月前

通过 JFR 与日志深入探索 JVM - 调试 JVM 的工具 WhiteBox API

在之后的 JFR 事件学习以及调试的过程中,我们会经常用到 WhiteBox API 来触发 JVM 的一些机制或者临界点。例如强制 JVM 现在立刻进行 FullGC 等等。什么是 WhiteBox APIWhiteBox API 是 HotSpot VM 自带的白盒测试工具,将内部的很多核心机制的 API 暴露出来,用于白盒测试 JVM,压测 JVM 特性,以及辅助学习理解 JVM 并调优参数。WhiteBox API 是 Java 7 引入的,目前 Java 8 LTS 以及 Java 11 LT
原创
33360阅读
1评论
1点赞
发布博客于 2 月前

通过 JFR 与日志深入探索 JVM - TLAB JFR 相关事件与日志详解

全系列目录:通过 JFR 与日志深入探索 JVM - 总览篇上一篇我们详细的分析了 TLAB 的原理以及生命周期,并且提出 JFR 相关的两个事件:在线程分配对象时,如果 TLAB 不够,则根据最大允许浪费空间,决定是回收当前 TLAB 还是重新获取一个 TLAB 进行分配还是直接在堆上分配。jdk.ObjectAllocationOutsideTLAB 代表直接在堆上分配,jdk.ObjectAllocationInNewTLAB 代表回收+重新获取 TLAB 进行分配。我们也提到了,jdk.Ob.
原创
32965阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - mysql中,我存十亿个手机号码,考虑存储空间和查询效率,怎么设计?

问题参考自:https://www.zhihu.com/question/438078173,以下解答思路为个人原创首先提出假设:手机号码不会更新,只会插入和删除。查询包括精确查询某个手机号是否存在,以及获取某一号码段的所有手机号假设表只有一个字段,就是手机号 phone,并且设置为主键。如果不设置主键并且没有唯一索引,InnoDB 会给我们自动生成一个隐藏主键列,浪费空间。MyISAM or InnoDB如果插入和删除并不频繁,手机号是提前载入的字典表,而不是用户主动注册而产生的,则 .
原创
12491阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - mysql 的自增 id 的实现逻辑是什么样子的?

本问题参考自: https://www.zhihu.com/question/437916819/answer/1661679374, 解答为个人原创Key TakeAwaysInnoDB 引擎中 有三种 AutoIncrement 锁模式:innodb_autoinc_lock_mode=0(traditional lock mode):获取表锁,语句执行结束后释放innodb_autoinc_lock_mode=1(consecutive lock mode,MySQL 8.0 之前默认.
原创
12304阅读
0评论
2点赞
发布博客于 2 月前

每日一面 - Redis程序设计中,上百万的新闻,如何实时展示最热点的top10条呢

假设可以使用 MySQL,redis,本地缓存以及MQ。用户量级千万,新闻数据百万,用户数比新闻数还多。用户的操作包括:关注某个新闻获取某个新闻的关注数量获取 top10 热点新闻查询自己关注的新闻。可以推测,获取 top10 热点新闻请求会远大于关注某个新闻的请求。这些请求都不能直接压入数据库,数据库受不了。首先想到的是 Redis 中的 Zset,所有的新闻id作为key放入同一个zset中,用户关注某个新闻,使用 zincrby 给这个新闻分数 +1。读取 top 10的时候,用zr
原创
12625阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - java中LinkedTransferQueue和SynchronousQueue有什么区别?

LinkedTransferQueue 是一种 TransferQueue,SynchronousQueue 是一种 BlockingQueue。TransferQueue和BlockingQueueBlockingQueue 是一种阻塞队列,队列是有大小的。队列满的时候,生产者会阻塞。队列空的时候,消费者会阻塞。TransferQueue在BlockingQueue提供的方法基础上,增加了 transfer 方法,就是只有生产者的消息被消费之后,才返回,否则继续阻塞。SynchronousQueu
原创
12222阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - java中,描述一下什么情况下,对象会从年轻代进入老年代?

本问题参考自: https://www.zhihu.com/question/437632685, 解答为个人原创Key TakeawayJava 默认启用了分代 GC启用分代 GC 的,在发生 Young GC,更准确地说是在 Survivor 区复制的时候,存活的对象的分代年龄会加1。当分代年龄 = -XX:MaxTenuringThreshold 指定的大小时,对象进入老年代还有动态晋升到老年代的机制,首先根据 -XX:TargetSurvivorRatio (默认 50,也就是 50.
原创
17070阅读
0评论
1点赞
发布博客于 2 月前

每日一面 - java中,MinorGC、MajorGC、FullGC 什么时候发生?

引用自: https://www.zhihu.com/question/437493648/answer/1656737915MinorGC 一般指清理 Young space (Eden and Survivor spaces) 的 GC。例如 G1GC 还有 ShenandoahGC 中的 YoungGC. 触发一般是:Allocation Failure: 分配对象失败,空间不足. 内存分配流程,涉及到了 bump-the-pointer, TLAB,Allocation Prematch.
原创
33688阅读
1评论
2点赞
发布博客于 2 月前

JVM 相关 - 深入 JVM 的钥匙 WhiteBox API

什么是 WhiteBox APIWhiteBox API 是 HotSpot VM 自带的白盒测试工具,将内部的很多核心机制的 API 暴露出来,用于白盒测试 JVM,压测 JVM 特性,以及辅助学习理解 JVM 并调优参数。WhiteBox API 是 Java 7 引入的,目前 Java 8 LTS 以及 Java 11 LTS(其实是 Java 9+ 以后的所有版本,这里只关心 LTS 版本,Java 9 引入了模块化所以 WhiteBox API 有所变化)都是有的。但是默认这个 API 并没有编
原创
34101阅读
0评论
1点赞
发布博客于 2 月前

2020年度总结 - 不断尝试与反思的一年

2020,转眼间就过去了。这一年,不论是技术上还是生活上,都成长很多,并做了很多之前没有做过的事情。和心爱的人终于要修成正果今年下半年,七夕那天和宝宝求婚。后来 9.25 终于和宝宝在韩国艺匠拍了婚纱照,宝宝和我都很满意。明年如果疫情不影响的话,应该五月份就会和宝宝举办婚礼,期待~跟着创业业务趋于稳定去年离开了网易,开始创业。受上半年疫情影响,导致创业本来的爆发增长期推后了半年左右,幸好老大他们运作得当,保证了各位员工的待遇的前提下,维持业务正常运行。现在业务终于可以够我们活下去的了,公司搬了新
原创
34495阅读
2评论
3点赞
发布博客于 2 月前

通过 JFR 与日志深入探索 JVM - 2. JFR 基本原理以及快慢因素

全系列目录:通过 JFR 与日志深入探索 JVM - 总览篇我个人有个习惯,对于要用的一个新的框架,新的中间件等等,我一般不太信任它的官网“吹”的优点以及性能测试,我一般会一边使用一边自己测试,并且猜想其内部实现并结合源码搞清楚它的实现原理以及一些“坑”(这些“坑”并不是说这些框架或者中间件有什么毛病,而是因为官网浮夸的“吹”以及有些事情说一半留一半导致用户有误解),在这之后我才敢放心使用。所以呢,我想先将 JFR 实现的基本原理提前说明白,这样可以让大家先有个整体印象,搞明白为何这么配置就对线上 .
原创
34248阅读
0评论
1点赞
发布博客于 2 月前

通过 JFR 与日志深入探索 JVM - 1. JFR 简介与发展

什么是 Java Flight Record我们都知道,黑匣子是用于记录飞机飞行和性能参数的仪器。在飞机出问题后,用于定位问题原因。JFR(Java Flight Record) 就是 Java 的黑匣子。JFR 是 Java Flight Record (Java飞行记录) 的缩写,是 JVM 内置的基于事件的JDK监控记录框架。这个起名就是参考了黑匣子对于飞机的作用,将 Java 进程比喻成飞机飞行。顾名思义,这个记录主要用于问题定位和持续监控。在线上出问题时,我们一般首要任务是快速恢复,而不是保
原创
33894阅读
1评论
1点赞
发布博客于 2 月前

通过 JFR 与日志深入探索 JVM - 总览篇

本系列会针对 Java 中高级开发人员以及 JVM 运维人员,帮助大家深入理解 JVM 原理并能学以致用定位线上瓶颈,线上性能问题以及长期持续监控 JVM 。本系列针对 OpenJDK 11 以后的版本,同时也会帮助用户升级到 OpenJDK 11。本专栏会从快速上手 JFR,可视化查看 JFR 引入,之后会详细分析每一个 JFR 事件对应的背后的 JVM 原理以及源码,并且结合 Java 测试代码生成这些 JFR 事件帮助大家更好的理解这些事件产生的原因,以及需要如何去优化,然后会给出一下通过 JFR 定
原创
33928阅读
1评论
3点赞
发布博客于 2 月前

通过 JFR 与日志深入探索 JVM - TLAB 原理详解

什么是 TLAB?TLAB(Thread Local Allocation Buffer)线程本地分配缓存区,这是一个线程专用的内存分配区域。既然是一个内存分配区域,我们就先要搞清楚 Java 内存大概是如何分配的。我们一般认为 Java 中 new 的对象都是在堆上分配,这个说法不够准确,应该是大部分 new 的对象在堆上分配。还有一部分可能在 栈上分配 或者是 TLAB 中分配。同时,对于一些的 GC 算法,还可能直接在老年代上面分配,例如 G1 GC 中的 humongous allocation
原创
40028阅读
5评论
3点赞
发布博客于 2 月前

微服务系统架构设计系列 - RateLimiter - 1. 限流器简介与一般算法

Key TakeAways限流器是一种防御性的编程实现方式,防止一个大型的分布式系统在不可预知的大流量到来的时候导致系统大规模故障。限流器可以设置在服务端,主要为了限制资源的使用。放在客户端主要考虑调用压力更加均匀。一般限流器有五种算法,分别是:令牌桶,漏斗桶,固定窗口,滑动日志(指的其实是广义上的滑动窗口),滑动窗口(这里指的是滑动日志+固定窗口结合的一种算法)。什么是限流器?限流器是一种限制某种操作在一定时间内的执行次数(例如每秒钟5次)或者执行量(例如每秒钟1G大小的数据)的机制。哪里会用
原创
12359阅读
2评论
0点赞
发布博客于 2 月前

深度探索JFR - JFR定位线上问题实例 - JFR导致的雪崩问题定位与解决

最近发现一个应用,使用默认的 JFR 配置,发生了类似于雪崩的现象,这里记录下,引以为戒。Key takeawaysJFR 的线程堆栈 dump 采集默认周期是everyChunk,也就是每次新建一个Chunk就会采集一次。默认每个Chunk大小为 12M,在线程比较多的时候,堆栈 dump 可能大于 12M,导致 JFR 一直切换新的 Chunk,然后又触发evenryChunk导致无限循环而雪崩。对于 JFR 默认事件采集配置(位于JDK目录/lib/jfr/default.jfc),每个采.
原创
33822阅读
0评论
1点赞
发布博客于 3 月前

JVM相关 - StackOverflowError 与 OutOfMemoryError

本文基于 Java 15StackOverflowError 与 OutOfMemoryError 是两个老生常谈的 Java 错误。Java 中的虚拟机错误 VirtualMachineError 包括以下四种:我们比较关心的就是 StackOverflowError 与 OutOfMemoryError,剩下的 InternalError 一般是内部使用错误,UnknownError 是虚拟机发生未知异常,这两种我们这里不讨论。虚拟机规范中的 StackOverflowError 与 Out.
原创
338阅读
0评论
1点赞
发布博客于 4 月前

JFR 定位因为 SSL 导致 CPU Load 飚高的问题

问题场景在某一时刻,某个微服务的某个实例 CPU 负载突然飚高:同时建立了很多数据库链接:其他实例没有这个现象。问题定位由于建立了很多数据库链接,猜想可能是数据库比较慢,查看数据库这段时间的 SQL 统计,发现数据库并不慢:其中这个微服务这段时间的热点 SQL,执行并不慢。那么问题出在了哪里呢?可能是由于 GC,可能是由于 safepoint,还有可能是获取锁时间过长(参考:Java 监控 JFR全解),我们 dump 一下 JFR 并查看其中的 safepoint,GC 以及 Monit
原创
13771阅读
0评论
0点赞
发布博客于 5 月前

分布式系统设计模式 - 预写日志(Write Ahead Log)

原文地址:https://martinfowler.com/articles/patterns-of-distributed-systems/wal.htmlWrite-Ahead log 预写日志预写日志(WAL,Write-Ahead Log)将每次状态更新抽象为一个命令并追加写入一个日志中,这个日志只追加写入,也就是顺序写入,所以 IO 会很快。相比于更新存储的数据结构并且更新落盘这个随机 IO 操作,写入速度更快了,并且也提供了一定的持久性,也就是数据不会丢失,可以根据这个日志恢复数据。背.
原创
188阅读
0评论
0点赞
发布博客于 5 月前

分布式系统设计模式 - 最低水位线(Low-Water Mark)

最低水位线(Low-Water Mark)最低水位线是指在 WAL(Write Ahead Log)预写日志这种设计模式中,标记在这个位置之前的日志可以被丢弃。问题背景WAL(Write Ahead Log)预写日志维护了对于存储的每次更新,随着时间不断增长,这个日志文件会变得无限大。Segmented Log 分割日志这种设计模式可以让我们每次只处理一个更小的文件,但是日志如果不清理,会无休止增长以至于硬盘被占满。解决方案最低水位线这种设计模式会告诉系统哪一部分的日志可以被删除了,即在最低水位线
原创
221阅读
0评论
0点赞
发布博客于 5 月前

分布式系统设计模式 - 分割日志(Segmented Log)

分割日志(Segmented Log)将大文件切分为更容易处理的多个更小的文件。问题背景单一的日志文件可能会增长到很大,并且在程序启动时读取从而成为性能瓶颈。老的日志需要定时清理,但是对于一个大文件进行清理操作很费劲。解决方案将单一日志切分为多个,日志在达到一定大小时,会切换到新文件继续写。//写入日志public Long writeEntry(WALEntry entry) { //判断是否需要另起新文件 maybeRoll(); //写入文件 return
翻译
126阅读
1评论
1点赞
发布博客于 5 月前

JDK核心JAVA源码解析(9) - hashcode 方法

本文基于 OpenJDK 11, HotSpot 虚拟机在开发过程中我们可能会经常接触到hashcode这个方法来生成哈希码,那么底层是如何实现的?使用时有何注意点呢?hashcode() 方法底层实现hashcode()是Object的方法:@HotSpotIntrinsicCandidatepublic native int hashCode();它是一个native的方法,并且被@HotSpotIntrinsicCandidate注解修饰,证明它是一个在HotSpot中有一套高效的实.
原创
179阅读
0评论
0点赞
发布博客于 5 月前

Java GC详解 - 1. 最全面的理解Java对象结构 - 对象指针 OOPs

最近在抽时间阅读 JDK 的源码,主要是 GC 还有 Safepoint 相关的源码,发现很多我在之前拜读网上各种 JVM 原理大作时候的对于底层原理的误解。果然,一百个人读水浒传,就有一百种水浒传。还是需要更加深入的了解下源码,才能更好地理解 JVM,进行调优。这个系列,将在讲述 Java GC 各种原理的基础上,结合对应的源码分析,并附上源码地址。因为JVM的源码更新还是很快的,尤其是 GC 这一块,但是基本原理,应该大体不会变,附上源码地址,旨在让各位读者掌握这些原理最新实现情况。本文在撰写的时候,.
原创
233阅读
2评论
3点赞
发布博客于 5 月前

Project Reactor 深度解析 - 2. 响应式编程调试,FLow的概念设计以及实现

响应式编程的首要问题 - 不好调试我们在分析传统代码的时候,在哪里打了断点,就能看到直观的调用堆栈,来搞清楚,谁调用了这个代码,之前对参数做了什么修改,等等。但是在响应式编程中,这个问题就很麻烦。来看下面的例子。public class FluxUtil1 { public static Flux<Integer> test(Flux<Integer> integerFlux) { return FluxUtil2.test2(integerFlux.ma
原创
13636阅读
0评论
0点赞
发布博客于 7 月前

HashMap 的 defaultLoadFactor 的一种推导计算思路

1. 为啥需要 defaultLoadFactor现在主流的 HashMap,一般的实现思路都是开放地址法+链地址法的方式来实现。即数组 + 链表的实现方式,通过计算哈希值,找到数组对应的位置,如果已存在元素,就加到这个位置的链表上。在 Java 8 之后,链表过长还会转化为红黑树。红黑树相较于原来的链表,多占用了一倍的空间,但是查询速度快乐一个数量级,属于空间换时间。 同时,链表转换红黑树也是一个耗时的操作。并且,一个效率高的哈希表,这个链表不应该过长。所以,如果数组的很多元素上面已经有值了,那么
原创
2308阅读
1评论
3点赞
发布博客于 7 月前

Project Reactor 深度解析 - 1. 响应式编程介绍,实现以及现有问题

现在, Java 的各种基于 Reactor 模型的响应式编程库或者框架越来越多了,像是 RxJava,Project Reactor,Vert.x 等等等等。在 Java 9, Java 也引入了自己的 响应式编程的一种标准接口,即java.util.concurrent.Flow这个类。这个类里面规定了 Java 响应式编程所要实现的接口与抽象。我们这个系列要讨论的就是Project Reactor这个实现。这里也提一下,为了能对于没有升级到 Java 9 的用户也能兼容,java.util.conc
原创
9951阅读
0评论
2点赞
发布博客于 7 月前

Spring Cloud升级之路 - Hoxton - 10. 网关重试带Body的请求Body丢失的问题

带 Body 的重试 Body 丢失之前我们的配置里面,只对 Get 请求针对 500 响应码重试,但是针对像 Post 这样的请求,只对那种根本还没到发送 Body 的阶段的异常(例如连接异常)这种重试,那么如果我们要对带 Body 的 Post 进行重试呢?或者就是用 Postman 构建一个带 Body 的 Get 请求,重试是否正常呢?我们启动之前第6节的 EurekaServer,修改/test-exception-thrown接口,增加 RequestBody 参数:@RequestMap
原创
9733阅读
0评论
0点赞
发布博客于 7 月前
The RetryGatewayFilterFactory should regenerate body Flux · Issue #1861 · spring-cloud/spring-cloud-gateway · GitHub
发布Blink于 7 月前

哈哈,看到这篇漫画,想起了去年在公司接手新项目,推广 OpenJDK 11,当时大家都用的是 Java 8,都没有接触过 Java 11.身为一群技术宅,趁着新项目,做一回第一个吃螃蟹的人,哈哈。 当然,敢于做第一个吃螃蟹的人,是在保证这个螃蟹不会只在概念层面上好吃的。首先 OpenJDK 11 是一个 LTS 版本,这给了不少信心。并且发布有一段时间了,社区很活跃,出的 Bug 基本上都是在一周内解决。还有重要的一点,JFR 监控。这个特性是我们一直想要的线上低消耗持续全面的监控特性。 于是,在我们项目组的不断努力下,基于 OpenJDK 11 的我们的应用成功上线并运行了一年多了。并且在这期间还做了 Spring Cloud 等基础框架的升级。

发布Blink于 7 月前