我的学习:一个人的精神发育史就是他的阅读史
我的研究方向有四大类:技术,投资,健康,国学。
主要是四个目标:立身,资产配置,活的长久,获取智慧。
技术占比40%,金融占比20%,健康占比30%,国学占比10%。
目标:为读万卷书而奋斗,为解放思想而探求!
学习的指导思想:学以致用。
该项目创建于2022-04-05,但内容涉及到大学期间(2011-2015)~至今的读书笔记,内容在Github地址 维护。
主要用于汇总技术笔记,阅读笔记,好的资料,用于形成知识体系,也是探索知识管理的实践。该项目最大特色是通过英文搜索(mdbook暂时不支持中文,中文暂时直接仓库中搜索)来检索自己的知识库,从而形成打通知识脉络。
书的类别主要分为:技术和社科,技术主要是技术书和论文,社科则没有严格限制。
读书笔记模版
# 书名
作者:
分类:
相关书籍:
## 进度
阅读记录:开始时间:YYYY-MM-dd ~ 结束时间:YYYY-MM-dd
阅读页数:
# 内容
## 整体结构
## 摘要
## 纲要
## 笔记
## 读后感
## 书评
# 参考
方法论探索
认知系统:如何读书,如何思考,思维模式(系统思维,模型思维,结构化思维,格栅思维等等),学习方法,记忆力,卡片笔记,思维导图,快速阅读,费曼学习法,演讲,写作等。
学习系统:个人的。
技术学习模型:COSEA模型
当前研究
2024技术研究
2024-01~2024-02
openai,llm:目标自己完成一个模型的构建和知识型问答机器人
golang
opentelemetry
向量数据库,向量检索算法,相似性算法
阅读目标
学习四大方向:技术,投资,健康,国学。
技术:主要是JAVA/Golang/互联网技术,主要是这些书籍
投资:金融投资,经济学,投资学
健康:饮食,疾病,医学类
国学:四书五经,孙子兵法,道德经,金刚经,纲鉴易知录,史记,资治通鉴,三国演义,水浒传
2023年读书计划
技术读完:主要是重读之前的一些书,加深理解。高性能MySQL/MySQL技术内幕(SQL和InnoDB)/数据库系统内幕,Redis设计与实现/Redis实战,Kafka权威指南,Elasticsearch权威指南/深入理解ElasticSearch,Java并发编程实战/Effective Java/深入理解JVM,DDIA/深入理解分布式系统/分布式系统与一致性。
金融学读完:彼得林奇3本(战胜华尔街,彼得·林奇教你理财,彼得·林奇的成功投资),西格尔2本(股市长线法宝,投资者的未来),马尔基尔1本(漫步华尔街),埃利斯2本(投资的常识,赢得输家的游戏),约翰·博格2本(共同基金常识,长赢投资),霍华德马克斯2本(投资最重要的事,周期)。
经济学读完:米什金的货币金融学,曼昆经济学原理上下册,博迪的投资学。
健康读完:食物营养与配餐第二版(范志红),你是你吃出来的两本,中国居民膳食指南(科普版+详细版),顾中一两本,营养圣经,吃出自愈力,精准营养,公共营养师,居民膳食营养素参考摄入量。
国学读完:道德经,金刚经,孙子兵法
2024读书计划
技术读完:主要是重读之前的一些书,加深理解。高性能MySQL/MySQL技术内幕(SQL和InnoDB)/数据库系统内幕,Redis设计与实现/Redis实战,Kafka权威指南,Elasticsearch权威指南/深入理解ElasticSearch,Java并发编程实战/Effective Java/深入理解JVM,DDIA/深入理解分布式系统/分布式系统与一致性。
金融学读完:
健康读完:
国学读完:儒释道的十三经
阅读记录
正在阅读
股市长线法宝
2023年
书名 | 作者 | 阅读时间 | 阅读情况 | 读书笔记 |
---|---|---|---|---|
股市长线法宝 | 杰里米 J. 西格尔 | 2023-10-10 | 阅读中 | |
技术简介
该技术学习框架创立于在网易工作期间,受益于组内完整的技术框架+优秀的封装技术。
我的技术笔记 Github地址:https://github.com/xiaozhiliaoo/courseop-tech-learning,也即知识管理的实践。
受 lvt4j 启发与借鉴而创立该项目。
笔记优于英文写作,因为英文方便搜索。
基础学习: 通读官方文档,相关论文,熟悉API。
拔高学习: 核心设计,接口,机制,流程,抽象等。
学习指导思想
- 实践优于理论。理论保证正确,精确。
- 整体优于局部。一个技术,全面了解优于技术细节/原理。因为这样才会产生知识/系统间更大关联。这里整体不是广度和深度的选择,而是对事物的整体认识。对于一个系统,有其分布式特性,或者数据模型特性,在谈分布式特性时候,就要站在分布式体系下去认识,而不能站在数据模型上说分布式特性就是“底层”或“原理”。
- 英语优于汉语。汉语会阻碍一个技术的认知。
- 注重历史。技术的历史,从头到位去了解。
- 思考优于知识。知识是知道,不代表你会这么想问题。虽然这么想了,但是不对。没有高质量知识思考也会质量很低。
技术关键字
Akka:Reactive Architecture
Kafka:Streaming Processing Platform
SMACK:Spark/Mesos/Akka/Cassandra/Kafka
学习进度
技术 | 进度 |
---|---|
Akka | https://doc.akka.io/docs/akka/current/mailboxes.html |
Es | https://www.elastic.co/guide/cn/elasticsearch/guide/current/full-text-search.html |
Kafka | https://developer.confluent.io/patterns/ |
Spring | https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-autowire |
技术栈
技术学习
Coding
admin
common-design
需要给业务层提供通用类库,该以怎么样的方式提供?通常有以下几种方式:
1.类似于apache common这种模式,应用层调用库。
2.类似于Spring boot stater+auto-configuration这种模式。
3.类似于IOC/框架模式/模板(XXXTemplate)/策略(回调)模式,框架调用应用层代码。典型的如JDBCTemplate.
4.类似于普通Spring模式,提供库,并且暴露配置且提供默认配置,由应用层自定义设置。
common-elasticsearch
Akka
lightbend-academy
reactive programming vs reactive system vs reactive architecture
Reactive Programming doesn't mean you have created a Reactive System
Reactive System: Reactive Microservice
A system that uses Reactive Programming is not necessarily Reactive.
Location Transport VS Transport Remoting
Reactive Architecture:DDD,Lagom
Reactive Architecture + DDD = same goal
Many of the guidelines and rules in Domain Driven Design are compatible with those in Reactive Architecture.
Akka简介
Build powerful reactive, concurrent, and distributed applications more easily
Akka is a toolkit for building highly concurrent, distributed, and resilient message-driven applications for Java and Scala.
提供的新架构,解决方案
反应式架构,反应式系统,反应式编程
Reactive Systems Architecture
Reactive Architecture:LightBend
The primary goal of reactive architecture is to provide an experience that is responsive under all conditions.
unresponsive software
Lightbend=Akka+Play+Lagom
akka监控:https://www.lightbend.com/blog/akka-monitoring-telemetry
其他
Lightbend CEO Jonas Boner-blog
Jonas Boner's Book: Reactive Microservices Architecture Reactive Microsystems The Reactive Principles - Design Principles for Distributed Applications
foreword—reactive Messaging Patterns with the Actor Model - 《响应式架构》 foreword—reactive application development - 《反应式应用开发》 foreword—reactive design patterns - 《反应式设计模型》 foreword—functional and reactive domain modeling - 《函数响应式领域建模》
Readlist: http://jonasboner.com/books-that-makes-you-think/
My Repo
https://github.com/xiaozhiliaoo/akka-in-action.git
https://github.com/xiaozhiliaoo/akka-practice
https://github.com/xiaozhiliaoo/learning-akka.git
https://github.com/SalmaKhater/Learning-Akka
使用场景
可扩展的分布式内存数据库
Akka Actor
Progress
Notes
tell,do not ask!
发消息方法: tell(fire and forget) ask(get response) pub/sub
acotr单线程模型,并发安全
become 通过行为改变状态
当actor中出现futrue时候,可以使用pipeline,否则会打破单线程模式
akka,riak,cassandra
ActorRef,ActorPath,Actor Selection
Replace Actor stack behavior vid become/unbecome/FSM
Actor如果是计数器,那么需要持久化。Stateful Actor
Sender -> Command -> Actor -> Event -> DB
线上推荐akka cluster,而不是remote
Send messages:Tell:fire-forget,Ask:Send-And-Receive-Future
Forward message: useful when writing actors that work as routers, load-balancers, replicators etc.
Reference
https://doc.akka.io/docs/akka/current/actors.html#actor-lifecycle
Akka Remoting
Classic Remoting (Deprecated) -> Typed Artery Remoting
https://doc.akka.io/docs/akka/current/remoting.html
akka通信协议,序列化机制是什么?
Akka Http
akka-http收http://spray.io/启发
Akka http = Akka + Akka stream
Akka TestKit
Akka Stream
Akka Distributed Data
多点写入冲突解决: 具有中央节点的数据修改,也涉及CRDT,因为时间有先后,但是最终选哪一个也是问题。多节点更新,然后节点同步达到一致性时候,会有冲突。
除非所有写入本身就存储在一个中央节点,
akka生态至少把akka项目看完,lightbend生态
core
convergent(收敛)
集群中节点间复制简单的会话信息。ORSet Observer Remove Set
Related
https://github.com/lmdbjava/lmdbjava/wiki
paper: Delta State Replicated Data Types
Akka Cluster
学习进度
https://doc.akka.io/docs/akka/current/typed/cluster.html#
笔记
application membership(heartbeat, gossip)
CAP:
available(pick up consistency):membership,distributed data,pubsub,multi-dc support consistency:singleton,sharding,leases
stateful applications
集群单例生成唯一用户ID
Akka Persistent + Akka Singleton 生成唯一用户ID
计算集群总请求数。
发现资源不够,会自动扩展actor来处理任务,资源充足,会减少actor来处理任务
全局状态:集群单例actor实现
actor中有阻塞操作该怎么办?
如果一个分片挂了,那么akka cluster shard是如何处理任务的?
集群路由感知器比集群单例更通用的构造。一个actor可以将任务推给多个worker.
Classic Cluster Aware Router:https://doc.akka.io/docs/akka/current/cluster-routing.html
Akka Persistence
Classic Persistence:https://doc.akka.io/docs/akka/current/persistence.html#at-least-once-delivery
Notes
https://github.com/dnemov/akka-persistence-jdbc/blob/master/src/main/resources/schema/mysql/mysql-schema.sql
Akka Utilities
熔断器
https://doc.akka.io/docs/akka/current/common/circuitbreaker.html
let it crash. 从奔溃中恢复才是弹性系统应该具备的能力。
Book
Akka实战
Akka入门与实践
Akka应用模式
反应式设计模式
反应式应用开发
Progress
Notes
Akka的actor模型中,并没有提供因果一致性,因此落在了开发人员,需要通过Process Manager模式完成Become/Unbecome实现因果一致性。
反应式架构默认是分布式的。
Akka分片:跨集群中多个节点自动分布具有标识符的actor.
Question
消息,命令,事件区别?
Hazelcast
Consul简介
Consul is a service mesh solution providing a full featured control plane with service discovery, configuration, and segmentation functionality.
Hashicorp:delivers consistent workflows to provision, secure, connect, and run any infrastructure for any application.
提供的新架构,解决方案
FAQ
线上容器里面是怎么连上的consul?
consul使用模式?线上部署模式?教务总共三个node,service全部在node上,其他电商的node就是service.
service -> consul client(3 pod) -> consul server()
Consul Agent,Server,Client,Consul cluster,
Using Lib
https://github.com/Ecwid/consul-api
Paper
-
SWIM:Scalable Weakly-consistent Infection-style Process Group Membership Protocol
-
Lifeguard:Local Health Awareness for More Accurate Failure Detection
Wiki
Hazelcast
Hazelcast简介
Hazelcast is a streaming and memory-first application platform for fast, stateful, data-intensive workloads on-premises, at the edge or as a fully managed cloud service.
产品有:Hazelcast Management Center,IMDG,Jet
学习进度
提供的新架构,解决方案
笔记
cache, distributed lock, key-value store, pub/sub, computing platform,
cache pattern: https://hazelcast.com/blog/a-hitchhikers-guide-to-caching-patterns/ cache read-through MapLoader write-through MapStore Write-Behind write-delay-seconds
内存计算大图:数仓方向Databend,apache arrow,Hadoop->Spark,HDFS->Alluxio,Arrow,HANA,HazelCast, Redis,VoltDB 这些技术的关系。IMDG到底是什么?
内存计算的含义是:IMDG+JET
Apache Beam和Jet组合起来?
IMDG(DataGrid-distributed data) IMDB(DataBase) IMDS(DataStore) IMCG(ComputeGrid-Jet)
使用方式Java Member和Java Client,其他语言只有Client。
Near Cache是client-server模式的二级缓存。
HZ核心设计文档:https://github.com/hazelcast/hazelcast/blob/master/docs/design/template.md
Bridging Between Java 8 Streams and Hazelcast Jet
In-Memory Storage/In-Memory Compute/Real-Time Processing
Distributed Data Design(Partitioning and Replication): AP:Replication(lazy replication), primary-copy, best-effort, no strong consistency but monotonic reads guarantee, anti-entropy,at-least-once, CP: Consensus algorithms Raft
嵌入式是否支持”跨应用”发现彼此?
membership具体细节,如何加入和如何退出,以及数据迁移细节官方文档涉及比较少。
Build Distributed System
Core Object:Config,DistributedObject,Node,NodeState,Cluster,HazelcastInstance
FD:PhiAccrualFailureDetector,PhiAccrualClusterFailureDetector,DeadlineClusterFailureDetector,PingFailureDetector
自定义对象:common infrastructure
simple data grid -> data grid infrastructure
Jet
Hazelcast Jet no dependency on disk storage, it keeps all of its operational state in the RAM of the cluster
竞品
HZ的AP需要结合复制,一致性,选举去理解。而CP则需要结合线性一致性,共识去理解。
https://www.gartner.com/reviews/market/in-memory-data-grids
对比:https://hazelcast.com/resources/#topic=competitive Apache Ignite,Pivotal Gemfire,Terracotta BigMemory,JBoss Data Grid,GigaSpaces,Oracle Coherence SAP HANA?timesten
https://www.oracle.com/java/coherence/
an alternative to Coherence and Terracotta
Distributed Snapshots: Chandy-Lamport algorithm JET using it?
讲座:https://hazelcast.com/blog/tech-talk-series/
hz和beam结合例子:https://hazelcast.com/blog/running-apache-beam-on-hazelcast-jet/
Testing the CP Subsystem with Jepsen:https://hazelcast.com/blog/testing-the-cp-subsystem-with-jepsen/ linearizable
问:Linearizable:单机jmm实现不了顺序一致性 采取了happen before一致性。为什么在分布式里面就能实现比顺序一致性高的线性一致性呢?(也许这是一个错误的问题)而raft是如何基于共识协议实现了线性一致性呢? 答:因为满足happen-before的属性是可线性化的,全序的,所有线程遵守约定次序。单锁保护对象读写都是可线性化的, Java内存模型满足松弛内存模型的基本特性:如果程序的顺序一致性满足某些规则,那么该程序的所有执行在松弛内存模型仍然是顺序一致的。
https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/package-summary.html#Weakly
假设Lock基于AQS,非阻塞同步,CAS,乐观并发。
CHashMap,单机不能实现强一致性(put完get肯定是最新的)。分布式也更加实现不了,如果实现了。
ConcurrentHashMap:Weak Consistency,单机的能保证read your write,但是能保证read others write吗?
jmm的happen-before:满足条件的是部分操作,而顺序一致性是所有操作。分布式系统里面,并没有定义哪些操作是happen before。如果定义了,那么等价于分布式的强一致性的Map。这里强 一致性是部分操作,不是所有操作。我在单机执行Map操作,然后复制结果到其他节点,完事。如果是CP的,那么Map每个操作都要强一致性的话,会很复杂。
如果是分布式的Map,意味着锁住整个Map,SynchronizedMap。并发集合是线程安全的,但不受单个互斥锁的控制。单个锁阻止对集合的所有访问时,“同步”类可能很有用。 Map的一致性性,操作非常多,不仅仅是put,get,还有size,isEmpty,containValue,迭代等功能。满足这些操作的全部强一致,代价较高。
K1=4 线程A:put(K1=6) get(K1),线程B:get(K1) put(K1=5), 没有同步情况下,B: get(K1)是可能获取到A的值。为什么并发Map不会导致脏读? 经过一段时间,K1的值是多少?
用底层不可靠机制实现了上层可靠机制。底层jmm happen before,但是上层happen before可以实现强一致性。
指令重排序,类似于消息乱序。
https://curator.apache.org/curator-recipes/index.html
CP:https://hazelcast.com/blog/author/ensarbasri/
https://github.com/jepsen-io/jepsen/tree/main/hazelcast
CP group Each CP group executes the Raft consensus algorithm independently
Beam缩写:Batch + strEAM
SQL基于calcite解析。
API文档:https://docs.hazelcast.org/docs/4.2.5/javadoc/,其中关于FencedLock很有意思。
缓存选择:IMap还是ReplicatedMap?为什么ReplicatedMap没有MapLoader和MapStore接口? 缓存选择:IMap还是ICache? ICache优于IMap,IMap过期策略很少,ICache API供应商独立,可以替换缓存实现,更符合缓存,IMap好像ConcurrentHashMap,ICache类似于LoadingCache.
IMap+Near Cache
Replicated Map:anti-entropy update operations to all members in the cluster eventually consistent system with read-your-writes and monotonic-reads consistency
Replicated Map:Mutli-Master IMap:Single Master
Akka的AP提供的是CRDT,HZ的AP提供的是数据结构。
AP数据结构,意味着线性一致性。意味着不一致就不可用。
分布式锁在CP意味着什么?AP意味着什么?这里的强一致性并不是数据。
HZ是PACELC种PA,EC完美案例。
(必读Daniel Abadi文章)Hazelcast和神话般的PA/EC系统:http://dbmsmusings.blogspot.com/2017/10/hazelcast-and-mythical-paec-system.html
PA/EC:系统的基本问题如下:尽管分区是一个罕见的事件,但它们并非不可能。任何建立在PA系统之上的应用都必须有相应的机制来处理这些分区事件中出 现的不一致。但是,一旦他们有了这些机制,为什么不在正常运行期间受益,并获得更好的延时呢?
https://en.wikipedia.org/wiki/PACELC_theorem
IAtomicLong的(incrementAndGet,compareAndSet )意味着分布式的compare-and-set。单机原子变量实现很复杂了。CAS操作。意味着共识。那意味着CAS可以实现非阻塞的锁。 那么为什么不能实现并发的强一致性MAP/LIST?参考juc思路。
AP数据结构并不依赖共识。
如何实现线性化的compareAndSet与全序关系广播等价于共识问题。
HZ的CP官方说是线性一致性。
HZ AP复制模型。primary-backup.primary挂了,怎么选举primary?leader选举不一定需要共识。
CP Subsystem:Unsafe mode,CP group,CP member,
Akka无主,实现了集群单例,主节点选举。
选举不一定需要共识,虽然表面看是对某些事情达成一致。
主节点选举,集群单例,分布式锁,分布式事务与共识关系。
分布式互斥与共识算法。共识和线性化有关系,但是分布式系统在不保证线性化时候,共识并不是必须的。
共识可以解决选主,原子提交,互斥。但是选主,原子提交,选主不一定是共识。
//Distributed Lock hzMap.lock("Peter"); 和 FenceLock区别?
core class
node:Hazelcast member:HazelcastInstance
CPSubsystem,CPMember,CPGroup,CPSession RaftService 【each CP member can participate to more than one CP group】
hz的cp到底和raft区别在哪里?多了哪些?
HZ的分布性特性,除了CAP抉择外,还需要满足正确性,如单机线程安全(去哪里了?是否还存在?),单机数据结构正确性(默认正确) ,分布式数据结构的正确性(保持疑问),比如Queue顺序,Set的唯一性,List下标,Topic的消息语义,数据一致。 数据结构的正确性,hashCode,equals,并发实现等等细节。理解部分简单,理解部分复杂,学习和理解都不难,但是难在证明是对的。你能想到很多问题,但是很难精确解答,因为你很难精确证明。为什么不需要证明系统还在运行? 因为经验主义。而不是科学主义。但是关键的点需要理解清楚:官方如文档提到的。需要收集各种信息来完善认识。了解越多越好是良好工程的基础。
分布式系统,节点变更对系统影响。很难说清楚,因为系统文档不全,相信但怀疑。
复制是如何保证不乱序的?
单机 List,Set,Map不线程安全时会发生什么?
顺序一致性。它太严格了,不适合做 Java 内存模型,因为它 禁止了标准的编译器和处理器优化。这一节将回顾下顺序一致性,然后展示另一个 模型,称作 happens-before 内存模型。
Hazelcast is a java library to create distributed applications
Java Memory Consistency with happens-before。
JMM可见性和ACID隔离性有点类似。
分布式系统和单机并行系统一致性表达同样的事物,只是操作或者适合级别不一样。先说单机一致性,再说分布式系统一致性。(和Replicate有关,但是不绝对,如共享存储) Java并发:A(原子性)V(可见性)O(顺序性) 指令重排,类似于命令重排。AVO是JMM在happen-before一致性模型下的特点。 数据库:ACID(隔离性-可见性) 分布式:CAP(一致性-可见性)
复制,一致性,共识关系是什么? 一致性协议有哪些?Continuous,Primary-based,Remote-write protocols,Replicated-write protocols, memory consistency and cache coherency.
先说单机并发的一致性,再说分布式系统的一致性。 如何让JUC变成分布式结构?HZ的原子变量/锁和JUC区别? https://en.wikipedia.org/wiki/Consistency_model https://en.wikipedia.org/wiki/MESI_protocol https://en.wikipedia.org/wiki/Consistency_(database_systems) 【Consistency (or Correctness) 】 https://en.wikipedia.org/wiki/Linearizability https://en.wikipedia.org/wiki/Sequential_consistency https://en.wikipedia.org/wiki/Causal_consistency https://en.wikipedia.org/wiki/Cache_coherence (缓存一致性) https://en.wikipedia.org/wiki/Data_consistency https://en.wikipedia.org/wiki/Consensus_(computer_science) 工程里面缓存一致性,是数据一致性。
Consistency and replication(多份数据的一致性)以及单一共享数据的一致性。
Expire(time:access or last write) and Evict(size:LRU,LFU),最近虽然是时间概念,但是淘汰的是size。 Caffenie:size-based eviction,time-based expiration
缓存淘汰:eviction(LRU LFU,很多key淘汰哪些,选择淘汰哪些是不确定的,全局配置) 缓存过期:expiration(单个key,淘汰是确定的)
我们在应用层很少谈论一个并发Map的一致性,因为JMM做了假设,是happen-before原则。
IMap和ICache区别?
顺序性,一致性,原子性,可见性,
CAP是特性,而不是实现。 一致性是形容词,共识是动词。
一致性能干什么?分布式锁的一致性是线性的(HZ)还是顺序的(ZK)。保证了一致性有什么好处?如何实现一致性呢?共识和一致性如何产生关系的?
数据库的ACID有什么好处?数据库并发控制+事务。
JMM的一致性的没有实现顺序一致性,因为会禁止编译器对所有代码重排序,所以选择了一种弱一致性模型,叫happen-before,而满足happen-before的操作,一定会满足线性一致性,此时是阻塞方式实现线性一致性。但是juc里面aqs基于非阻塞算法,而非阻塞算法分为无等待,无锁,无障碍。juc 大部分是无锁实现,也就是无锁实现了线性一致性。 单机并发一致性和分布式一致性是一样的。只是分布式多了网络这个不确定因素。
原子变量:里面只有一个值。减少了状态的变化,基于原子变量可以设计非阻塞的数据结构。然后在理解hz的原子变量作用。 并发集合:有阻塞同步的,也有非阻塞同步的。 同步原语,阻塞同步,AQS框架。
单机锁和分布式锁均需要保证活跃性,安全性,性能。
Distributed lock : 分布式锁本质是共识问题,需要多个节点共同认可某个节点是锁的占有者,否则就会认为自己也可以占有锁,redis做分布式锁并不是一个好的idea,因为本身并不提 供共识功能,而是一个存储KV库。虽然选举算法可以选出来一个leader获取某个锁,但是并不是强一致性的,也不能满足安全性,活性,基于共识的分布式锁, 如基于paxos的chubby(暴露文件系统API和分布式锁服务),或者zab的zk,raft的etcd是更好的选择。
leader选举和一致性没关系,但是强一致性更好实现leader选举,如zk 顺序一致性。
锁可以实现leader选举,leader选举也可以用锁或者别的方法来做。
分布式锁本质是分布式同步,单机锁和分布式锁区别在于对于网络分区,异常的处理。容错的分布式锁。
共识包括了选举,复制,分区等操作,这些操作会带来一致性问题。但是选举,复制,分区本身不包括共识。
共识包括了一致性,但是一致性不包括共识。
共识可以构建更高级的分布式同步原语,但是分布式同步原语可以不包括共识。
无论上面关系怎么变化,需要的是人为可感知的正确性。
分布式锁,共识,选举关系:共识包括选举,共识可以实现分布式原语,锁,锁也可以实现选举。这里选举含义是:是占有锁的人是leader,但是没有选举过程。
JMM具备AVO特性,导致单机锁具备了可见性和顺序性特点,分布式锁具有顺序性吗?或者可见性吗?分布式具备这些特性,需要满足一致性。如果分布式锁内容具有原子性,必须2PC了。但是2PC是弱的共识协议。
单机锁(LSP):活性(blocking:AQS,synchronize,LockSupport,non-blocking: AtomicXXX, wait-free, lock-free, obstruction free),安全性(),性能()
分布式的活性是什么?不获取锁?还是阻塞住?还是退了客户端继续重试?ZooKeeper: Wait-free coordination for Internet-scale systems
Locks can then be used to implement leader election, group membership
锁是一种通用机制,而选举,成员管理是一种功能。
MySQL构成的锁,Redis单机不是容错的分布式锁。这里的锁更类似于”产生互斥“的效果,其本身并不是锁的语义。
原子性:java(原子变量),acid,分布式事务,分布式系统(ZooKeeper Atomic Broadcast)
选主和分布式锁关系。实际该用选主的场景,选则了分布式锁。定时任务是什么场景?
定时任务本质一个节点执行,转换为leader执行,或者第一个获取锁的节点执行。本质是分布式互斥问题/分布式成员管理问题。
FencedLock的线性一致性如果服务端节点宕机或者客户端宕机,什么才叫线性一致性呢?
AP对于具体的数据结构含义不一样。
CPSubsystem
leader election, distributed locking, synchronization, and metadata management
Each CP group elects its own Raft leader and runs the Raft consensus algorithm independently.
each CP member can participate to more than one CP group
5个节点,挂了两个,集群还是线性一致性,但是在挂一个,将会报错。也就是一致性优于可用性。如果是6个,还是6/2+1,还是容忍挂两个。浪费了一个节点。
CP data structures have quite low memory overheads。
CP Subsystem member down之后,由于没有持久化raft状态,所以如果IP地址一样的话,将加入不了CPSubsystem,但是rancher里面每次重启ip变化了,所以不会有这个问题。
CP persistence requires Hazelcast Enterprise Edition
locks or semaphore:CPSession保证了liveliness。Sessions offer a trade-off between liveliness and safety。
复制顺序保证
复制是分布式系统的起点,研究清楚复制过程是基础也是核心,如数据复制形式(pull or push,复制模式,语句还是状态,复制顺序保证等等),服务复制(管理服务)。shard-everything也需要复制的。
共识保证复制顺序,一致性等等。但是反过来就不一定了。普通的复制如何保证顺序性呢?难道是保证不了?顺序性需要事件顺序,又回到了逻辑时间问题?究竟如何保证的?
副本更新顺序是怎么保证的?如果保证了,和一致性关系?mysql主从顺序保证了,但是一致性没保证。复制顺序问题。
With lazy replication, when the primary replica receives an update operation for a key, it executes the update locally propagates it to backup replicas. It marks each update with a logical timestamp so that backups apply them in the order and converge to the same state with the primary.
MySQL复制是slave读取masterbinlog然后放在中继日志里面。
复制,分布式互斥,分布式数据结构,分布式选举,这些问题,可以单独解决,也可以先构建一个共识协议,来解决这些问题。基于共识解决是有限制的。比如redis分布式锁是基于redis去实现的, 本身和分布式共识没关系,但是可以基于共识去实现分布式锁。 这就是redis,zk,etcd,hz的分布式锁/barrier/countdownlatch的区别。但是用共识解决这些问题, 会导致一些限制,如写不能太多,数据不能太大,必须强一致性,不能性能瓶颈。 分布式数据结构里面的hz ap,以及redis reddsion存储能力大于zk的队列存储。需要一致性的,互斥的尽量是 共识解决,不需要的可以不借助共识实现。kafka的数据复制和zk分开的(分区管理,元信息等).zk的分布式数据存的是配置或者参数之类的,而不是一个数据存储系统。
akka,gossip consul client(gossip)+server(raft)
kv(https://db-engines.com/en/ranking/key-value+store)
1.Riak, Redis and Voldermort 2.etcd/consul/zk/ 3.leveldb/rocksdb/mapdb
AP是舍弃了线性一致性,获得了高可用,但是一致性模型,在jepsen中是什么呢?(Causal Consistency/RYW/Session/Monotonic Read/Write)
Quroumn策略:W+R<=N,属于weak/eventual consistency W+R>N,强一致性,但是可用性下降,写入少于W,系统就不可用了。
kafka复制和kraft没关系。也不借助zk。一个系统用了raft看主要解决了什么问题?raft虽然有复制,但是系统数据一般不会用。
Starter
https://docs.hazelcast.com/hazelcast/5.1/pipelines/spring-boot
参考
Paper
Repository
https://github.com/xiaozhiliaoo/hazelcast
https://github.com/xiaozhiliaoo/hazelcast-code-samples
https://github.com/xiaozhiliaoo/hazelcast-jet
https://github.com/xiaozhiliaoo/hazelcast-practice
链接
Redis和Hazelcast对比:https://hazelcast.com/compare-with-redis/
Jet和Spark对比:https://hazelcast.com/blog/how-hazelcast-jet-compares-to-apache-spark/
人物
Greg Luck Hz CTO ( https://hazelcast.com/blog/author/gregluck/ ) jsr107作者 https://github.com/gregrluck
Greg Luck is a leading technology entrepreneur with more than 15 years of experience in high-performance in-memory computing. He is the founder and inventor of Ehcache, a widely used open source Java distributed cache that was acquired by Software AG (Terracotta) in 2009, where he served as CTO. Prior to that, Greg was the Chief Architect at Australian start-up Wotif.com that went public on the Australian Stock Exchange (ASX:WTF) in 2006. Greg is a current member of the Java Community Process (JCP) Executive Committee, and since 2007 has been the Specification Lead for JSR 107 (Java Specification Requests) JCACHE. Greg has a master's degree in Information Technology from Queensland University of Technology and a Bachelor of Commerce from the University of Queensland.
cluster
Discovery Mechanisms
Auto Detection:multicast TCP/IP Cloud Discovery
Distributed Data Structures
数据结构选择依据:1 是否partitioned 2 AP or CP保证
AP:
Jackson
Jackson简介
ElasticStack
ElasticSearch
学习进度
看到这里了:https://www.elastic.co/guide/cn/elasticsearch/guide/current/_preventing_combinatorial_explosions.html
概念
Near Real Time
打分机制:从TF-IDF改成BM25,也叫similarity ,scoring,ranking
oversharding问题,如何创建分片数?
如何知道数据在集群中的哪个节点?
集群状态:红绿黄
es和mysql数据模型区别?
结构化搜索和全文搜索
全文搜索:传统数据库确实很难搞定的任务,传统数据库要么匹配,要么不匹配,es有相关性打分。
PB级别,数百台服务器
一个分片是一个 Lucene 的实例,以及它本身就是一个完整的搜索引擎
每个字段的所有数据都是默认被索引的
index是逻辑概念,面向用户,shard是物理概念,面向机器,应用程序关心索引,而不是分片
Elasticsearch中文档是不可改变的,不能修改它们,在内部,Elasticsearch 已将旧文档标记为已删除,并增加一个全新的文档,并且会重新进行索引。
更新文档:标记删除,创建文档,重新索引,检索-修改-重建索引
文档中的每个字段都将被索引并且可以被查询
在分布式系统中深度分页:在分布式系统中,对结果排序的成本随分页的深度成指数上升
filed:精确值,全文值
很少对全文类型的域做精确匹配
Doc Values:排序,聚合,脚本计算 Invert Index:检索
文档的唯一性:index,type,routing value
检索过程:query then fetch 先查后取
分片节点:from+size
协调节点:numberOfShard * (from+size)
scroll 查询禁用排序
搜索类型:query then fetch,dfs_query_then_fetch
深度分页的代价根源是结果集全局排序,如果去掉全局排序的特性的话查询结果的成本就会很低。
Data Replication:Primary-Backup
in-sync shard(可以被选中为primary的shard)
index配置最重要的是:number_of_shards(创建后更改不了),number_of_replicas(创建后可以修改)
_id 和 _index 字段则既没有被索引也没有被存储,这意味着它们并不是真实存在的。
不能添加新的分析器或者对现有的字段做改动。 如果你那么做的话,结果就是那些已经被索引的数据就不正确, 搜索也不能正常工作。此时需要reindex。
修改索引类型:https://www.elastic.co/guide/cn/elasticsearch/guide/current/index-aliases.html
应用中使用索引别名,而不是索引真实名字。这样在修改索引时候,应用层不需要变化。
全文检索=全字段索引
倒排索引被写入磁盘后是 不可改变 的
在保留不变性的前提下实现倒排索引的更新?答案是: 用更多的索引。
一个 Lucene 索引包含一个提交点和三个段
一个 Lucene 索引 我们在 Elasticsearch 称作 分片 。 一个 Elasticsearch 索引 是分片的集合
段是不可改变的
内存索引缓冲区
按段搜索
写入和打开一个新段的轻量的过程叫做 refresh,每1s refresh下
Elasticsearch是近实时搜索: 文档的变化并不是立即对搜索可见,但会在一秒之内变为可见
Flush:执行一个提交并且截断 translog 的行为在 Elasticsearch 被称作一次 flush,30分钟一次。 Flush之后段被全量提交,并且事务日志被清空
减少段的数量(通常减少到一个),来提升搜索性能。
结构化搜索:要么在,要么不在,和打分机制无关系。也就是和相似度无关。
精确值查找时候,需要用filter,不会被打分,会被缓存。
尽可能多的使用过滤式查询。
constant_score(常量评分查询) 将 term 查询转化成为过滤器。
term查询转成constant_score查询。(非评分查询)
非评分计算是首先执行的,这将有助于写出高效又快速的搜索请求。
bool过滤器,也叫复合过滤器。
查看索引别名:GET /finance_netease_settle_order/_alias
布尔过滤器可以用来作为构造复杂逻辑条件的基本构建模块。
term 和 terms 是 包含(contains) 操作,而非 等值(equals)
查询优化:普通查询 -> bool filter -> constant_score filter
exists(!=null),missing(==null)查询
filter query 实现bitset的roraing bitmap
bool match查询
多数字符串字段都是 not_analyzed 精确值字段
dfs_query_then_fetch: dfs是指分布式频率搜索(Distributed Frequency Search) , 它告诉 Elasticsearch , 先分别获得每个分片本地的 IDF ,然后根据结果再计算整个索引的全局 IDF 。
多字段搜索:bool match查询
dis_max:分离最大化查询(Disjunction Max Query)
全文搜索被称作是 召回率(Recall) 与 精确率(Precision) 的战场
召回率 ——返回所有的相关文档;
精确率 ——不返回无关文档
TF/IDF
字段中心式(term-centric)查询:best_fields 和 most_fields 词中心式(term-centric)的查询:cross_fields
自定义单字段查询是否能够优于多字段查询,取决于在多字段查询与单字段自定义 _all 之间代价的权衡, 即哪种解决方案会带来更大的性能优化就选择哪一种。
multi_match 查询中避免使用 not_analyzed 字段。
短语匹配(match_phrase查询)
http://people.apache.org/~mikemccand/lucenebench/
unigrams ,bigrams(shingles),trigrams,
shingles 不仅比短语查询更灵活,而且性能也更好。 shingles 查询跟一个简单的 match 查询一样高效,而不用每次搜索花费短语查询的代价。
prefix 查询不做相关度评分计算,它只是将所有匹配的文档返回,并为每条结果赋予评分值 1 。它的行为更像是过滤器而不是查询。
search-as-you-type:match_phrase_prefix
Boolean Model:只是在查询中使用 AND 、 OR 和 NOT
Lucene 使用 布尔模型(Boolean model) 、 TF/IDF 以及 向量空间模型(vector space model) ,然后将它们组合到单个高效的包里以收集匹配文档并进行评分计算。
bool 查询实现了布尔模型
查询时的权重提升 是可以用来影响相关度的主要工具
constant_score 和 function_score区别?
一致随机评分(consistently random scoring)
similarity算法:BM25,TF-IDF
全文搜索是一场 查准率 与 查全率 之间的较量—查准率即尽量返回较少的无关文档,而查全率则尽量返回较多的相关文档。
es多字段,可对字段建立两次索引。文本做两次索引
stem 词干 stemmer 词干提取器
多语言设计:index-per-language, field-per-language
Elasticsearch 为什么不能在 analyzed (分析过)的字符串字段上排序,并演示了如何为同一个域创建 复数域索引 , 其中analyzed域用来搜索,not_analyzed域用来排序。
Analyzed 域无法排序并不是因为使用了分析器,而是因为分析器将字符串拆分成了很多词汇单元,就像一个 词汇袋,所以 Elasticsearch 不知道使用那一个词汇单元排序。
analyzed name域用来搜索。not_analyzed name.raw 域用来排序。
International Components for Unicode (ICU)
单词还原成词根。比如foxes还原成fox.
常见问题
1.数字什么时候建模成numeric类型,什么时候建模成keyword类型? 参考
2.映射非结构化数据,选择text还是keyword? 参考
3.Object查询和Nested查询区别是什么? 参考
4.FieldData是什么? 参考
5.Mapping的参数有哪些?(Filed的配置有哪些?) 参考
6.什么是global-ordinals?
7.mapping-field-meta是否可以写字段备注? 参考
8.为什么删除了mapping type字段? 参考
9.Analyzer的三个过程是什么? 参考
10.ES聚合分析的内部原理? 聚合基于doc value正排索引实现的。用纯倒排索引实现性能很差。doc value也叫正排索引。搜索基于倒排索引实现。
11.doc value和filed data区别?
doc value是非分词字段的默认值,在index时候创建,所以可以支持聚合, filed data是分词字段的聚合控制,是没有doc value的,默认不支持聚合操作,必须设置为true才可以,filed data在内存中,查询聚合时候才生成的加载到内存中。 https://www.elastic.co/guide/en/elasticsearch/reference/current/text.html#fielddata-mapping-param https://www.elastic.co/guide/en/elasticsearch/reference/current/doc-values.html 实际很少对分词fileddata进行聚合,尽量对不分词的docvalue进行聚合。
12.Terms聚合如何选择收集模式?DFS or BFS?ES默认是哪一个? 参考
13.Es如何处理并发冲突?
14.如何解决ES深度分页问题?
Scroll,Search After,From/Size
15.ES的相似度/分数是怎么计算的?(ES排序问题) 参考
16.准确率和召回率是什么意思?如何优化这两个数值?
17.ES会发生一边搜索一边构建索引过程吗?
18.ES分割倒排索引是纵向分割文档还是水平分割单词?
19.MySQL全文检索和ES搜索区别? 参考
20.Vector Space Model(term vector model)是什么? 参考
21.如何设计一个搜索引擎? 参考
22.ES match phrase query的slop和 fuzzy query的max_expansions距离对比。 参考
23.如何自己实现一个ES插件?
24.Text(文本)->Token(词汇单元)->Term(项)过程中,发生了什么?TokenFilter和Tokenizer区别是什么?Token有哪些属性?
25.ES词干提取算法有哪些?
26.分别举例:一个字段查多个词和一个词查多个字段可以用哪些Query?
一个字段查一个词:term-query,match-query,match-phrase-query
一个字段查多个词:match-query,terms-query
一个词查多个字段:multi-match,bool-query
多个词查多个字段:bool-query,disjunction-max-query
27.Es Query编写:查找所有文档中”quick fox”接近”lazy dog”的或者”quick fox”接近”sleepy cat”的文档。
参考:https://gist.github.com/xiaozhiliaoo/abc5c3d18c3ab52ea78a600641588dab
Doc Content
1 the quick brown fox jumped over the lazy dog
2 the quick red fox jumps over the sleepy cat
28.Match phraseQuery和SpanQuery/SpanNearQuery区别?以及使用场景?
29.Url-search和query-string search区别?
30.Es mapping如下,查找指定订单ID的文档,用尽可能多的方式写出。 query string query,match query,term query,uri search
31.如何为任务选择合适的查询?
32.query string和simple query string区别?
33.Es query rewrite是什么意思?
34.多桶聚合的terms和composite聚合的区别? 精确度问题: https://www.elastic.co/guide/en/elasticsearch/reference/5.3/search-aggregations-bucket-terms-aggregation.html#search-aggregations-bucket-terms-aggregation-approximate-counts
https://www.elastic.co/guide/en/elasticsearch/guide/master/_approximate_aggregations.html
https://www.elastic.co/guide/en/elasticsearch/reference/6.8/search-aggregations-bucket-terms-aggregation.html
35.深度分页问题? https://www.elastic.co/guide/en/elasticsearch/guide/current/pagination.html
36.倒排索引的数据结构是什么?
原理
https://www.elastic.co/blog/found-elasticsearch-internals
https://www.elastic.co/blog/found-elasticsearch-networking
https://en.wikipedia.org/wiki/Finite-state_transducer
for压缩和rbm压缩:https://www.elastic.co/cn/blog/frame-of-reference-and-roaring-bitmaps
EQL
select * from course where title='how to make millions' and tag!='spam' or (tag = 'starred' and date >= '2014-01-01');
select * from emails where (folder='inbox' and reading = false) or (folder!='inbox' and important=true)
SELECT product FROM products WHERE (price = 20 OR productID = "XHDK-A-1293-#fJ3") AND (price != 30)
遇到问题
1.forbidden-12-index-read-only-allow-delete-api?
某个节点的磁盘满了,需要运维清理下磁盘
课程
https://github.com/xiaozhiliaoo/geektime-ELK
https://github.com/xiaozhiliaoo/search-practice
Java API
ElasticsearchClient执行Action
核心抽象是Action
TransportClient(TCP) RestHighLevelClient(HTTP)
prepareSearch和
TransportClient.prepareSearch ActionRequestBuilder.get
SearchRequest (SearchRequestBuilder) -> TransportClient/RestHighLevelClient -> SearchResponse
SearchRequest(Query,Source,Scroll)
prepareXXX -> get
Action<Request, Response, RequestBuilder>
疑问
-
SearchScroll和SearchAfter区别?
-
这3种写法的区别是什么?
SearchRequest request1 = new SearchRequest(INDEX) .source(new SearchSourceBuilder().query(query)) .scroll(SCROLL_TIMEOUT); //prepareSearch里面调用SearchRequestBuilder SearchRequest request2 = transportClient.prepareSearch(INDEX) .setSource(new SearchSourceBuilder().query(query)) .setScroll(SCROLL_TIMEOUT).request(); //searchRequest里面调用new SearchRequest(INDEX) SearchRequest searchRequest3 = Requests.searchRequest(INDEX) .source(new SearchSourceBuilder().query(query)) .scroll(SCROLL_TIMEOUT);
请求写法1 通过RestHighLevelClient的request search
SearchRequest request = transportClient.prepareSearch(INDEX)
.setSource(new SearchSourceBuilder().query(query))
.setScroll(SCROLL_TIMEOUT).request();
SearchResponse searchResponse = RestHighLevelClient.search(request)
请求写法2 通过TransportClient的request builder get/execute
SearchRequestBuilder requestBuilder = transportClient.prepareSearch(INDEX)
.setSource(new SearchSourceBuilder().query(query))
.setScroll(SCROLL_TIMEOUT);
SearchResponse searchResponse = requestBuilder.get(SCROLL_TIMEOUT)
SearchResponse searchResponse2 = requestBuilder.execute().actionGet();
使用
mysql与es进行同步
订单多字段检索,插件搜索:订单查询
订单模块加解密插件,单字分词插件
统计聚合:结算
新加字段:结算
修改字段类型:结算
嵌套聚合,嵌套分组:结算
嵌套搜索 结算:结算
es terms聚合和composite聚合区别,以及改进terms聚合。节点经常oom,聚合数据太多了,所以改成了composite聚合
Config
Operation
常见错误
- Fielddata is disabled on text fields by default. Set fielddata=true on [id] in order to load fielddata in memory by uninverting the inverted index. Note that this can however use significant memory. Alternatively use a keyword field instead.
在text字段上面进行排序操作。
- Cannot search on field [lastName] since it is not indexed.
mapping中lastName设置位index:false,es字段不索引,查不出来。
System
ES相似度Similarity Search:https://www.elastic.co/guide/en/elasticsearch/reference/current/index-modules-similarity.html
ES向量化搜索
https://www.elastic.co/blog/text-similarity-search-with-vectors-in-elasticsearch
https://juejin.cn/post/7086775047091666952
https://lucene.apache.org/core/8_0_0/core/org/apache/lucene/search/similarities/Similarity.html
https://github.com/adrg/strutil
召回率
ES Term的Fuzzy查询基于: Levenshtein edit distance(es string distance)
ES Match的查询基于:TF/IDF或者BM2.5
ES的Suggest基于string_distance(字符串距离算法): https://www.elastic.co/guide/en/elasticsearch/reference/8.8/search-suggesters.html#_other_term_suggest_options
internal: The default based on damerau_levenshtein but highly optimized for comparing string distance for terms inside the index.
damerau_levenshtein: String distance algorithm based on Damerau-Levenshtein algorithm.
levenshtein: String distance algorithm based on Levenshtein edit distance algorithm.
jaro_winkler: String distance algorithm based on Jaro-Winkler algorithm.
ngram: String distance algorithm based on character n-grams.
golang字符串距离:https://github.com/adrg/strutil
Ecosystem
Admin
LogStash
笔记
kibana
笔记
beat
reference
https://www.elastic.co/guide/en/beats/libbeat/8.0/beats-reference.html
Lucene
Book
Elasticsearch权威指南
Elasticsearch: The Definitive Guide: A Distributed Real-Time Search and Analytics Engine 1st Edition
中文:https://www.elastic.co/guide/cn/elasticsearch/guide/current/index.html
英文:https://www.elastic.co/guide/en/elasticsearch/guide/current/index.html
Progress
100%
https://www.elastic.co/guide/cn/elasticsearch/guide/current/_creating_an_index.html
Notes
对文档进行索引、检索、排序和过滤,而不是对行列数据
query string轻量级搜索,bool查询+filter。
聚合的结果数据并非预先统计,而是根据匹配当前查询的文档即时生成的。
Elasticsearch 可以横向扩展至数百(甚至数千)的服务器节点,同时可以处理PB级数据
全文搜索:match查询,match_phrase查询 关键词搜索:term查询
Elasticsearch 默认按照相关性得分排序,即每个文档跟查询的匹配程度。
ES屏蔽了分布式系统复杂性,如下:
分配文档到不同的分片中,文档可以储存在一个或多个节点中
按集群节点来均衡分配这些分片,从而对索引和搜索过程进行负载均衡
复制每个分片以支持数据冗余,从而防止硬件故障导致的数据丢失
将集群中任一节点的请求路由到存有相关数据的节点
集群扩容时无缝整合新节点,重新分配分片以便从离群节点恢复
分布式架构概念:集群,节点,分片,副本
节点特性:
1.当有节点加入集群中或者从集群中移除节点时,集群将会重新平均分布所有的数据。
2.当一个节点被选举成为主节点时,它将负责管理集群范围内的所有变更,例如增加、删除索引,或者增加、删除节点等。
而主节点并不需要涉及到文档级别的变更和搜索等操作,所以当集群只拥有一个主节点的情况下,即使流量的增加它也不会成为瓶颈。
任何节点都可以成为主节点。
3.可以将请求发送到集群中的任何节点,包括主节点。每个节点都知道任意文档所处的位置,并且能够将请求直接转发到存储我们所需文档的节点。
无论将请求发送到哪个节点,它都能负责从各个包含我们所需文档的节点收集回数据,并将最终结果返回給客户端。
集群健康:
Green:所有主副分片可运行。
Yellow:所有主分片运行,副本分片部分不可用。
Red:部分主分片不可用。
索引指向一个或者多个物理分片的逻辑命名空间。一个分片是一个底层的工作单元,它仅保存了全部数据中的一部分。一个分片是一个Lucene的实例,以及它本身就是一个完整的搜索引擎。
文档保存在分片内,分片又被分配到集群内的各个节点里。当集群规模扩大或者缩小时,ES会自动的在各节点中迁移分片,使得数据仍然均匀分布在集群里。
在索引建立的时候就已经确定了主分片数,但是副本分片数可以随时修改。 "number_of_shards" : 3, "number_of_replicas" : 1
分片是一个功能完整的搜索引擎。
CAP:CP系统一般用了共识协议,没用的一般AP。Cassandra 可调一致性调节到CP,用的是quorum策略。
TF-IDF:词频/逆向文档频率(term frequency inverse document frequency)
es两个阶段:索引和查询
stemmer:词干提取器,Hunspell 词干提取器(拼写检查)
synonyms:同义词
字典词干提取器,算法化词干提取器
实践中一个好的算法化词干提取器一般优于一个字典词干提取器。
保留停用词最大的缺点就影响搜索性能。
索引结构:Terms dictionary,Postings list,Term frequency,Positions,Offsets,Norms
common_grams 过滤器是针对短语查询能更高效的使用停用词而设计的。
Fuzzy matching 允许查询时匹配错误拼写的单词。原理是编辑距离
fuzzy 查询的工作原理是给定原始词项及构造一个 编辑距离自动机 — 像表示所有原始字符串指定编辑距离的字符串的一个大图表。
聚合=bucket+metrics bucket=group by metrics=count,sum,max...
<国家, 性别, 年龄> 组合的平均薪酬。所有的这些都在一个请求内完成并且只遍历一次数据.
直方图聚合:histogram,date_histogram
聚合是在查询范围内的,但有时要搜索它的子集,而聚合的对象却是所有数据:全局桶
聚合结果过滤:过滤桶
只过滤搜索结果,不过滤聚合结果:post_filter
Approximate Aggregations(近似聚合):cardinality(HyperLogLog),percentiles(TDigest- https://github.com/tdunning/t-digest )
max是精确聚合,count(DISTINCT)是近似聚合
大数据:精确性,实时性,延时的不可能三角
精确+实时:数据可以存入单台机器的内存之中,我们可以随心所欲,使用任何想用的算法。结果会 100% 精确,响应会相对快速。
大数据+精确:传统的Hadoop。可以处理PB级的数据并且提供精确的答案,但它可能需要几周的时间才能提供这个答案。
大数据+实时:近似算法为提供准确但不精确的结果。
聚合实现:DocValues
DocValues的存在是因为倒排索引只对某些操作是高效的。
倒排索引的优势在于查找包含某个项的文档,而对于从另外一个方向的相反操作并不高效,即:确定哪些项是否存在单个文档里
搜索使用倒排索引查找文档,聚合操作收集和聚合DocValues里的数据。
DocValues本质上是一个序列化的列式存储。列式存储 适用于聚合、排序、脚本等操作DocValues 不支持 analyzed 字符串字段。
聚合运行在 not_analyzed 字符串而不是analyzed 字符串,这样可以有效的利用DocValues。
聚合一个分析字符串:FieldData
terms 桶基于数据动态构建桶,它并不知道到底生成了多少桶。大多数时候对单个字段的聚合查询还是非常快的,但是当需要同时聚合多个字段时,就可能会产生大量的分组,最终结果就是占用 es 大量内存,从而导致 OOM 的情况发生。
聚合模式:DFS(默认),BFS
BFS广度优先仅仅适用于每个组的聚合数量远远小于当前总组数的情况下,因为广度优先会在内存中缓存裁剪后的仅仅需要缓存的每个组的所有数据,以便于它的子聚合分组查询可以复用上级聚合的数据。
对单个文件的变更是ACID的,但包含多个文档的变更不支持。
每个字段的所有数据都是默认被索引的。
逻辑概念索引,物理概念分片。
搜索比查询复杂,包括了分词,意图猜测,近义词,纠错等等。查询是精确匹配的。
分析:分词和标准化。分词产出token,标准化提高可搜索性。ES通过分析器实现了功能,包括字符过滤器,分词器,Token过滤器。
Elasticsearch实战
Progress
P47
深入理解Elasticsearch(原书第三版)
进度
阅读完成
笔记
prefix-query不会被分析,match query会被分析
es1.0多播发现机制,2.0单播默认发现机制。zen discovery
ingest等价于java版logstash节点
shrink api 索引收缩
查询数据:查询,过滤器
normalization 归一化
BM25和TF-IDF
es当作NOSQL,无分析查询会更好。也即精确查询。
基本查询:match,multi_match,common,fuzzy_like_this,fuzzy_like_this_field,geoshape,ids,match_all,query_string,simple_query_string range,prefix,regex,span_term,term,terms,wildcard
组合查询:bool,boosting,constant_score,dis_max,filtered,function_score,has_child,has_parent,indices,nested,span_first,span_multi, span_near,span_not,span_or,span_term,top_children
无分析查询:term,terms,common,ids,prefix,span_term,wildcard
全文检索:match,multi_match,query_string,simple_query_string
模式匹配:prefix,regexp,wildcard
相似度查询: fuzzy,fuzzy_like_this,fuzzy_like_this_filed,more_like_this,more_like_this_field
支持修改分数查询:boosting,constant_score,function_score,indices
位置敏感:match_pjrase,span_first,span_multi,span_near,span_not,span_or,span_term
结构敏感:nested,has_child,has_parent,top_children
查询改写:prefix,rewrite参数
multi_match匹配类型:best_fields,most_fields,cross_fields,phrase,phrase_prefix
es使用mustache实现查询模板
es管理关系型提供了:嵌套,父子文档结构
处理人类语言。
文档通过路由知道放在哪一个分片上面了。
集群主节点任务:节点间分配分片。
分片是一个Lucence索引。
相似度模型(similarity):TF-IDF,BM25,DFR,DFI,IB,LM Dirichlet,LM JelinekMercer
store模块:lucene和io子系统的抽象:niofs,simplefs,mmapfs,fs
Searcher重新打开的过程:refresh,默认1s
flush:将事务日志同步到lucene index,同时清空事务日志。默认5s
实时读取:从事务日志中读取。
段合并耗费性能的操作。
并发合并调度器:ConcurrentMergeScheduler
NRT:近实时
发现模块:选主,发现新节点,形成和发现新节点过程叫发现。Zen发现模块单播(unicast)发现集群中其他节点。
微服务发现是发现别人,但是自己发现不了。
es恢复过程:加载通过网关模块存储的数据以使得es正常工作。每当集群整体启动时候,恢复过程就会启动,加载所有数据:元数据,映射和全部索引。 网关模块存储es正常运行的全部数据。
es可以备份到s3,hdfs,gcs,azure
ingest处理器,内置23个等。append,convert,grok,fail等等。。。grok自带了120多种grok模式。
联盟搜索:跨集群搜索,通过部落节点
部落节点从所有连接的集群中获取集群状态,合并成一个集群状态。
percolation(过滤),suggester(联想,建议器)
查询验证 validate api
查询分析器:profile api
dfs query then fetch
发现集群变慢,阻塞等情况时候,可以看到热点线程api,看哪些线程耗费cpu,io等信息 hot_threads
当数据量够大,查询够复杂时候,就会碰到内存问题,此时增加更多内存也无济于事。
增加主分片:内存溢出,分片查询时间过长,内存交换,高IO等待等问题。增加副本分片:流量过高节点无法处理的时候,增加查询能力。
集群缺少部分节点数据,比完全不响应查询要好。
防止分片和副本部署在同一个节点,此时失去了高可用能力了。使用awareness能力。
集群部署:两个聚合节点,n个数据节点,三个候选主节点,冗余3个。设置minimum_master_nodes:2,可以避免脑裂发生。
索引刷新频率:文档需要多久才能出现在搜索结果里面。默认1s,意味着每1s索引查询器重新打开一次。
查询:总应该思考最优的查询结构,过滤器使用等。
不使用路由情况下,es会查询所有分片。如果知道文档在哪一个路由里面,将会提高效率。
索引只在一个分片上面,查询性能较差,增加副本分片对性能提高无用,需要将索引分为多个分片。把数据平均负载。
聚合查询:size是最后聚合结果返回多少组数据,shard_size是每个分片返回多少组数据。 降低size和shard_size会让聚合结果不那么准确,但是网络开销小,内存使用低。
过多的副本会导致索引速度下降。
es 预写日志WAL,tranlog,get请求获取最新的数据,确保数据持久化,优化lucene index的写入。
SSD优于HDD
基于时间的索引管理:shrink和rollover。shrink api 减少主分片,生成新的索引。只有只读才能收缩。
Elasticsearch源码解析与优化实战
Kafka
Config
kafka日志清理策略,cleanup.policy:compact, delete。 "compact" policy will enable log compaction,"delete" policy will discard old segments when retention time or size limit has been reached。
log(roll,retention,flush,cleaner)
log.retention.(bytes,hours,minutes,ms
log.retention.hours
log.reteideantion.minutes
log.retention.ms
log.cleaner.enable
kafka日志清理完,之后logSize会不会往前移动,如果前移,那么offset呢?不会前移,代价太高。
retention mechanism: compaction done by log cleaner。recopy log segments,
min.insync.replicas
Operations
消费者操作
打印指定偏移量的消费者的消息
./kafka-console-consumer.sh --bootstrap-server brokerIP:brokerPort --topic yourTopic --partition 0 --offset 19831988 --property print.key=true --max-messages 1
其他属性有: print.timestamp Set to true to display the timestamp of each message (if available). print.key Set to true to display the message key in addition to the value. print.offset Set to true to display the message offset in addition to the value. print.partition Set to true to display the topic partition a message is consumed from. key.separator Specify the delimiter character to use between the message key and message value when printing. line.separator Specify the delimiter character to use between messages. key.deserializer Provide a class name that is used to deserialize the message key before printing. value.deserializer Provide a class name that is used to deserialize the message value before printing.
消费组操作
查看消费组
./kafka-consumer-groups.sh --bootstrap-server brokerIP:brokerPort --describe --group yourGroup
重置消费者偏移量
./kafka-consumer-groups.sh --bootstrap-server brokerIP:brokerPort --group yourGroup --topic yourTopic --reset-offsets --to-offset yourOffset --execute
./kafka-consumer-groups.sh --bootstrap-server brokerIP:brokerPort --group yourGroup --topic yourTopic --reset-offsets -to-latest --execute
Kafka简介
Apache Kafka is an open-source distributed event streaming platform used by thousands of companies for high-performance data pipelines, streaming analytics, data integration, and mission-critical applications.
Confluent: Set Your Data in Motion
Confluent is creating the foundational platform for data-in-motion
进度
Event Streaming Patterns:https://developer.confluent.io/patterns/event/event/
inside-ksqldb:https://developer.confluent.io/learn-kafka/inside-ksqldb/streaming-architecture/
笔记
提供的新架构,解决方案:事件流处理平台,事件处理
Kafka
Events+Topics+RealTime+TalkToEachOther,4件事,不是kafka是什么,而是这种观点,分布式日志,
消费者:https://kafka.apache.org/30/javadoc/org/apache/kafka/clients/consumer/KafkaConsumer.html
生产者:https://kafka.apache.org/30/javadoc/org/apache/kafka/clients/producer/KafkaProducer.html
消费者逻辑比生产者复杂。
Kafka是事件处理平台,提供了事件存储能力Kafka的Log,事件计算KSQLDB,Kafka Stream。
Kafka Ecosystem: Kafka,Kafka Stream,Kafka Connect,KSQLDB.
事件处理中出现了问题,那么Materialize可以是发邮件,也可以是存到存储系统中。
kafka发送消息是k,v类型的。没发送一个消息,offset+1
https://developer.confluent.io/learn-kafka/event-sourcing/event-driven-vs-state-based/
软件设计方法:
state-based(databases+ synchronous network call)
event-based(data at rest + data in motion + event sourcing + CQRS + event streaming)
CRUD:Databases
CR:Event Sourcing
Topic:Event,Key,Partition,Schema
Table:Row,Primary Key,Shard,Schema
Index:Document,_id,Shard,Mapping
Collection:Document,DocumentId,Shard,Schema
Kafka Queue is Log:Append Only and Durable,Reading Message never delete. Other Message is Queue. Message is Bounded Buffer can be deleted. Topic is Log. Not Queue. Topic(DLT) is Queue(DLQ).
same key -> same partition -> in order ,key is null -> round robin ,key is nonull -> hash function
rewind,reprocess,replayable,reblance,
consumer group protocol(join+leave)
kafka日志清理两种策略,一种是删除,一种是压缩,删除的话就直接删除消息了,压缩才是保留最新的,
Kafka Connector
Consumer+Materialize = Kafka Connect ,Consumer+Stateful = Kafka Stream ,Consumer+Stateless = Kafka Consumer
数据是流动的处理平台(Kafka)和数据是静止的处理平台(MySQL)
DLQ:Dead Letter Queue
Kafka Stream
KTable:Last Updated Value
Kafka Core: Log+Event
Kafka Stream = KStream,KTable,Serialization,Joins,Stateful Operations,Windowing,Times,Processor,
Joins:Stream-Stream(Windows),Stream-Table,Table-Table
Stateless:filter,map, Stateful(use pre event):group by key,reduce,aggregation(sum,count,avg,max,min),join
Time Windows: https://kafka.apache.org/30/javadoc/org/apache/kafka/streams/kstream/TimeWindows.html
Session Windows: https://kafka.apache.org/30/javadoc/org/apache/kafka/streams/kstream/SessionWindows.html
SlidingWindows: https://kafka.apache.org/30/javadoc/org/apache/kafka/streams/kstream/SlidingWindows.html
ksqlDB
ksqlDB:distributed compute layer kafka:distributed storage layer
Streams:unbounded series of event. Table: the current state of event
Stateful Aggregations (Materialized Views)
ksqlDB can build a materialized view of state
Kafka is a database turned inside out
Data Mesh
software architecture vs data architecture
service mesh vs data mesh
broker配置
default.replication.factor
unclean.leader.election.enable
min.insync.replicas
producer配置
acks(0,1,all)
Confluent Course
APACHE KAFKA® INTERNAL ARCHITECTURE
Event Record RecordBatch
ISR/High Watermark/Leader Epoch
Leader Select: ISR and propagated through control plane
FetchRequest/FetchResponse
Reconciliation(协调) Logic
Data plane handles data replication
Consumer Group Protocol: Group Coordinator(Broker中), Group Leader(Consumer Group中)
Rebalance Protocol: distribute resources, stop-the-world rebalancing
Eager Rebalancing VS Incremental Cooperative Rebalancing(https://www.confluent.io/blog/incremental-cooperative-rebalancing-in-kafka/)
Partition Assignment Strategy
__consumer_offsets
Consumer Group Rebalance Notification
Stop-the-World Rebalance Avoid Needless State Rebuild with StickyAssignor Avoid Pause with CooperativeStickyAssignor Avoid Rebalance with Static Group Membership
Incremental Cooperative Rebalancing
一个topic,可以被多个消费组消费,但是每个消费组内的消费组,只能消费一次。
消费组
一个pod对应一个消费者,一个消费者对应一个分区,查看消费速度,如果部署了三个pod,那么只会并行有三个分区的消息被消费,
疑问:一秒消费多少条消息?
三个消费者五个分区,这时候消息模型是什么呢?来回切换?
./kafka-console-consumer.sh --bootstrap-server ns014:9092 --from-beginning --topic manhattan_message_refund
本地机器(本质是起了一个消费者)
./kafka-console-consumer.bat --bootstrap-server ns014:9092 --from-beginning --topic manhattan_message_refund
./kafka-console-producer.bat --topic manhattan_message_refund --broker-list 127.0.0.1:9092
【在2.5.0版本之前只支--broker-list 在2.5.0版本之后支持--bootstrap-server】
1 offset清除时间是什么?
2 长时间消费者没收到消息,会rebalance,
验证MQ有没有问题:
$ bin/kafka-topics.sh --create --topic quickstart-events --bootstrap-server localhost:9092
$ bin/kafka-topics.sh --describe --topic quickstart-events --bootstrap-server localhost:9092
$ bin/kafka-console-producer.sh --topic quickstart-events --bootstrap-server localhost:9092
$ bin/kafka-console-consumer.sh --topic quickstart-events --from-beginning --bootstrap-server localhost:9092
设计
https://docs.confluent.io/platform/current/kafka/design.html
实现
FAQ
https://developer.confluent.io/learn/apache-kafka-faqs/
其他
The Streams API in Kafka and Flink are used in both capacities. The main distinction lies in where these applications live — as jobs in a central cluster (Flink), or inside microservices (Streams API).
The Streams API makes stream processing accessible as an application programming model, that applications built as microservices can avail from, and benefits from Kafka’s core competency —performance, scalability, security, reliability and soon, end-to-end exactly-once — due to its tight integration with core abstractions in Kafka. Flink, on the other hand, is a great fit for applications that are deployed in existing clusters and benefit from throughput, latency, event time semantics, savepoints and operational features, exactly-once guarantees for application state, end-to-end exactly-once guarantees (except when used with Kafka as a sink today), and batch processing.
疑问
kafka一个topic多个消费组情况下,broker是怎么管理log的offset的呢,是每一个消费组提交自己的呢,还是共同提交?
类的API文档
https://docs.confluent.io/platform/current/clients/javadocs/javadoc/index.html
https://kafka.apache.org/30/javadoc/org/apache/kafka/clients/consumer/StickyAssignor.html
https://kafka.apache.org/30/javadoc/org/apache/kafka/clients/consumer/ConsumerPartitionAssignor.RebalanceProtocol.html
StickyAssignor CooperativeStickyAssignor
遇到问题
balance问题
自动创建topic问题
Streaming
book:making sense of stream processing
Data Integration Problem: Log VS Dual Write
The database is a cache of a subset of the log.
表:更新流,对事实的更新 流:事件流,无界事件
Ecosystem
Admin
Book
Designing Event-Driven System
turning the database inside out
using messaging as system of record
Kafka:The Definitive Guide Second Edition
Make Sense of Streaming Processing:The Philosophy behind Apache Kafka and Scalable Stream Data Platforms
Kafka权威指南-第二版
书名
作者:
分类:
相关书籍:
进度
阅读记录:开始时间:2024-08-08 ~ 结束时间:YYYY-MM-dd
阅读页数:
笔记
JBOD,RAID
偏移量提交:更新分区当前读取位置的操作。
kafka的可靠性是配置出来的。
Kafka对可靠性保证:
- 分区内消息有序。
- 消息被写入分区所有的同步副本时才被认为“已提交”。
- 只要一个副本活动,已提交消息不会丢失。
- 消费者只能读取已经提交的消息。
可靠性是:消息存储可靠性和一致性的重要程度与可用性,高吞吐,低延迟和硬件成本重要程度的一种权衡。
不同步副本:1.与zk断开连接 2.不在复制新消息 3.复制消息滞后了10s。
不同步副本和副本不可用是不同的。不同步副本不一定副本不可用,副本不可用,一定会不同步副本。
复制系数。
消费者提交偏移量+消费消息关系很重要。自动提交会导致重复消费。
可靠性是配置出来的:
broker配置:
1. 复制系数:replication.factor
2. 不彻底的首领选举:unclean.leader.election.enable
3. 最少同步副本:min.insync.replicas
4. 保持副本同步 zookeeper.session.timeout.ms(broker发送zk心跳间隔)和 replica.lag.time.max.ms(指定时间从leader复制数据),
5. 磁盘持久化:flush.message flash.ms
producer配置:
1. 发送确认:acks
2. 重试与幂等:delivery.timeout.ms enable.idempotence retries
consumer配置:
1. group.id
2. auto.offset.reset
3. enable.auto.commit
4. auto.commit.interval.ms
消费者经常重平衡,就不是可靠的。
自动提交偏移量:轮询结束时提交偏移量。轮询里提交。
手动提交偏移量:提交频率是性能与重复消息之间权衡。在正确时间点提交正确的偏移量,一定要在消息处理完之后提交偏移量。提交
已读取但未处理消息的偏移量导致消费者错过消息。消息错过比消息重复更严重。
kafka投递语义:至少一次,精确一次
消息丢失:1 生产者保证发出去(核心保证) 2 broker保证多副本+落磁盘 3 消费者保证不漏消息(消息还在,只是没有消费) 消息重复:1 生产者幂等 2 broker拒绝重复消息 3 消费者不重复消费(核心保证:处理消息+提交偏移量) 消息顺序:1 单分区消息有序(核心保证) 2 retries>0 && max.in.flight.requests.per.connection>1 && enable.idempotence=false,批次顺序可能会反,有重排序可能性。但是一个批次是有序的。retries>0 && max.in.flight.requests.per.connection=1也可以保证,但是可用性变低了。 enable.idempotence=true && max.in.flight.requests.per.connection<=5 && retries>0 可以保证有序+重试消息不重复。
消息写入成功指的是发送去确认acks=1,0,-1。和消息已经提交写入所有同步副本不是一个概念。acks=1写入leader,但是不一定提交了。 acks=-1,写入所有同步副本,但是没有重试,消息也会丢失。
不丢消息,重试,可能产生重复消息。
已提交消息(写入所有同步副本)和已提交偏移量(消费者发送kafka的偏移量,用于确认最后一条消息在分区位置)。
HW(HighWatermark),OSR(Out-Sync Relipcas),ISR(In-Sync Replicas),AR(Assigned Repllicas),LEO(LogEndOffset),LSO( LogStartOffset),CO(ConsumerOffset-已提交偏移量)
Lag=HW-CO或LEO-CO
kafka事务消息保证流处理模型:消费-处理-生产,保证原子多分区写入。提交偏移量到_consumer_offsets主题,写入结果到输出主题。
kafka实现精确一次性语义:1 幂等生产者(避免重试机制导致的重复处理) 2 事务(Stream精确一次性语义基础)
配置参数
broker
broker.id
listeners
zookeeper.connect
log.dirs
num.recovery.threads.per.data.dir
auto.create.topics.enable
auto.leader.rebalance.enable
delete.topic.enable
broker in os
vm.swappiness
vm.dirty_background_ratio
vm.overcommit_memory
net.core.wmem_default
net.core.rmem_default
net.ipv4.tcp_window_scaling
net.ipv4.tcp_max_syn_backlog
net.core.netdev_max_backlog
G1:MaxGCPauseMillis和InitiatingHeapOccupancyPercent
topic
num.partitions=1
default.replication.factor=1
log.retention.ms
log.retention.bytes
log.segment.bytes
log.roll.ms
min.insync.replicas
message.max.bytes
producer
bootstrap.server
key.serializer
value.serializer
client.id
acks
max.block.ms
delivery.timeout.ms
request.timeout.ms
retries
retry.backoff.ms
linger.ms
buffer.memory
compression.type
batch.size
max.in.flight.requests.per.connection
max.request.size
receive.buffer.bytes
send.buffer.bytes
enable.idempotence
consumer
fetch.min.bytes=1
fetch.max.wait.ms=500
fetch.max.bytes=52428800=50MB
max.poll.records=500
max.partition.fetch.bytes=1048576=1M
session.timeout.ms=10000=10秒
heart.interval.ms=3000=3秒
max.poll.interval.ms=300000=5分钟
default.api.timeout.ms=60000=1分钟
request.timeout.ms=30000=30秒
auto.offset.reset=latest
enable.auto.commit=true
partition.assignment.strategy:RangeAssignor,RoundRobinAssignor,StickyAssignor,CooperativeStickyAssignor,
client.id
client.rack
group.instance.id
receive.buffer.bytes
send.buffer.bytes
offsets.retention.minutes=10080=7天
Apache Kafka实战
深入理解Kafka
Apache Kafka源码剖析
Gradle-TODO
Gradle简介
Book
Gradle实战
Druid-TODO
Druid简介
Spring
Spring Core
container:configuration model + dependency injection
Lightweight and minimally invasive development with POJOs Loose coupling through DI and interface orientation Declarative programming through aspects and common conventions Eliminating boilerplate code with aspects and templates
Spring一个包里面的support都是接口的便利实现。
核心对象
BeanWrapper,PropertiesEditor
BeanFactory,XmlBeanFactory,ListableBeanFactory,DefaultListableBeanFactory
BeanDefinition
ApplicationContext,WebApplicationContext,XmlWebApplicationContext
ContextLoader/ContextLoaderListener/ContextLoaderServlet
ApplicationContext:ClassPathXmlApplicationContext,FileSystemXmlApplicationContext,GenericGroovyApplicationContext 最灵活的方式:GenericApplicationContext
metadata -> bean definition -> bean factory -> applcation context
xxxTemplate(JDBC,JMS)
Resource,AbstractResource,ResourceLoader
BeanDefinitionRegistry,BeanDefinition,
异常处理:受检成运行,捕获能处理
Spring源码先看Interface,在看Interface继承关系,在看AbstractInterface
AbstractInterface里面的protected方法和属性需要注意。没有protected属性,说明不是为了继承而设计的。
spring aop的实现?
spring ioc的实现?
spring 事务的实现?
IOC
instantiating, configuring, and assembling the beans
configuration metadata:XML, Java annotations, or Java code
bean definition:Class,Name,Scope,Constructor arguments,Properties,Autowiring mode,Lazy initialization mode,Initialization method ,Destruction method
autowiring collaborators
FactoryBean 自定义Bean创建 ProxyFactoryBean 代理包装Bean TransactionProxyFactoryBean 事务包装代理
dependencies are on interfaces or abstract base classes, which allow for stub or mock implementations to be used in unit tests
uml里面有association和dependency. 而dependency和ioc dependency不一样,ioc dependency是所有有关联的对象,而不在乎对象来自哪里。 结合起来看,就是依赖注入(IOC)成关联(UML)。
public class A {
}
public class B {
}
public class C { //此时没有办法注入A,B public void doTask(A a,B b){} }
main() { C c = new C(); c.doTask(new A(), new B()); }
这个依赖放在了方法上面了,
AOP
Aspect:跨多个类的模块化横切点 Join point:程序执行的地点。 Advice:程序执行的地方发生的操作。 Pointcut:满足程序执行地点的条件。 Introduction:代表类型声明其他方法或字段 Target object: 被多个Aspect Advice的对象 AOP proxy: Weaving:
join points matched by pointcuts is the key to AOP
auto-proxying
aop is proxy-based frameworks
动态代理失效: AspectJ does not have this self-invocation issue because it is not a proxy-based AOP framework.
Pointcut以及实现.
创建代理方式: Dependency on Spring IoC:ProxyFactoryBean是Spring创建代理的Bean,ProxyFactoryBean通过 Dependency on Programmatically: ProxyFactory Dependency on Auto-proxy:BeanNameAutoProxyCreator,DefaultAdvisorAutoProxyCreator
java代理发展:静态,动态。spring aop框架(可单独使用) java依赖管理:手动,spring ioc容器(可单独使用)
TransactionProxyFactoryBean
Data Access
JDBC,DAO(二级抽象),ORM(JPA,Hibernate),Spring-Data-JDBC,spring-boot-starter-data-jdbc 一级(低级别抽象):一个控制JDBC工作流程和错误处理的框架。 org.springframework.jdbc.core 核心JdbcTemplate 二级(高级别抽象):RDBMS操作建模Java对象操作 - org.springframework.jdbc.object 核心RdbmsOperation ORM:org.springframework.orm
mybatis,spring-mybatis,spring-mybatis-starter
AOP:Advisor=Advice+PointCut
AOP
JavaBean+ProxyFactory=Proxy JavaBean
JavaBean+ProxyFactory+TransactionInterceptor=Proxy Transaction JavaBean
JavaBean+TransactionProxyFactoryBean=Proxy Transaction JavaBean
其他感悟
Spring从来不用别人接口,都是自己定义接口。
Spring源码先读接口和实现类,此垂直为类之职责。在读关联,此水平为类之交互。
Spring WebMVC
SpringWeb
SpringWebMVC
Spring Test
https://github.com/xiaozhiliaoo/spring-test-practice
Spring Boot
https://docs.spring.io/spring-boot/docs/current/reference/html/index.html
看到这里了:https://docs.spring.io/spring-boot/docs/current/reference/html/features.html#features.testing.spring-boot-applications.spring-mvc-tests
Notes
Core
Convention_over_configuration
embed,starter,autoconfigure,production-ready features,no code generation
Project Structure
spring-boot-starter-xxx
spring-boot-xxx-autoconfigure
spring-boot-xxx
springboot的结构 spring-boot-starter spring-boot-autoconfigure spring-boot
springboot-test结构 spring-boot-starter-test(spring-boot-starter) spring-boot-test-autoconfigure spring-boot-test
springboot-actuator结构 spring-boot-starter-actuator(spring-boot-starter) spring-boot-actuator-autoconfigure spring-boot-actuator
Configuration Metadata
配置
Features
Liveness State Readiness StateL
Spring’s Environment abstraction
Database版本化管理:MyBatis Migrations,liquibase,flyway
https://metrics.ryantenney.com/ Spring integration for Dropwizard Metrics
Actuator(运维能力)
文档:https://docs.spring.io/spring-boot/docs/current/reference/html/actuator.html
数据通过http/jmx接口暴露
spring-boot-actuator
spring-boot-starter-actuator
spring-boot-actuator-autoconfigure
Health:HealthContributor,HealthIndicator
Information:InfoContributor
Endpoint:和应用检测和交互的点。提供了很多内置的Endpoint.
Actuator Web API:https://docs.spring.io/spring-boot/docs/2.6.4/actuator-api/htmlsingle/#overview
BeansEndpoint,BeansEndpointAutoConfiguration
Endpoint可以通过Http或者JMX暴露出去,这个是怎么实现的呢?
dropwizard,micrometer(Spring Boot 2: Migrating From Dropwizard Metrics to Micrometer)
Auto Configuration
spring-boot-autoconfigure
疑问:
starter里面的autoconfigure是怎么配置第三方库的呢?
mybatis-spring-boot-starter mybatis-spring-boot-autoconfigure mybatis-spring mybatis
spring的autoconfigure的配置类不在原来库代码里面,这是怎么做到的呢?而common-xxx配置类在库实现里面。 以上例子是经典例子, mybatis-spring配置了mybatis,从而在FactoryBean(Spring)获取SqlSessionFactory(MyBatis),是真实的创建了MyBatis的对象的, 但是mybatis-spring-boot-autoconfigure配置了mybatis,也创建对象。这就是自动装配。这一步是通过spring.factories文件实现的。
Spring的配置Bean概念,Configuration(配置的Bean),ConfigurationProperties(配置Bean的属性),autoconfigure指的是自动装配Bean.而在自动 装配过程中,用到了Properties
Spring Boot的设计是加载应用级配置,随后再考虑自动配置类。
单元测试专注于单一组件或组件中的一个方法,此处并不一定要使用Spring。Spring提供了 一些优势和技术——松耦合、依赖注入和接口驱动设计。这些都简化了单元测试的编写。但Spring 不用直接涉足单元测试,集成测试会涉及众多组件,这时就需要Spring帮忙了。
Spring Boot和Grails
HttpTrace默认的类,InMemoryHttpTraceRepository,100条,持久化实现需要继承HttpTraceRepository类
深入Spring Boot应用程序的内部细节:Actuator
ConfigurationProperties和Environment区别?
程序的配置,传入到
Spring Boot Admin
https://codecentric.github.io/spring-boot-admin/
注册方式:Admin Client或者Discovery Client
服务通过Admin Cli ent注册到Admin Server上了。
Service引入Admin Client把自己ip注册到Admin Service,然后Admin Service读取Admin Client的actuator接口?
Admin Client注册的类:ApplicationRegistrator,注册到Admin Server的InstancesController#register方法了。
Admin Server提供了三个Controller来接受请求,InstancesController,ApplicationsController,InstancesProxyController
Admin Server通过InstanceWebClient调用Service. 从而对Service进行控制。
核心实体类:Application,Instance,InstanceEvent(注册,不注册,状态更新,),Registration,InstanceEventStore
注册信息存在了哪里?InstanceEventStore,默认注册在内存中了。
基于事件的注册,将事件注册到内存中。
Spring Cloud Common
https://docs.spring.io/spring-cloud-commons/docs/current/reference/html/
Core Class
SpringApplication SpringApplicationBuilder BootstrapConfiguration
DiscoveryClient ServiceRegistry LoadBalancerClient
Notes
Cloud核心包: Spring Cloud Context and Spring Cloud Commons and Spring Cloud Load Balancer and Circuit breaker
child contexts inherit property sources and profiles from their parent
common patterns: service discovery, load balancing, and circuit breakers
springcloud common loadbalance and spring cloud loadbalance 区别是什么?
common里面提供的接口,并没有提供实现,而spring cloud loadbalance提供了实现。 service discovery/register 实现:consul,zk,eureka load balancing 实现:spring cloud loadbalance circuit breaker实现:Resilience4J,Sentinel,Spring Retry(Spring Cloud Circuit Breaker)
一些新的endpoint,引入了spring-boot-actuator,refresh,restart,pause,env
Refresh入口类是:RefreshEndpoint,RefreshScope实现了GenericScope,GenericScope实现了Scope类, 也就是@RefreshScope是@Scope("refresh")
Spring Cloud Consul
https://cloud.spring.io/spring-cloud-consul/reference/html/
lookup service:
Spring Cloud Config
https://cloud.spring.io/spring-cloud-config/reference/html/
Core Class
Environment
EnvironmentRepository实现类JGitEnvironmentRepository ,通过Eclipse JGit实现
Notes
The Config Server runs best as a standalone application
other external property sources
Config Client:Config First Bootstrap,Discovery First Bootstrap
Spring Cloud Gateway
Spring Cloud OpenFeign
https://docs.spring.io/spring-cloud-openfeign/docs/current/reference/html/
Spring Integration
Spring Others
Book
Spring实战第四版
SpringBoot解密
KVStore
Redis
The world’s most loved real‑time data platform
MapDB
MinIO
https://github.com/minio/minio-go
Etcd
分布式事务
atomikos
seata
Book
深入理解分布式事务
正本清源分布式事务之Seata
Library
apache-httpcomponents
https://hc.apache.org/httpcomponents-client-4.5.x/current/tutorial/html/fluent.html
Logback
apache-poi
Server-Sent-Events
https://en.wikipedia.org/wiki/Server-sent_events
https://www.youtube.com/watch?v=2To3_mYT2hc&t=8s
https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events
https://docs.spring.io/spring-framework/docs/current/reference/html/web.html#mvc-ann-async-sse
dom4j
lombok
@Cleanup
logstash-logback-encoder
https://github.com/logfellow/logstash-logback-encoder
jmx
spring对jmx的处理:
step1:在spring-framework里面封装jmx,MBeanExporter,AnnotationMBeanExporter
step2:在spring-autoconfigure中自动配置jmx,JmxAutoConfiguration
step3:在spring-boot-actuator中通过JmxEndpointExporter将endpoint暴露出去,endpoint本身可以通过http和jmx暴露。 spring-boot-actuator-autoconfigure中配置JmxEndpointAutoConfiguration
step4:在spring-boot-admin中通过jolokia暴露所有jmx(endpoint和其他jmx)
https://docs.oracle.com/javase/tutorial/jmx/overview/index.html
https://docs.spring.io/spring-framework/docs/current/reference/html/integration.html#jmx
https://docs.spring.io/spring-boot/docs/current/reference/html/actuator.html#actuator.jmx
https://codecentric.github.io/spring-boot-admin/2.5.1/#jmx-bean-management
JDK自带的MBean
java.lang.management
BufferPoolMXBean ClassLoadingMXBean CompilationMXBean GarbageCollectorMXBean MemoryMXBean OperatingSystemMXBean RuntimeMXBean ThreadMXBean
单元测试
junit5
参数化测试:减少样板代码
API: ExecutionCondition
JUnit Jupiter’s org.junit.jupiter.api.Assertions class does not provide an assertThat() method like the one found in JUnit 4’s org.junit.Assert
Assumptions的作用是什么?
mode:per-class,per-method
@Nested:测试之间的关系以及测试结构
assertj
mockito
Mockito
Mockito
when...thenXXX(not void) ... invoke when...thenAnswer ... ... invoke
doXXX...when (void)... invoke doAnswer...when(void)... invoke
doAnswer使用场景是什么?测试有参数无返回值,无参数无返回值.
BDDMockito
BDDMockito
given...willReturn
verify
Argument matchers ArgumentCaptor
@Mock @Spy @Captor @InjectMocks
SpringBoot: @MockBean @SpyBean
@Mock和@MockBean区别是什么? @Mock和@InjectMocks区别是什么? doAnswer.when和when thenReturn和when thenAnswer和doReturn when区别区别? doAnswer.when返回空,就是void方法。
组合: @Mock和@InjectMock @MockBean和@Autowired
Use doAnswer() when you want to stub a void method with generic Answer.
jacoco
Book
有效的单元测试
Database
MySQL
Change Data Capture Canal
Linkedin Databus All Aboard the Databus!
Facebook Wormhole Wormhole: Reliable Pub-Sub to Support Geo-replicated Internet Services
Yahoo Sherpa(PNUTS to Sherpa: Lessons from Yahoo!’s Cloud Database )
Bottled Water Postgres
Maxwell/Debezium
Mongoriver oplog tailer
Oracle GoldenGate
Kafka Connect
Doris
MongoDB
MongoDB
Cassandra
Config
建表核心配置
bloom_filter_fp_chance
caching
compaction
compression
crc_check_chance
dclocal_read_repair_chance
default_time_to_live
gc_grace_seconds
max_index_interval
memtable_flush_period_in_ms
min_index_interval
read_repair_chance
speculative_retry
建表案例
CREATE TABLE course_process.user_process (
userid text,
courseid text,
lessonid text,
all bigint,
duration bigint,
finish bigint,
mark bigint,
time bigint,
PRIMARY KEY (userid, courseid, lessonid)
) WITH CLUSTERING ORDER BY (courseid ASC, lessonid ASC)
AND bloom_filter_fp_chance = 0.01
AND caching = {'keys': 'ALL', 'rows_per_partition': 'NONE'}
AND comment = ''
AND compaction = {'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32', 'min_threshold': '4'}
AND compression = {'chunk_length_in_kb': '64', 'class': 'org.apache.cassandra.io.compress.LZ4Compressor'}
AND crc_check_chance = 1.0
AND dclocal_read_repair_chance = 0.1
AND default_time_to_live = 0
AND gc_grace_seconds = 864000
AND max_index_interval = 2048
AND memtable_flush_period_in_ms = 0
AND min_index_interval = 128
AND read_repair_chance = 0.0
AND speculative_retry = '99PERCENTILE';
CREATE INDEX lesson_index ON course_process.user_process (lessonid);
Operation
Admin
cqlsh node
nodetool -h host -p port describecluster
应用表
查看所有命令: HELP;
查看集群信息(没选keyspace):DESCRIBE CLUSTER ;
查看集群信息(选了keyspace):DESCRIBE CLUSTER ;
查看cassandra版本:SHOW VERSION ;
所有keyspace: DESCRIBE KEYSPACES;
某个keyspace: USE xxx; DESCRIBE KEYSPACE; 或 DESCRIBE KEYSPACE xxx;
某个keyspace所有表:USE xxx; DESCRIBE TABLES;
某个keyspace某个表: USE xxx; DESCRIBE TABLE tableName;
一致性级别:CONSISTENCY;
清理表数据:TRANCATE tableName;
清除表结构:DROP TABLE tableName;
查询时间:select userId,writetime(answer) from user_answer ;
新加列:ALTER TABLE tableName ADD columnName text;
删除列:ALTER TABLE tableName DROP columnName;
创建二级索引:CREATE INDEX indexName ON tableName(columnName);
删除二级索引:DROP INDEX indexName;
插入:INSERT INTO tableName(columnName1,columnName2) VALUES ('value1','value2');
更新:UPDATE tableName SET columnName='value1' WHERE columnName2='xxx';
删除某个列的值:DELETE columnName FROM tableName WHERE columnName2='xxx';
删除行:DELETE FROM tableName WHERE columnName2='';
总数:select count(*) from tableName;
系统表
select broadcast_address from system.local;
select peer,rack,rpc_address from system.peers;
select keyspace_name,columnfamily,generation from system.sstable_activity;
查找repair记录:select keyspace_name,columnfamily_name,exception_message from system_distributed.repair_history ;
查找二级索引:select keyspace_name,table_name,index_name from system_schema.indexes ;
system_schema包括:aggregates,dropped_columns,indexes,tables,types,columns,functions,keyspaces,triggers,views;
查找所有表:SELECT * FROM system_schema.tables where table_name='user_process' allow filtering;
查找所有UDT:SELECT * FROM system_schema.types;
查找所有的Materialized Views:SELECT * FROM system_schema.views;
查找所有
其它
打开trace , TRACING ON, 然后select数据,发现每一步耗时。查看trace命令,select * from system_traces.sessions ;查看trace的事件,select * from system_traces.events
System
进度
笔记
基础知识
CQL
不支持join,like,非主键查询,支持需要allowing filter,二级索引,或者SASI,物化视图。
SASI:LIKE,SPARSE INDEX。 memory mapped B+ trees,不支持集合索引,普通二级索引支持。
函数:ttl,writetime,token
配置
基本知识
ER图是概念建模,关系型和非关系是逻辑建模。具体到数据库是物理建模。
Clustered Index and Secondary Indexes:聚簇索引只有一个,优先primary key 没有就是unique key,两个都没有,innodb自动生成。看来唯一索引也是非聚簇的,唯一索引也能建多个,是非聚簇的,也能为空,能多个都是空,但是不能重复。 https://dev.mysql.com/doc/refman/5.7/en/innodb-index-types.html
数据建模:Chebotko method,query driven,primary key=partation key + clustering key,把表想象成一个分区表。【https://cassandra.apache.org/doc/latest/cassandra/data_modeling/index.html】
write-once immutable ordered data model
Release Note: https://gitbox.apache.org/repos/asf?p=cassandra.git;a=blob_plain;f=CHANGES.txt;hb=refs/tags/cassandra-4.0.0
cassandra是宽列行存储引擎。数据模型是列存(Wide Column Stores ),但是磁盘是行存。hbase和bigtable也是。面向列 的磁盘存储一般在数仓较多,如clickhouse,druid,greenplum,还有关系型分为行存和列存。
https://en.wikipedia.org/wiki/List_of_column-oriented_DBMSes
Apache Parquet is an open source, column-oriented data file format designed for efficient data storage and retrieval
TiDB(行存) TiFlash(列存)
OLTP(行存) OLAP(列存)
先读bigtable(2006),dynamo(2007),cassandra(2009)的paper.
范式:one table serve many queries 反范式:one table serve one query
数据建模cassandra风格: 数据查询在一起,存储应该在一起,保持分区和结果集小,使用高基数的key,表是为了查询而建的,没有全表扫描
https://en.wikipedia.org/wiki/Apache_Cassandra
read path和write path发生了什么?
compaction类型minor,major,user defined,scrub 和策略:STCS,LCS,TWCS
多维hashmap
读取很快,简单的查询模型,数据在一起查询那么应该存在一起,使用高基数的key,
数据时间 ttl
cassandra datastax driver三种模式:statement,mapper,accessor + spring data cassandra
column families 也叫 tables
副本修复方式:read repair,hinted handoff
计数器可以有多个counter,但是不能出现非主键key。
Cassandra uses a Last-Write-Wins Element-Set conflict-free replicated data type for each CQL row。
SSTable Attached Secondary Index (SASI): LIKE
CODD 12条原则,5大范式。
除了主键外的每一列都有时间戳,那么设置更新时间就没有意义了,关系型每一个是一个完整的时间。
运维
compaction
gc_grace_seconds=10d
hints
max_hint_windowin_ms=3h
百科
workshop
https://github.com/DataStax-Academy/cassandra-workshop-series
person
[Avinash Lakshman]
[Prashant Malik]
Jeffrey Carpenter Jeffrey Carpenter
Site
https://www.intel.com/content/www/us/en/silicon-innovations/intel-tick-tock-model-general.html
https://cwiki.apache.org/confluence/display/cassandra
Common-Error
Query
-
[Invalid query] message="ORDER BY is only supported when the partition key is restricted by an EQ or an IN."。
order by 操作必须在分区key是 == 或者 in的时候下才可以使用。不能排序分区键,因为需要遍历所有分片。
-
[Invalid query] message="Order by currently only support the ordering of columns following their declared order inthe PRIMARY KEY"。
orderby必须是主键指定的顺序。
-
InvalidRequest: Error from server: code=2200 [Invalid query] message="Cannot rename non PRIMARY KEY part createtime"。 不能重命名非PRIMARY KEY。
-
InvalidRequest: Error from server: code=2200 [Invalid query] message="Invalid operation (studytimechange =studytimechange + 1000) for non counter column studytimechange" 累加操作必须在counter类型字段上面。
-
InvalidRequest: Error from server: code=2200 [Invalid query] message="Cannot mix counter and non counter columns in the same table"。 计数器列可以多个,但是必须非主键之外所有键。
-
InvalidRequest: Error from server: code=2200 [Invalid query] message="Order by currently only support the ordering of columns following their declared order in the PRIMARY KEY" 排序字段只能是PRIMARY KEY定义的顺序。
-
InvalidRequest: Error from server: code=2200 [Invalid query] message="Cannot execute this query as it might involve data filtering and thus may have unpredictable performance. If you want to execute this query despite the performance unpredictability, use ALLOW FILTERING"。 原来查询:select * from answers_by_user where courseid=1; 现有查询:select * from answers_by_user where courseid=1 allow filtering; 其他方法:change your data model add an index, use another table use ALLOW FILTERING
-
InvalidRequest: Error from server: code=2200 [Invalid query] message="User-defined functions are disabled in cassandra.yaml - set enable_user_defined_functions=true to enable" UDF没有打开。UDF没有打开,那么UDA也用不了。因为UDA借助两个UDF。
-
InvalidRequest: Error from server: code=2200 [Invalid query] message="Invalid non-frozen user-defined type for PRIMARY KEY component address"。 非冻结的UDT不能作为主键的一部分,而冻结的UDT可以作为主键的一部分。
-
InvalidRequest: Error from server: code=2200 [Invalid query] message="Unsupported order by relation"。 orderby必须是集群键指定的顺序,不可以相交。 建表默认是a asc,b asc,order by b asc,c desc; order by b desc,c asc; 均会失败,order by a asc,b asc 或 a desc,b desc均会成功。
-
InvalidRequest: Error from server: code=2200 [Invalid query] message="INSERT statements are not allowed on counter tables, use UPDATE instead" counter类型不能直接插入,需要直接UPDATE。
-
InvalidRequest: Error from server: code=2200 [Invalid query] message="Cannot directly modify a materialized view" 不能insert,delete物化视图,物化视图修改只能由基础表来派生。
-
InvalidRequest: Error from server: code=2200 [Invalid query] message="Cannot TRUNCATE materialized view directly; must truncate base table instead" 不能TRUNCATE物化视图。
-
InvalidRequest: Error from server: code=2200 [Invalid query] message="Cannot execute this query as it might involve data filtering and thus may have unpredictable performance. If you want to execute this query despite the performance unpredictability, use ALLOW FILTERING" 在执行((a,b),c)建表索引时候,查询条件只带了where a=xxx,会导致这个报错,因为分区key没有完整,应该是where a=xxx and b=xxx。。
-
副本因子只能配置在keyspace级别,也即复制策略在一个keyspace级别,或者一个数据中心级别,不能配置在table级别。
-
如果索引是((a,b),c),那么查询至少是where a=xxx and b=yyy,而不能直接a=xxx。
-
如果索引是(a,b,c),那么默认第一个是分区键,b,c是排序键。
开源项目的代码案例研究
cassandra-workshop-series
- https://github.com/DataStax-Academy/cassandra-workshop-series
killrvideo-java
- https://github.com/KillrVideo/killrvideo-java
主要是core和mapping,GRPC,大量CF,
workshop-spring-data-cassandra
- https://github.com/datastaxdevs/workshop-spring-data-cassandra
workshop-ecommerce-app
- https://github.com/datastaxdevs/workshop-ecommerce-app
基于SpringDataCassandra写的。
DataStax-Examples
- https://github.com/DataStax-Examples/
cassandra-guide
https://github.com/jeffreyscarpenter/cassandra-guide
基于core写的。没有mapper。
参考
dbdb.io: https://dbdb.io/db/cassandra
https://github.com/xiaozhiliaoo/cassandra-practice
java客户端:https://docs.datastax.com/en/developer/java-driver/4.13/
spring-data-cassandra: https://docs.spring.io/spring-data/cassandra/docs/current/reference/html/#preface
scylladb:C++写的cassandra. https://www.scylladb.com/resources/introduction-to-apache-cassandra/
术语:https://docs.datastax.com/en/glossary/doc/glossary/glossaryTOC.html
https://cwiki.apache.org/confluence/display/CASSANDRA2/Home
https://cwiki.apache.org/confluence/display/CASSANDRA/Home
Merkle tree:http://people.eecs.berkeley.edu/~raluca/cs261-f15/Merkle.html
https://en.wikipedia.org/wiki/Ralph_Merkle https://ralphmerkle.com/
静态列的值所有行都一样,最新的会覆盖其他列的。
paper
Backup and Recovery Mechanisms of Cassandra Database: A Review
Gossip : http://awinterman.github.io/simple-scuttle/
Facebook’s Cassandra paper, annotated and compared to Apache Cassandra 2.0 : https://docs.datastax.com/en/articles/cassandra/cassandrathenandnow.html
source code
C* Summit 2013: Cassandra Internals
https://www.youtube.com/watch?v=W6e8_IcgJM4
API Layer/Dynamo Layer/Database Layer
Data Access
存储层封装的演进
JDBC->commons-dbutils->Template->ORM(MyBatis)->Spring Data 每一次演进的本质区别是什么。
为什么要有common-cassandra
assandra datastax driver有三种模式:statement,mapper,accessor,spring data cassandra
开源的很好,但是很复杂,学习成本很高。开发只能记住最简单的使用。
功能
支持直接注入@Autowired Accessor(启动时候引入@Accessor)
加了些配置。和方便开发使用。”没有新加机制“。
新的机制。
Ecosystem
Book
peer-to-peer systems
DataStax Academy DS201
DS201.01 Course Introduction | Foundations of Apache Cassandra
Basic
partition key data haah to ring group by consistent hash
copy命令,外界导入cassandra数据。
PRIMARY KEY: unique record, control order
PRIMARY KEY:paration key, cluster column(查询必须先确认分区,然后才能查询)
分布式特性:读写路径。
如何改变默认顺序。cluster column。
主键插入不会报错,但是会覆盖数据。
顺序在磁盘,二分搜索会有有效。
ALLOW FILTERING:https://www.datastax.com/blog/allow-filtering-explained
一个节点2-4T。
Partitioner
hash partition key to get prtition token
Node.
数据存在distributed hash table
6000-12000 transaction/second/core 2-4TB
Nodetool
Ring
-2^63 ~ 2^63 -1
CLuster叫Ring.每个节点管理一段范围数据,叫token range. 协调节点知道token range. token range 是partitioner分配的。
不停机。种子节点,对等节点。driver is aware of which token range belong to which node, which replica. TokenAwarePolicy:避免协调节点,驱动知道数据在哪一个节点。 RoundRobinAwarePolicy:随机选择ring中的节点。 DCAwreRoundRobinPolicy:指定数据中心。
Peer 2 Peer
Leader-Follower。选举期间不可用。
P2P 不用选举,但是有协调节点。处理网络分区是怎么处理的?keep always online。
VNode
如果新加入节点,会导致数据迁移压力全在一个节点,VNode会从不同节点拉取数据。keep cluster balance。
add/remove node with vnode help keep cluster balanced. each node has 128 vnode. vnode automate token range assignment. 配置参数 num_tokens.
Gossip
数据复制是通过gossip吗?不是,传递的是metadata。
seed nodes就是开始节点。
gossip:node/cluster metadata,not client data
Endpoint State:https://github.com/facebookarchive/cassandra/blob/master/src/org/apache/cassandra/gms/Gossiper.java
uses the Gossip protocol to distribute nodes' status amongst its peers.
Snitch
which node belong where
cassandra.yml:endpoint_snitch:SimpleSnitch
cloud base snitch
dynamic snitch
改变这个需要重启集群。
Replication
ring replicate data
replication factor: 1 RF:2 each node store two copies. neighbors store neighbors data store.
一般是 RF=3. 3台机器宕机情况很少。
Consistency
RF+CL(Consitency Level)
replication factor
RF=3(数据存三份) CL=one(一个replica回复即可) CL=QUROUM(2个,不能容忍分区容错得) CL=ALL(3个必须回复)
强一致性:读到最新写的。
WRITE CL:ALL READ CL:ONE
CL ONE: 写入很快,(IOT,时序数据,log data) always online。
写入很快,读取较慢。W(1)+R(2)>N(3).
如果W=2,意味着两个节点写入了吗?还是响应?
consistency 和 latency 取舍。(PACELC)
consistency默认是one.
Hint Handoff
rf=3,4个node,协调节点写入一个node失败,协调节点会存储。等节点成功,再次传递。默认3小时。
RF=3,4个node,1个node宕机,CL=one,two。协调节点会返回成功,three,协调节点会返回错误。
CL=any的话,生产环境不建议,协调节点会存储所有hint suffices,CL=one,至少会写入一个成功。如果超过hint hand off 时间窗口,协调节点会删除数据。如果协调节点宕机,会失去所有数据。 CL=one,至少一个replicate node会存储成功。
Availability can affect data consistency. Hinted-handoff helps Apache Cassandra(TM) maintain consistency even when a node is down.
Read Repair
Node=4,RF=3,CL=ALL,Node1 Data,Node 2,3 摘要(checksum) Node4 协调。
checksum不一样,说明数据不一致。
CL=ALL,一致性越少,越读不到最新数据。
nodetool full repair sync all data in cluster.
read_repair_chance: Sets the probability which Cassandra will perform a read repair with a consistency level less than ALL.
Read repair is always occurs when consistency level is ALL.
Node Sync
node sync vs full repair
full repair对集群性能影响较大。
CREATE TABLE nodesync = true,在表级别,默认关闭。
Write Path
HDD:commit log, SSTable
RAM:MemTable
commit log总是写入顺序,memtable 不是写入顺序。
SSTable和MemTable 保证clustering column有序,commit log保证写入有序。
Read Path
如何在SStable读取,如何在Memtable读取数据?
Bloom Filter:space和精确性权衡。
disk:SSTable(不可变的),partition index
Compaction
合并SSTable:先合并partition数据,然后合并partition。合并完之后删除旧的SSTable。
三种策略:SizeTiered,Leveled,TimeWindows。
gc_grace_second 10天。864000 seconds (10 days).
Performance
DS210: Operations for Apache Cassandra™ and DataStax Enterprise
DataStax Academy DS220
Admin
向量数据库
Milvus
Qdrant
Golang
go spec
地址:https://go.dev/ref/spec
go blog
Russ Cox,Rob Pike
主题 | 有视频 | 完成时间 | 地址 | 核心 |
---|---|---|---|---|
goprotobuf | N | https://go.dev/blog/protobuf | ||
JSON-RPC | N | https://go.dev/blog/json-rpc | ||
斯坦福Rob Pike talk | Y | https://go.dev/blog/new-talk-and-tutorials | ||
Google IO大会 | Y | https://go.dev/blog/io2010 | ||
声明格式 | N | https://go.dev/blog/declaration-syntax | ||
并发模型 | N | https://go.dev/blog/codelab-share | ||
Defer, Panic, and Recover | N | https://go.dev/blog/defer-panic-and-recover | ||
并发模式:超时 | N | https://go.dev/blog/concurrency-timeouts | ||
项目实战:SmartTwitter | N | https://go.dev/blog/smarttwitter | ||
Debug | N | https://go.dev/blog/debug-status | ||
go std
标准库 https://pkg.go.dev/std
- 操作字符串重要的包:bytes,strings,strconv,unicode
- 比较字节slice:bytes.Equals
- strings.Map 对每个字符使用函数
- 格式化 fmt
- 操作系统 os
- 缓冲io:bufio
- io工具类:ioutil
- 数学:math
- 随机数:math/rand
- 图片:image
- http:net/http
- 时间:time
- 同步:sync
- 命令行:flag
- json:encoding/json
- 大数:math/big
- sha265摘要:crypto/sha256
- 排序 sort
- 模板 text/template html/template
- 日志:log
- 正则:regexp
- 运行时:runtime 转储栈:Stack
- rpc:net/rpc jsonrpc net/rpc/jsonrpc
- 序列化 encode/gob
扩展库 https://pkg.go.dev/golang.org/x
-
exp:slices,maps
-
sync:errgroup,semaphore,syncmap,singleflight
go talks
Go at Google: Language Design in the Service of Software Engineering https://go.dev/talks/2012/splash.article
GopherCon 2016: Francesc Campoy - Understanding nil https://www.youtube.com/watch?v=ynoY2xz-F8s
Another Go at Language Design https://www.youtube.com/watch?v=7VcArS4Wpqk
Null References The Billion Dollar Mistake https://www.youtube.com/watch?v=YYkOWzrO3xg
Errors are values https://go.dev/blog/errors-are-values
effective go
go语言源码:https://go.dev/src/
talks:https://go.dev/talks/
格式化:gofmt
注释:块注释,行注释 https://go.dev/doc/comment
名字:包名,Getter,接口名字
分号:
控制结构:for,swtich,if,break,contine,select
方法:函数和指针
Embedding(嵌入)
接口转换,类型声明
下划线标识符
Do not communicate by sharing memory; instead, share memory by communicating. CSP Linux Pipeline
function literals are closures
channel用来同步的,信号结束的。
带缓冲的channel可以用作信号量。
Go是一个并发语言,而不是一个并行语言,不是所有并行问题都适用于Go模型。详见讨论:Concurrency is not parallelism https://go.dev/blog/waza-talk
泄露的Buffer
type switch
真实库函数应该避免panic。
recover always returns nil unless called directly from a deferred function
recover is only useful inside deferred function
re-panic idiom changes the panic value if an actual error occurs
Go is powerful enough to make a lot happen in a few lines
扩展
Concurrency is not parallelism https://go.dev/talks/2010/io/balance.go
https://go.dev/talks/2012/waza.slide#1
Communicating sequential processes C. A. R. Hoare 1978
channel没有locking
关键想法:数据结构使用channel和goroutines去构建并发, 结果是扩展性,简单,正确,并且没有锁。这种架构的好处。
Concurrency is about dealing with lots of things at once. Parallelism is about doing lots of things at once.
Don't communicate by sharing memory, Share memory by communicate.
Go Concurrency Patterns https://go.dev/talks/2012/concurrency.slide#1
channel是同步工具,同步拆解为 send receive
并发模式:
Generator:Function return a channel
Channel as a handler on a service
Multiplexing
Restoring sequencing
select
timeout using select
timeout for whole conversation using select
receive on quit channel
Daisy chain:菊花链
Advanced Go Concurrency Patterns https://go.dev/talks/2013/advconc.slide#1
go run -race main.go Race Detector(Sync Issues)
for{
select {
}
}
select:no lock , no condtion
代码规范
Google Go 规范:https://google.github.io/styleguide/go/
pb最佳实践:https://protobuf.dev/programming-guides/dos-donts/
api最佳实践:https://protobuf.dev/programming-guides/api/
Go在线书籍
https://go-kratos.dev/ go微服务框架
Go语言高级编程:https://chai2010.cn/advanced-go-programming-book/index.html
Go 语言编程之旅:https://golang2.eddycjy.com/
Go语言各种文档: https://learnku.com/go/docs
Go语言原本 :https://golang.design/under-the-hood/
Golang
go spec
地址:https://go.dev/ref/spec
go blog
Russ Cox,Rob Pike
主题 | 有视频 | 完成时间 | 地址 | 核心 |
---|---|---|---|---|
goprotobuf | N | https://go.dev/blog/protobuf | ||
JSON-RPC | N | https://go.dev/blog/json-rpc | ||
斯坦福Rob Pike talk | Y | https://go.dev/blog/new-talk-and-tutorials | ||
Google IO大会 | Y | https://go.dev/blog/io2010 | ||
声明格式 | N | https://go.dev/blog/declaration-syntax | ||
并发模型 | N | https://go.dev/blog/codelab-share | ||
Defer, Panic, and Recover | N | https://go.dev/blog/defer-panic-and-recover | ||
并发模式:超时 | N | https://go.dev/blog/concurrency-timeouts | ||
项目实战:SmartTwitter | N | https://go.dev/blog/smarttwitter | ||
Debug | N | https://go.dev/blog/debug-status | ||
go std
标准库 https://pkg.go.dev/std
- 操作字符串重要的包:bytes,strings,strconv,unicode
- 比较字节slice:bytes.Equals
- strings.Map 对每个字符使用函数
- 格式化 fmt
- 操作系统 os
- 缓冲io:bufio
- io工具类:ioutil
- 数学:math
- 随机数:math/rand
- 图片:image
- http:net/http
- 时间:time
- 同步:sync
- 命令行:flag
- json:encoding/json
- 大数:math/big
- sha265摘要:crypto/sha256
- 排序 sort
- 模板 text/template html/template
- 日志:log
- 正则:regexp
- 运行时:runtime 转储栈:Stack
- rpc:net/rpc jsonrpc net/rpc/jsonrpc
- 序列化 encode/gob
扩展库 https://pkg.go.dev/golang.org/x
-
exp:slices,maps
-
sync:errgroup,semaphore,syncmap,singleflight
go talks
Go at Google: Language Design in the Service of Software Engineering https://go.dev/talks/2012/splash.article
GopherCon 2016: Francesc Campoy - Understanding nil https://www.youtube.com/watch?v=ynoY2xz-F8s
Another Go at Language Design https://www.youtube.com/watch?v=7VcArS4Wpqk
Null References The Billion Dollar Mistake https://www.youtube.com/watch?v=YYkOWzrO3xg
Errors are values https://go.dev/blog/errors-are-values
effective go
go语言源码:https://go.dev/src/
talks:https://go.dev/talks/
格式化:gofmt
注释:块注释,行注释 https://go.dev/doc/comment
名字:包名,Getter,接口名字
分号:
控制结构:for,swtich,if,break,contine,select
方法:函数和指针
Embedding(嵌入)
接口转换,类型声明
下划线标识符
Do not communicate by sharing memory; instead, share memory by communicating. CSP Linux Pipeline
function literals are closures
channel用来同步的,信号结束的。
带缓冲的channel可以用作信号量。
Go是一个并发语言,而不是一个并行语言,不是所有并行问题都适用于Go模型。详见讨论:Concurrency is not parallelism https://go.dev/blog/waza-talk
泄露的Buffer
type switch
真实库函数应该避免panic。
recover always returns nil unless called directly from a deferred function
recover is only useful inside deferred function
re-panic idiom changes the panic value if an actual error occurs
Go is powerful enough to make a lot happen in a few lines
扩展
Concurrency is not parallelism https://go.dev/talks/2010/io/balance.go
https://go.dev/talks/2012/waza.slide#1
Communicating sequential processes C. A. R. Hoare 1978
channel没有locking
关键想法:数据结构使用channel和goroutines去构建并发, 结果是扩展性,简单,正确,并且没有锁。这种架构的好处。
Concurrency is about dealing with lots of things at once. Parallelism is about doing lots of things at once.
Don't communicate by sharing memory, Share memory by communicate.
Go Concurrency Patterns https://go.dev/talks/2012/concurrency.slide#1
channel是同步工具,同步拆解为 send receive
并发模式:
Generator:Function return a channel
Channel as a handler on a service
Multiplexing
Restoring sequencing
select
timeout using select
timeout for whole conversation using select
receive on quit channel
Daisy chain:菊花链
Advanced Go Concurrency Patterns https://go.dev/talks/2013/advconc.slide#1
go run -race main.go Race Detector(Sync Issues)
for{
select {
}
}
select:no lock , no condtion
代码规范
Google Go 规范:https://google.github.io/styleguide/go/
pb最佳实践:https://protobuf.dev/programming-guides/dos-donts/
api最佳实践:https://protobuf.dev/programming-guides/api/
Go在线书籍
https://go-kratos.dev/ go微服务框架
Go语言高级编程:https://chai2010.cn/advanced-go-programming-book/index.html
Go 语言编程之旅:https://golang2.eddycjy.com/
Go语言各种文档: https://learnku.com/go/docs
Go语言原本 :https://golang.design/under-the-hood/
Library
种类 | Go | Java |
---|---|---|
集合 | https://github.com/emirpasic/gods https://github.com/deckarep/golang-set | apache-collections4 |
工具 | guava | |
OrderMap | https://github.com/iancoleman/orderedmap | |
内存缓存 | https://github.com/dgraph-io/ristretto https://github.com/allegro/bigcache | Caffeine |
distributed in-memory immutablekey-value cache | groupcache | |
连接池 | HikariCP | |
Excel | https://github.com/qax-os/excelize | apache-poi |
CSV | https://pkg.go.dev/encoding/csv | apache-common-csv |
Http | okhttp | |
Redis | https://github.com/redis/go-redis | jedis,redisson |
Kafka | https://github.com/Shopify/sarama | kafka官方 |
Database | https://github.com/go-sql-driver/mysql https://github.com/jmoiron/sqlx | mybatis |
Elasticsearch | https://github.com/elastic/go-elasticsearch | |
单测 Mock | https://github.com/agiledragon/gomonkeyhttps://github.com/golang/mock | |
单测 Unit | ||
单测 Assert | https://pkg.go.dev/github.com/stretchr/testify/assert https://github.com/stretchr/testify | |
单测 BDD | https://github.com/smartystreets/goconvey | |
Web框架 | Gin | |
异常处理 | https://pkg.go.dev/github.com/pkg/errors | |
时间处理 | https://github.com/jinzhu/now | |
数字 | https://github.com/shopspring/decimal | |
依赖注入 | https://github.com/uber-go/dig | |
定时任务 | https://github.com/robfig/cron | |
序列化 | https://flatbuffers.dev/ https://github.com/protocolbuffers/protobuf | |
网络 | https://pkg.go.dev/net | netty |
分布式事务 | TDXA:https://iwiki.woa.com/pages/viewpage.action?pageId=905611335 | |
日志 | https://github.com/uber-go/zap | |
端口重用 | SO_REUSEPORT:https://github.com/kavu/go_reuseport | |
tracing | OpenTracing https://github.com/opentracing/opentracing-go | |
Resiliency | https://github.com/eapache/go-resiliency | |
并发原子包 | https://github.com/uber-go/atomic | |
concurrency | https://github.com/modern-go/concurrent | |
反射 | https://github.com/modern-go/reflect2 | |
yaml | https://github.com/ghodss/yaml | |
database clustering system | https://github.com/vitessio/vitess | |
orm | https://github.com/go-gorm/gorm | |
Faiss计算 | https://github.com/DataIntelligenceCrew/go-faiss | |
UUID | https://github.com/google/uuid | |
日志 | Grafana Loki https://grafana.com/docs/loki/latest/ |
常用
NLP and text segmentation:https://github.com/go-ego/gse
readability:https://github.com/go-shiori/go-readability
TimeNLP:https://github.com/bububa/TimeNLP
Excel: https://github.com/xuri/excelize/v2
Gin Web Framework
Gin插件:https://github.com/gin-gonic/contrib
https://github.com/gin-contrib
bind功能
form-data,html checkbox,query string,post data,uri
Gorm
工具
dlv
golang调试器 delve(dlv)工具
Book
100-go-mistakes
代码和项目组织
- 无意的变量阴影
- 不必要的嵌套代码
- 错用init函数
- 过度使用getter和setter
- 接口污染
- 接口在生产册
- 返回接口
- any says nothing
- 何时使用范型感到困惑
- 没有意识到type嵌入可能带来的问题
- 未使用函数式options模式
- 项目错误组织
- 创建工具包
- 忽视包名字冲突
- 遗漏代码文档
- 未使用代码提示器
数据类型
- 通过八进制字面量创建混乱
- 忽略整数溢出
- 不理解浮动数
- 不理解切片的长度和容量
- 无效切片初始化
- 对nil和空切片感到迷惑
控制结构
字符串
函数和方法
错误管理
并发控制:基础
并发控制:实践
标准库
测试
优化
技术分享
2023-03-23
maven和go mod区别? go mod graph go api swagger【需要写API文档】 go工程组织/包结构 子包和子目录 go的集合有set吗?TreeMap?go集合 https://github.com/emirpasic/gods https://github.com/deckarep/golang-set 包的引入 . 和 _ 区别? go注释和java注释。
Go语言趣学指南
进度
完成
代码仓库:https://github.com/xiaozhiliaoo/go-practice/tree/master/get-programming-with-go
笔记
-
大数:big。无类型常量:存储非常大的值,被用作函数参数的时候,必须转换为有类型变量
-
字符串不可变,使用UTF-8可变长度编码,每个字符占1~4字节内存。字符串转换可用strconv包。
-
方法是和特定类型关联的函数,关联的类型是方法名的接收者来指定。
-
函数作为一等值便于代码拆分和复用,想要动态创建函数,使用带闭包特性的匿名函数。
-
array作为传参会被复制,slice和map不会被复制。
-
Go 通过结构实现组合,并通过名为结构嵌入的特殊语言特性实现方法转发。
-
使用继承相比,使用组合构建的软件通常更灵活、复用程度更高并且更容易修改。
-
Go 语言通过组合结构和方法,在没有引入任何新特性的情况下实现了传统语言的面向对象特性。构造函数是普通函数,不是特殊的语言特性。
-
对传统继承的使用并不是必需的;所有使用继承解决的问题都可以通过其他方法解决。
-
写入接口Writer,可以将任意内容写入任何地方。
-
类型关心自己存储了什么值,但是接口关心可以做什么而不是存储了什么值。类型通过方法表达自己的行为,而接口则通过列举类型必须满足的一组方法来进行声明。
-
同时使用组合和接口将构成非常强大的设计工具。
-
fmt 包声明Stringer接口,一种类型只要提供了String 方法,它的值就能够为Println、Sprintf 等打印函数所用。
-
Go 通过简单的、通常只有单个方法的接口,来鼓励组合而不是继承,这些接口在各个组件之间形成了简明易懂的界限。 - Rob Pike
-
地址操作符 & 解引用 * ,指针类型 * int 。指针存储的是内存地址。
-
星号放在类型前面:声明指针类型,星号放在变量前面:解引用变量指向的值。
-
在访问字段时对结构体进行解引用并不是必需的。
-
地址操作符可以合法地放置在变量和复合字面量前面,但不能放置在字符串字面量或整数字面量前面。
-
go会对指向结构体,数组指针进行自动解引用,但不对slice和map自动解引用。
-
映射在被赋值或者被作为实参传递的时候不会被复制。因为映射实际上就是一种隐式指针。
-
隐式指针:1 映射也是指针 2 切片指向数组
-
Go 语言的函数和方法都以传值方式传递形参,这意味着函数总是基于被传递实参的副本进行操作。当指针被传递至函数时,函数将接收到传入内存地址的副本,在此之后,函数就可以通过解引用内存地址来修改指针指向的值。
-
使用指针作为接收者的策略应该是始终如一的。如果一种类型的某些方法需要用到指针作为接收者,就应该为这种类型的所有方法都使用指针作为接收者。
-
实现修改:将指针作为形参,将指针作为接受者。
-
nil函数值,nil切片(vs 空切片),nil映射,nil接口
-
slice的零值是nil,代表没有对应的底层数组,map的零值是nil,代表没有引用任何hash表。结构体的零值是结构体成员的零值。指针的零值为nil。
-
在发生错误时,调用返回的其他值可能会被设置成相应类型的零值,但也可能会包含不完整的数据或者完全不同的其他内容。总体来说,每当有错误发生时,同一调用返回的其他值通常就不再值得信任。
-
Go 语言鼓励使用者思考并处理函数可能返回的所有错误。
-
减少错误处理代码的一种策略是,将程序中不会出错的部分和那些包含潜在出错隐患的部分隔离开来。
-
因为错误也是值,所以Go 编程语言提供的所有功能都可以用于处理它们。
-
Go 程序将使用带有Err 前缀的变量来存储错误消息。
-
类型断言:值从接口类型重新转换成底层的具体类型。err.(SudokuError) error类型转换成SudokuError。
-
Go 语言的错误值机制促使开发者考虑错误,而不是像处理异常那样默认将其忽略,这有助于生成更为可靠的软件。除此之外,因为错误值机制不需要用到特殊关键字,所以它比异常简单而灵活。
-
如果某个被defer的函数调用了recover,那么panic将会停止,而程序则会继续运行。这种恢复机制类似于其他语言中的catch、except 和rescue。
-
Go处理错误通过error,没有异常机制。Java处理错误是通过异常机制。
-
并发任务之间则通过相互通信来达成共同的目的。
-
单个通道(都产生相同类型的值)来等待多个goroutine,select处理多个通道。
-
被阻塞的goroutine 并不消耗任何资源。goroutine 会静静地停在那里,等待导致它阻塞的事情发生,然后解除阻塞。
-
“从通道里面读取值,直到它被关闭为止”,所以Go通过在range 语句里面使用通道,程序可以在通道被关闭之前,一直从通道里面读取值。
-
range 语句可以从通道中读取所有值,直到通道关闭为止。
-
互斥锁并未内置在Go 语言当中,而是通过sync 包提供,而通道是内置的。
-
将sync.Mutex 用作结构成员的做法是一种常见的模式。
-
为了保证互斥锁的使用安全,遵守以下规则:尽可能地简化互斥锁保护的代码,对每一份共享状态只使用一个互斥锁。
-
长时间运行的工作进程:
func worker() { for { select { // 在此处等待通道 } } }
-
通道常常被看作是实现细节,所以一般都会把通道隐藏在方法的后面。
-
通道可以发送任何类型的值。
参考
Go程序设计语言
- map,slice均不可比较,只能与nil比较。
- map[string]bool 字符串集合
- 不允许本身是指针的命名类型行方法声明。
Python
运维
Tracing
Monitoring
Logging
rancher
kubernetes
harbor
Reacher
Reliability Engineering(可靠性工程)
这个工程技术的一个发力点。整合之前全部学的技术。
可靠性是一个系统属性,是方方面面的系统问题。而不是单独技术点。需要将知识点进行融合。形成一个体系。
可靠数据传输,可靠请求和相应,可靠服务,纳入系统思维里面来思考问题。
Chaos engineering
Google SRE:https://sre.google/
微服务
如何使得系统可靠运行?
Reliability分解为监控啊,熔断
Resilience能力
微服务可靠性
故障处理
书籍:The Site Reliability Workbook 站点可靠性工作手册 中文版
aws
aliyun
TencentCloud
模拟考试地址:https://tschool.kaoshixing.com/exam/before_answer_notice/867846
基础产品学堂
COS
COS 作为IAAS层
对象存储的数据湖和原生存算一体数据湖。
基于对象存储的数据湖?
YottaStore--腾讯新一代云原生存储系统 COS存储引擎
数据加速器 GooseFS https://cloud.tencent.com/document/product/1424
CVM
灵活计算能力。
无法单独购买一个CVM,是一个整体能力。
不同的机型价格不一样。
CBM
裸金属
也就是物理机
虚拟机,物理机,所有公有云网络互联互通。
CODING DevOps
研发管理工具
软件开发生命周期(SDLC)
Ckafka
Ckafka在开源上的商业化能力:租户隔离,限流,鉴权
同城双活。
监控能力。
日志的能力给产品化能力出来。
Kafka产品化能力Ckakfa
跨区容灾,跨域灾备
ckafka一键诊断
容器服务
TKE和EKS
容器自动缩容如何做到?
容器属于基础Paas服务。
数据库在容器化用处不大。
异构计算
通用计算 VS 异构计算
qGPU,TKS
CPU和GPU区别
云硬盘
CBS(Cloud Block Storage),CVM里面的硬盘
云CFS
Cloud File Storage
结构化数据和非结构化数据
1ZB=109TB
云上存储:CBS,CFS,COS
CFS
高性能
腾讯云,华为云,阿里云 对表
Lustre 是用于高性能计算 (HPC) 群集和环境的开源并行分布式文件系统。Lustre 名称是Linux 和集群的portmanteau。
并行文件存储。
对比阿里云做规避。引导客户XXX。
阿里云GPFS
CFS的Turbo系列,POSIX接口。和本地文件一样访问
TBDS大数据套件
端到端解决方案。
工具链wedata
构建工具wemodel
分析型数仓 MPP
竞品:CDH平台
RayData可视化
数据实时渲染技术
Plus(CS)
Web(网页)
数字孪生
企点客服
单轮 多轮 任务型(满足特定任务,从客户系统回答)
通路能力。
学习笔记
数据中心是非常复杂系统。
TCO TVO
uptimeinstitute 对数据中心分类:https://uptimeinstitute.com/tiers
两地三中心。双活。
可靠性越高,成本越大。
互联网数据中心(IDC--Internet Data Center) 企业数据中心 (EDC--Enterprise Data Center) 外包数据中心 (ODC--Outsourcing data center) 主数据中心(DC--Data Center)
National Institute of Standards and Technology (NIST) 美国国家标准与技术研究院
按需服务维度:资源,时间
资源池化:虚拟化,资源池,传统的资源隔离。
TVO价值明显:服务可度量,投入产出比分析,成本控制。
操作系统虚拟化。
多云互通:阿里云,腾讯云互通。
计算虚拟化。为什么存储不能虚拟化?
VCPU,虚拟cpu
CPU特权级别:ring0,ring1,ring2,ring3
Binary translation (BT) is the process of converting executable binary from one instruction set architecture (ISA) to another.
CPU纯软件半虚拟化技术:https://www.cnblogs.com/echo1937/p/7227385.html Hypercall技术
dom0
三个虚拟化平台对比。
分布式存储 serverSAN
网络虚拟化 SDN
应用虚拟化:容器技术。
大数据4V。
技术能力到服务输出。
产业互联网:连接,交互,计算
云计算对组织影响。
Grary Sort:排序100TB花费多久?
Minute Sort:60秒排序多少数据?
腾讯云音视频技术,游戏领域很强。
最核心:云服务器。计算最基础东西。
可用区是物理隔离的。
CVM云服务器。(Cloud Virtual Machine)
实例类型:IO,计算,存储,
VPS主机。
管理服务器:API,CLI,控制台
动态扩缩:镜像。
CDH:CVM Deciated Host
升配和降配
不同网络地址掩码是 固定的。
用的CIDR
子网ip只能在子网内,不能互通子网,通过路由表的网关实现。
网关地址实现跨子网通信地址。
ENI:弹性网卡,A实例绑定ENI1,A挂了,可以把ENI1绑定到B实例
网络的核心是实现连接。
虚拟私有云(VPC)
网络连接:连接公网,连接私网,连接另一个vpc
NAT:私有IP转为公网IP。
不支持安全组绑定,不受安全组限制。
NAT要比公网官网更强。
VPN不是物理链接,而是虚拟连接。
NAT:少量公网对应大量私网IP。
企业对网络要求高,用专线接入,对网络要求不高,可以VPN连接。
云联网 CCN
负载均衡:CLB
流量分发算法:WRRS,WLCS,IP-Hash
负载均衡使用场景:业务访问分离,流量分发,出入流量分离,混合云
横向扩展更容易扩容。
公网IP有限,防止不用。
同地域对等连接 走腾讯云内部,所以免费的。
引入CDN节点变多了,但是性能提高了。
CDN是规模经济,规模越大,价格越低。
SLA得到保障。
Akamai(阿卡迈)在1998年发明CDN技术架构之后组建公司
https://www.akamai.com/zh/company/company-history
GSLB 智能调度
DNS里面的一个功能是GSLB。
HTTP协议不是安全的,HTTPS是安全的。
SSL种类:域名型,增强型,
监控 Http Refer 防盗链
DDos攻击和CC(Challenge Collapsar)攻击
海外加速 GCD
动态加速网络:DSA
全球应用加速:GAAP
CDN边缘计算:CDN Edge。如马路上的监控不需要数据传输到云数据中心。
智能CDN:x-p2p
网络绕行
https://www.lustre.org
CDN计费方式:带宽和流量
SQL和NoSQL最大区别:查询。(查询,聚合等等)NoSQL查询能力不行,因为数据模型简单。
数据库一体机。infiband
数据传输服务 DTS,数据库一体机 TData
云MySQL弹性扩容
SQLServer用于windows,基于镜像机制实现高可用。
TDSQL是MariaDB分布式版本。
强同步MAR:Multi-thread Asynchronous Replication 异步多线程同步复制方案
MariaDB_TDSQL 高并发,实时交易,物联网,金融级别
CynosDB 设计基于云,云原生数据库
日志即数据库。
SPDK和RDMA零拷贝技术。
云数据库 MongoDB:游戏开发
两个版本:Redis,CKV(基于社区Redis进行优化,多线程,数据备份不用额外内存)
时序数据库 CTSDB(带时间标签的)(IOT和业务监控分析)
数据库一体机:TData 软件 硬件的融合。IB(Infiniband):计算层和存储层的数据交换效率
金融行业:高可靠,高可用:两地三中心(主库,同城备库,异地备库)
DTS:数据传输服务,监听binlog
Redis,Memcacvhe计算只计算内存不计算磁盘,MongoDB计算内存+磁盘
SLA,Service Level Agreement
COS存储引擎 YottaStore
人脸识别 是 PaaS
人脸识别 能力 Paas 人脸识别 服务 Saas
最便宜的是公有云
公有云和私有云:使用权和所有权。
数据放在自己机房未必安全。不一定放在腾讯云不安全。取决于是否有了安全策略。本地有充分安全策略。
你的电脑不是时刻利用完资源。
虚拟化:解决资源利用率问题。
Cos不是某一个存储柜(机柜),而是上传时候,系统是分布式,切成很多块。
云供应商买的硬盘不是高性能的,一堆非常不可靠,性能不可靠的机器上实现的非常可靠的,高可用的。每一块硬盘DataNode非常差。分拆的非常小。
腾讯云的用的不是openstack。基于vstation
分布式存储,用的ssd,实际上不是ssd。
服务化到各行各业都在使用,就是产业化。
云计算不用满足,未来几年。因为云替你考虑了。
题库。
不同地域之间不互通。负载均衡不在地域间。
Replication And Consistency(Not Consensus)
在分布式系统中,复制可用来实现Reliable, Scalable. 数据的复制会导致一致性问题。 数据的复制也即同步过程,会带来节点是否可用问题,这也是CAP中的AP权衡。 复制是一项基础技术,而一致性是这项技术带来的问题。可以认为没有复制便没有一致性问题。
PacificA: Replication in Log-Based Distributed Storage Systems
Replication in database,kv,document-db,column-db,file system, distributed coordination,framework
Replication Model https://en.wikipedia.org/wiki/Replication_(computing)
Consistency Model https://en.wikipedia.org/wiki/Consistency_model
Consistency Model https://jepsen.io/consistency
复制的基本问题
- 复制方式:主从,多主,无主
- 同步还是异步
- 处理失败副本
- 数据滞后问题
关键词
data replication
Paper
Understanding Replication in Databases and Distributed Systems
A Suite of Database Replication Protocols based on group communication
Chain Replication for Supporting High Throughput and Availability
重点研究
MySQL,PostgreSQL,Kafka,Redis,
Database
mysql https://dev.mysql.com/doc/refman/8.0/en/replication.html
postgresql https://www.postgresql.org/docs/current/high-availability.html
mariadb https://mariadb.com/kb/en/standard-replication/
KV store
redis https://redis.io/topics/replication
etcd https://etcd.io/docs/v3.3/faq/
riak https://docs.riak.com/riak/kv/latest/learn/concepts/replication/index.html
tikv: https://tikv.org/deep-dive/scalability/introduction/
dynamo:https://www.allthingsdistributed.com/files/amazon-dynamo-sosp2007.pdf
consul https://www.consul.io/docs/architecture
Document
mongodb https://docs.mongodb.com/manual/replication/
couchdb https://docs.couchdb.org/en/stable/replication/intro.html https://guide.couchdb.org/editions/1/en/replication.html
Framework
hazelcast https://docs.hazelcast.com/imdg/4.2/consistency-and-replication/consistency
akka https://doc.akka.io/docs/akka/current/typed/cluster-concepts.html
Column DB
cassandra https://cassandra.apache.org/doc/latest/cassandra/architecture/overview.html
hbase https://hbase.apache.org/book.html#_cluster_replication
Message
kafka https://kafka.apache.org/documentation/#replication
https://cwiki.apache.org/confluence/display/kafka/kafka+replication
rabbitmq https://www.rabbitmq.com/ha.html
rocketmq https://rocketmq.apache.org/docs/rmq-deployment/
activemq https://activemq.apache.org/clustering
Search
elasticsearch https://www.elastic.co/guide/en/elasticsearch/reference/current/modules-discovery.html
solr https://solr.apache.org/guide/6_6/index-replication.html
File System
hdfs https://hadoop.apache.org/docs/r1.2.1/hdfs_design.html#Data+Replication
ceph https://ceph.io/assets/pdfs/weil-crush-sc06.pdf
GFS https://static.googleusercontent.com/media/research.google.com/zh-CN//archive/gfs-sosp2003.pdf
Coordination
zookeeper: https://zookeeper.apache.org/doc/r3.2.2/zookeeperInternals.html
Distributed database(newsql)
yugabyte https://docs.yugabyte.com/latest/architecture/docdb-replication/replication/
CockroachDB https://www.cockroachlabs.com/docs/stable/architecture/replication-layer.html
TiDB https://docs.pingcap.com/tidb/stable/bidirectional-replication-between-tidb-clusters
other
Aurora https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.Replication.html
Spanner/F1
rethinkdb https://rethinkdb.com/docs/architecture/
Windows Azure Storage https://docs.microsoft.com/en-us/azure/storage/common/storage-redundancy
voldemort https://www.project-voldemort.com/voldemort/design.html
Bigtable https://static.googleusercontent.com/media/research.google.com/zh-CN//archive/bigtable-osdi06.pdf
Yahoo PNUTS https://sites.cs.ucsb.edu/~agrawal/fall2009/PNUTS.pdf
VoltDB https://docs.voltdb.com/UsingVoltDB/ChapReplication.php
ScyllaDB https://docs.scylladb.com/architecture/
foundationdb: https://apple.github.io/foundationdb/consistency.html
https://apple.github.io/foundationdb/fault-tolerance.html
Compute
Flink:
Spark:
Storm:
Application | Replication Model | Consistency Model |
---|---|---|
Partitioning&Sharding
分区是将大数据集拆分成小数据集的方法,拆分会带来两个问题,1 是寻找到分区信息Routing 2 是增减节点时候Rebalance分区
https://en.wikipedia.org/wiki/Shard_(database_architecture)
https://en.wikipedia.org/wiki/Partition_(database)
partition:hazelcast,kafka shard:MongoDB,ES,Solr region:Hbase,TiKV tablet:Bigtable vnode:Cassandra,Riak vBucket(virtual buckets):Couchbase slot:Redis ShardRegion:akka
System
Memcached
Redis:https://redis.io/topics/partitioning https://redis.io/topics/cluster-tutorial
Cassandra https://docs.datastax.com/en/cassandra-oss/3.0/cassandra/architecture/archDataDistributeAbout.html https://cassandra.apache.org/doc/latest/cassandra/architecture/dynamo.html#dataset-partitioning-consistent-hashing
DynamoDB
Google Spanner
Shardingsphere
rethinkdb:https://rethinkdb.com/docs/architecture
HBase:https://hbase.apache.org/book.html#manual_region_splitting_decisions https://hbase.apache.org/book.html#regions.arch
BigTable:
MongoDB:https://docs.mongodb.com/manual/sharding/
voldemort: https://www.project-voldemort.com/voldemort/rebalance.html https://www.project-voldemort.com/voldemort/design.html
Couchbase: https://docs.couchdb.org/en/stable/partitioned-dbs/index.html
MySQL:https://dev.mysql.com/doc/refman/8.0/en/partitioning.html
Riak:
voltdb:https://docs.voltdb.com/UsingVoltDB/IntroHowVoltDBWorks.php
HDFS:https://blog.cloudera.com/partition-management-in-hadoop/
Ketama https://www.metabrew.com/article/libketama-consistent-hashing-algo-memcached-clients
Request Routing
service discovery
https://helix.apache.org/
https://docs.mongodb.com/manual/core/sharded-cluster-config-servers/
https://github.com/couchbase/moxi
Rebalancing(Split&Merge)
StorageEngine
MySQL:https://dev.mysql.com/doc/refman/8.0/en/innodb-storage-engine.html
Postgre:https://wiki.postgresql.org/wiki/Future_of_storage
Mariadb:https://mariadb.com/kb/en/choosing-the-right-storage-engine/
cassandra: https://cassandra.apache.org/doc/latest/cassandra/architecture/storage_engine.html
riak:https://docs.riak.com/riak/kv/2.2.3/setup/planning/backend/bitcask/index.html
consul,etcd:blot
leveldb:https://github.com/google/leveldb/blob/main/doc/impl.md
rocksdb:http://rocksdb.blogspot.com/
hbase:https://hbase.apache.org/book.html#inmemory_compaction
elasticsearch:lucene,https://www.elastic.co/cn/blog/found-dive-into-elasticsearch-storage
solr:lucene
lucene:https://blog.mikemccandless.com/2011/02/visualizing-lucenes-segment-merges.html
lmdb:http://www.lmdb.tech/doc/
voltdb:
memsql:
ramcloud:
redis:
mongodb:https://docs.mongodb.com/manual/core/storage-engines/
couchbase:
OLAP:Teradata,Vertica,SAP HANA,ParAccel,Amazon RedShift
Apache Hive,SparkSQL,Cloudear Impala,Facebook Presto,Aoache Tajo,Apache Drill,Google Gremel
Network Partition
https://en.wikipedia.org/wiki/Network_partition
https://en.wikipedia.org/wiki/Split-brain
akka:https://doc.akka.io/docs/akka-enhancements/current/split-brain-resolver.html
hazelcast: https://docs.hazelcast.com/imdg/4.2/network-partitioning/split-brain-protection https://hazelcast.com/blog/jepsen-analysis-hazelcast-3-8-3/
es: https://www.elastic.co/guide/en/elasticsearch/reference/8.0/modules-discovery-quorums.html https://www.elastic.co/guide/en/elasticsearch/reference/8.0/modules-discovery-voting.html https://www.elastic.co/guide/en/elasticsearch/reference/8.0/high-availability-cluster-design-large-clusters.html https://www.elastic.co/guide/en/elasticsearch/reference/8.0/high-availability-cluster-small-clusters.html
CouchDB: https://guide.couchdb.org/editions/1/en/conflicts.html
rabbitmq: https://www.rabbitmq.com/partitions.html
Transaction
https://en.wikipedia.org/wiki/Isolation_(database_systems)
aerospike:https://aerospike.com/blog/developers-understanding-aerospike-transactions/
datomic: https://docs.datomic.com/on-prem/transactions/transactions.html
MySQL:https://dev.mysql.com/doc/refman/8.0/en/innodb-locking-transaction-model.html
PostgreSQL:https://www.postgresql.org/docs/14/mvcc.html K Oracle
SQL Server2012: https://docs.microsoft.com/en-us/sql/relational-databases/sql-server-transaction-locking-and-row-versioning-guide?view=sql-server-ver15#database-engine-isolation-levels
FoundationDB:https://apple.github.io/foundationdb/transaction-manifesto.html
Access
MemSQL(singlestore):https://dbdb.io/db/singlestore
Index
https://en.wikipedia.org/wiki/Database_index
ResiliencyPatterns
Retry
https://github.com/elennick/retry4j
Guava Retry
Spring Retry
resilience4j-retry
https://failsafe.dev/
ServiceRegistry
https://microservices.io/patterns/service-registry.html
服务注册和发现是分布式系统里面的Naming部分,并不是Communication部分。Communication是Feign做的。
nacos,zookeeper,etcd,consul,eureka
nacos:一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。
zookeeper:Apache ZooKeeper is an effort to develop and maintain an open-source server which enables highly reliable distributed coordination.
etcd:A distributed, reliable key-value store for the most critical data of a distributed system
consul:Consul is a service networking solution to automate network configurations, discover services, and enable secure connectivity across any cloud or runtime.
eureka:Eureka is a RESTful (Representational State Transfer) service that is primarily used in the AWS cloud for the purpose of discovery, load balancing and failover of middle-tier servers. It plays a critical role in Netflix mid-tier infra.
Person
Peter Bailis: HAT,Consistency Model
Stan Zdonik :SciDB,H-Store(VoltDB),C-store(Vertica),Aurora/Borealis(StreamBase)
Samuel Madden : TinyDB,SciDB
2021
2020
java nio select 与 go select,python select
https://docs.python.org/3.8/library/select.html
library
https://mvnrepository.com/open-source?p=15
https://java.libhunt.com/
http://latencyutils.org/
https://www.jfrogchina.com/
explore exchange-web-api jar
benchmark
https://k6.io/blog/comparing-best-open-source-load-testing-tools
web压测考虑这个: https://www.locust.io/
robotframework 和cucumber
Classloader
https://docs.oracle.com/javase/8/docs/api/index.html?java/lang/ClassLoader.html https://tomcat.apache.org/tomcat-9.0-doc/class-loader-howto.html https://maven.apache.org/guides/mini/guide-maven-classloading.html https://dzone.com/articles/spring-boot-classloader-and-class-override https://en.wikipedia.org/wiki/Java_Classloader https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/ClassLoader.html https://docs.jboss.org/jbossas/docs/Server_Configuration_Guide/4/html/Inside_the_JBoss_Class_Loading_Architecture-The_Complete_Class_Loading_Model.html https://www.jrebel.com/blog/how-to-use-java-classloaders https://www.eclipse.org/jetty/documentation/current/jetty-classloading.html
https://sites.google.com/site/sureshdevang/java-classloader-hierarchy Java容器隔离简介 https://wemp.app/posts/c2b76b5b-af28-434b-8a02-29f2ba658b45 https://github.com/kevinlynx/kcontainer http://codemacro.com/2015/09/05/java-lightweight-container/ ClassLoaders are used in large systems and server applications to do things like: Modularize a system and load, unload and update modules at runtime Use different versions of an API library (e.g. an XML parser) in parallel Isolate different applications running within the same JVM (ensuring they don't interfere with each other, e.g. through static variables) https://github.com/sofastack/sofa-ark
https://github.com/rzwitserloot/lombok/blob/master/src/launch/lombok/launch/ShadowClassLoader.java
一系列文章:https://dzone.com/articles/reloading-java-classes-401
RJC101: Objects, Classes and ClassLoaders RJC201: How do Classloader leaks happen? RJC301: Classloaders in Web Development — Tomcat, GlassFish, OSGi, Tapestry 5 and so on RJC401: HotSwap and JRebel — Behind the Scenes RJC501: How Much Does Turnaround Cost?
ClassLoader Leak https://arthas.aliyun.com/doc/classloader.html
[arthas@27028]$ classloader name numberOfInstances loadedCountTotal sun.misc.Launcher$AppClassLoader 1 6383 BootstrapClassLoader 1 3087 com.taobao.arthas.agent.ArthasClassloader 1 1210 sun.reflect.DelegatingClassLoader 253 253 sun.misc.Launcher$ExtClassLoader 1 30 javax.management.remote.rmi.NoCallStackClassLoader 2 2 sun.reflect.misc.MethodUtil
sun/reflect/GeneratedMethodAccessor类和sun/reflect/DelegatingClassLoader private ClassLoader contextClassLoader 反射原理:https://mp.weixin.qq.com/s/5H6UHcP6kvR2X5hTj_SBjA
Collections
2021-01-04
集合选择:关键看新加了哪些Collection?有什么新的特性? 对比:Apache Common Collection4,Guava,Varv,JCF,Eclipse Collections 像Guava,Apache Common Collection4和JCF比较像,但是EC和vavr就差别比较大,设计里面也不同。
https://www.eclipse.org/collections/
https://github.com/eclipse/eclipse-collections
Javaslang https://docs.vavr.io/#_introduction
动态代理
线上问题之动态代理失效,导致AOP失效,Redis分布式锁没有释放。
CGLib和JDK区别? 将项目的一个方法写成了final,启动时候异常,运行时注入的类是空的: o.s.aop.framework.CglibAopProxy - Unable to proxy interface-implementing method [public final java.util.Set com.chainup.cache.redis.RedisClientTemplate.keys(java.lang.String)] because it is marked as final: Consider using interface-based JDK proxies instead!
动态代理+分布式锁组合造成了充值阻塞了几百笔,事故时间长达2小时。
动态代理给所有实现类,加代理行为怎么加呢?CGLIB? JDK只能传入一个实现类,获取他的代理的方式。 动态代理给指定类,加代理行为怎么加呢?
https://docs.spring.io/spring-framework/docs/2.5.x/reference/aop.html#aop-proxying
动态代理方法和类,构造函数,
CGLIB不能代理final方法 https://jira.spring.io/browse/SPR-15436?redirect=false
https://github.com/spring-projects/spring-framework/issues/7798
https://dzone.com/articles/cglib-missing-manual
https://www.cnblogs.com/onlymate/p/9630788.html
https://www.choupangxia.com/2019/11/06/spring-cglib2aopproxy/
https://github.com/spring-projects/spring-boot/issues/8974
https://github.com/spring-projects/spring-framework/issues/19997
https://stackoverflow.com/questions/39590094/spring-aop-proxy-and-interface-implementation
@EnableAspectJAutoProxy(proxyTargetClass = true, exposeProxy = true)
但是改成接口代理的话,启动又会报错: 在属性文件中加入,改成了接口代理。 spring.aop.proxy-target-class=false
会报错:
2020-12-31 16:19:00.389 [main] WARN o.s.w.c.s.GenericWebApplicationContext - Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'configAccountTypeServiceImpl': Unsatisfied dependency expressed through field 'redisClient'; nested exception is org.springframework.beans.factory.BeanNotOfRequiredTypeException: Bean named 'redisClientTemplate' is expected to be of type 'com.chainup.cache.redis.RedisClientTemplate' but was actually of type ' com.sun.proxy.$Proxy156' 2020-12-31 16:19:00.427 [main] INFO o.s.b.a.l.ConditionEvaluationReportLoggingListener -
Error starting ApplicationContext. To display the conditions report re-run your application with 'debug' enabled. 2020-12-31 16:19:00.435 [main] ERROR o.s.b.d.LoggingFailureAnalysisReporter -
APPLICATION FAILED TO START
Description:
The bean 'redisClientTemplate' could not be injected as a 'com.chainup.cache.redis.RedisClientTemplate' because it is a JDK dynamic proxy that implements: com.chainup.cache.redis.core.RedisClient
Action:
Consider injecting the bean as one of its interfaces or forcing the use of CGLib-based proxies by setting proxyTargetClass=true on @EnableAsync and/or @EnableCaching.
2020-12-31 16:19:00.443 [main] ERROR o.s.test.context.TestContextManager - Caught exception while allowing TestExecutionListener [org.springframework.test.context.web.ServletTestExecutionListener@6692b6c6] to prepare test instance [com.chainup.exchange.service.RedisClientTemplateTest@fd5689d] java.lang.IllegalStateException: Failed to load ApplicationContext at org.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate.loadContext( DefaultCacheAwareContextLoaderDelegate.java:132) at org.springframework.test.context.support.DefaultTestContext.getApplicationContext(DefaultTestContext.java:123) at org.springframework.test.context.web.ServletTestExecutionListener.setUpRequestContextIfNecessary( ServletTestExecutionListener.java:190) at org.springframework.test.context.web.ServletTestExecutionListener.prepareTestInstance( ServletTestExecutionListener.java:132) at org.springframework.test.context.TestContextManager.prepareTestInstance(TestContextManager.java:244) at org.springframework.test.context.junit.jupiter.SpringExtension.postProcessTestInstance(SpringExtension.java:98) at org.junit.jupiter.engine.descriptor.ClassTestDescriptor.lambda$invokeTestInstancePostProcessors$5( ClassTestDescriptor.java:349) at org.junit.jupiter.engine.descriptor.JupiterTestDescriptor.executeAndMaskThrowable(JupiterTestDescriptor.java:215) at org.junit.jupiter.engine.descriptor.ClassTestDescriptor.lambda$invokeTestInstancePostProcessors$6( ClassTestDescriptor.java:349) at java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:193) at java.util.stream.ReferencePipeline$2$1.accept(ReferencePipeline.java:175) at java.util.ArrayList$ArrayListSpliterator.forEachRemaining(ArrayList.java:1382) at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:481) at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:471) at java.util.stream.StreamSpliterators$WrappingSpliterator.forEachRemaining(StreamSpliterators.java:312) at java.util.stream.Streams$ConcatSpliterator.forEachRemaining(Streams.java:743) at java.util.stream.Streams$ConcatSpliterator.forEachRemaining(Streams.java:742) at java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:580) at org.junit.jupiter.engine.descriptor.ClassTestDescriptor.invokeTestInstancePostProcessors(ClassTestDescriptor.java: 348) at org.junit.jupiter.engine.descriptor.ClassTestDescriptor.instantiateAndPostProcessTestInstance( ClassTestDescriptor.java:270) at org.junit.jupiter.engine.descriptor.ClassTestDescriptor.lambda$testInstanceProvider$2(ClassTestDescriptor.java:259) at org.junit.jupiter.engine.descriptor.ClassTestDescriptor.lambda$testInstanceProvider$3(ClassTestDescriptor.java:263) at java.util.Optional.orElseGet(Optional.java:267) at org.junit.jupiter.engine.descriptor.ClassTestDescriptor.lambda$testInstanceProvider$4(ClassTestDescriptor.java:262) at org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor.prepare(TestMethodTestDescriptor.java:82) at org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor.prepare(TestMethodTestDescriptor.java:59) at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$prepare$0(NodeTestTask.java:83) at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:72) at org.junit.platform.engine.support.hierarchical.NodeTestTask.prepare(NodeTestTask.java:83) at org.junit.platform.engine.support.hierarchical.NodeTestTask.execute(NodeTestTask.java:69) at java.util.ArrayList.forEach(ArrayList.java:1257) at org.junit.platform.engine.support.hierarchical.SameThreadHierarchicalTestExecutorService.invokeAll( SameThreadHierarchicalTestExecutorService.java:38) at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$4(NodeTestTask.java:112) at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:72) at org.junit.platform.engine.support.hierarchical.NodeTestTask.executeRecursively(NodeTestTask.java:98) at org.junit.platform.engine.support.hierarchical.NodeTestTask.execute(NodeTestTask.java:74) at java.util.ArrayList.forEach(ArrayList.java:1257) at org.junit.platform.engine.support.hierarchical.SameThreadHierarchicalTestExecutorService.invokeAll( SameThreadHierarchicalTestExecutorService.java:38) at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$4(NodeTestTask.java:112) at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:72) at org.junit.platform.engine.support.hierarchical.NodeTestTask.executeRecursively(NodeTestTask.java:98) at org.junit.platform.engine.support.hierarchical.NodeTestTask.execute(NodeTestTask.java:74) at org.junit.platform.engine.support.hierarchical.SameThreadHierarchicalTestExecutorService.submit( SameThreadHierarchicalTestExecutorService.java:32) at org.junit.platform.engine.support.hierarchical.HierarchicalTestExecutor.execute(HierarchicalTestExecutor.java:57) at org.junit.platform.engine.support.hierarchical.HierarchicalTestEngine.execute(HierarchicalTestEngine.java:51) at org.junit.platform.launcher.core.DefaultLauncher.execute(DefaultLauncher.java:220) at org.junit.platform.launcher.core.DefaultLauncher.lambda$execute$6(DefaultLauncher.java:188) at org.junit.platform.launcher.core.DefaultLauncher.withInterceptedStreams(DefaultLauncher.java:202) at org.junit.platform.launcher.core.DefaultLauncher.execute(DefaultLauncher.java:181) at org.junit.platform.launcher.core.DefaultLauncher.execute(DefaultLauncher.java:128) at com.intellij.junit5.JUnit5IdeaTestRunner.startRunnerWithArgs(JUnit5IdeaTestRunner.java:69) at com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:33) at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:230) at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:58) Caused by: org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name ' configAccountTypeServiceImpl': Unsatisfied dependency expressed through field 'redisClient'; nested exception is org.springframework.beans.factory.BeanNotOfRequiredTypeException: Bean named 'redisClientTemplate' is expected to be of type 'com.chainup.cache.redis.RedisClientTemplate' but was actually of type 'com.sun.proxy.$Proxy156'
因为属性类通过接口引用的类。
事件总线
Observable,Observer SwingUtilities,SwingWorker EventListenerList,EventObject,EventListener Message driven - Guava (by Google)
interface ActionListener { void actionPerformed(ActionEvent e); }
JButton button = new JButton("Click me"); button.addActionListener((e) -> System.out.println("Button clicked") )
hash
2021-01-04
https://www.zhihu.com/question/286529973
HashMap平衡树?https://openjdk.java.net/jeps/180
https://en.wikipedia.org/wiki/SipHash
https://www.slideshare.net/stamparm/hash-dos-attack
https://www.geeksforgeeks.org/string-hashing-using-polynomial-rolling-hash-function/
String多项式Hash算法
雪崩效应
Hash Flooding
Avalance Effect
HashDoS
https://en.wikipedia.org/wiki/Cache_stampede
JDBC
DriverManager,ServiceLoader,ClassLoader,
online question
线上问题经典待整理博客: 1 事务失效,数据源切换失败。
2 动态代理不能代理final方法,分布式锁释放失败,充提挂了。
3 forkjoin不正确使用导致线程hang住,系统突然卡死,定时任务不在执行。
4 内存泄漏问题,没有重写hashCode方法导致内存泄漏。
5 ThreadLocal内存泄漏问题。
6 Redis带宽被打满,热点key问题
7 Broken pipe问题解决
8 工程方面。
ThreadLocal
博客写ThreadLocal,相关使用,log4j ThreadContext,design,利用threadlocal解决SimpleDateFormat解决线程不安全的问题
https://rules.sonarsource.com/java/type/Bug/RSPEC-5164?search=ThreadLocal
https://errorprone.info/bugpattern/ThreadLocalUsage
ThreadLocal Idea FindUsage
https://laliluna.com/jpa-hibernate-guide/ch13s04.html
HibernateSessionFactory
https://cwiki.apache.org/confluence/display/TOMCAT/MemoryLeakProtection
https://dzone.com/articles/memory-leak-protection-tomcat
FastThreadLocal
RequestContextHolder
Timer
hierarchical timer wheel
时间轮算法:https://github.com/ben-manes/caffeine/blob/master/caffeine/src/main/java/com/github/benmanes/caffeine/cache/TimerWheel.java
kafka.utils.timer.SystemTimer
https://cwiki.apache.org/confluence/display/KAFKA/Purgatory+Redesign+Proposal
https://netty.io/4.0/api/io/netty/util/HashedWheelTimer.html
Timer,TimerTask VS ScheduledThreadPoolExecutor VS HashedWheelTimer
ScheduledThreadPoolExecutor VS HashedWheelTimer
Timer和WheelTimer使用场景?
https://github.com/Spikhalskiy/hashed-wheel-timer
Reinventing the timer wheel:https://lwn.net/Articles/646950/
Akka:https://doc.akka.io/docs/akka/current/scheduler.html
spring scheduler
潘爱明
《大道至易——实践者的思想》(第二版) 《程序原本》 《我的架构思想——基本模型、理论与原则》
atomix
https://atomix.io/docs/latest/user-manual/introduction/what-is-atomix/
其他问题研究
异构任务并行化
CompletableFuture研究
CS:CompletionStage(链式调用) CF:CompletableFuture
thenCombine 两个CompletionStage结果汇总。
thenCompose 一个CompletionStage结果是另外一个CS的输入。
apply是Function,accept是Consumer.either是任意异构,compose前一个输入作为当前参数,combine组合两个,async是fj或tpe.
提交任务
runAsync, supplyAsync
转换
thenRun(不进不出Runnable), thenAccept(只进不出Consumer),thenApply(有进有出Function)
组合
thenCompose, thenCombine, allOf, anyOf,either
完成
whenComplete,handle
异常
exception
物料金额拆分
一个订单三门课,C1,C2,C3。课程金额分别为M1,M2,M3元,
订单发了两个物料,G1,G2,分别为N1,N2元。
G1为图书类型。包括C1,C2。
G2为硬件类型,包括C2,C3。
一门课的金额需要分拆在 课程,物料上,使之总和为课程金额。比如C1的M1需要分拆在C1(课拆),G1(G1拆),G2(G2拆),C1金额+G1金额+G2金额=M1元
C2的M2需要分拆到C2(课拆),G1(G1拆),并且 C2金额+G1金额=M2元。
问每门课(C1,C2,C3)应该分拆图书G1多少钱,硬件G2多少钱?设计一个算法解决该问题。
课程 | 物料 | 物料分拆金额 |
---|---|---|
C1 | G1 | M1怎么分配C1? |
C2 | G1 | M2怎么分配C2? |
C2 | G2 | M2怎么分配C2? |
C3 | G2 | M3怎么分配C3? |
课程 | 课拆 | 物料G1拆 | 物料G2拆 | 总和=课拆+G1拆+G2拆(三者必须均大于0) |
---|---|---|---|---|
C1 | ? | ? | 0元 | M1 |
C2 | ? | ? | ? | M2 |
C3 | ? | 0元 | ? | M3 |
老师学生匹配
很多老师,上课时间是XXX,很多学生,上课时间是YYY,如何保证最多学生上课,以让老师赚更多钱?
匈牙利算法是否可以解决?https://www.acwing.com/problem/content/4301/
灵活标签问题
用户可以被打n个标签,n个标签灵活查询数据,数据分布在各种存储里面。用户标签可以看到不同的数据。
条件是标签,查询是N个存储。
问题
场景: 对话机器人全链路压测,端到端请求通过websocket,发出问题得到回答。
现有方案: 通过jmeter进行websocket压测,但是由于同样问题的一个答案,会发出很多websocket请求,所以无法精确知道答案在哪一个websocket里面出现,所以难以编写WebSocket Sampler进行采样从而统计问答延时和答案正确率。
websocket图:
jmeter图:
问题: 如何通过修改jmeter进行ws压测或者 有没有更好的方案实现这种场景的压测?
可取消的http请求
技术分享
我的技术分享:https://github.com/xiaozhiliaoo/my-slides
boltdb
KV领域基本被GO占据了。JAVA缺很少。
竞品:https://github.com/xujiajun/nutsdb
https://github.com/tidwall/buntdb
https://github.com/dgraph-io/badger
LMDB: Lightning Memory-Mapped Database Manager (LMDB)
研究 write和mmap
boltdb PK levelDB
理论结合实践详解 B+ 树存储引擎(InnoDB、BoltDB、BuntDB)
https://mp.weixin.qq.com/s/aSNdEkNdeCAC7O6b3coo-A
理论结合实践详解 lsm 树存储引擎(bitcask、moss、leveldb 等
https://github.com/couchbase/moss
https://github.com/cockroachdb/pebble
https://github.com/roseduan/rosedb
https://mp.weixin.qq.com/s/QxTtNdtkrJxRhaxUEKTqSg
B站非常好的学习视频:https://www.bilibili.com/video/BV1Zv411G7ty
怎么跑起来单元测试的呢?添加mod了吗?
etcd的wal用了boltdb
read/write两次传输,一次文件和内核高速缓冲,一次高速缓冲区和用户空间缓冲区。
页对齐,大文件,读多写少场景。
缺页,会导致性能很差。
内存映射优势在大型文件中执行重复随机访问性能最好。读多于写适合。
如果顺序得访问一个文件,并假设执行IO时缓冲区足够大以至于避免大量IO 系统掉调用,此时和read,write相比,mmap优势有限或者根本没有优势。提升有限是因为整个文件在磁盘和内存只传一次,效率提高在于减少用户空间和内核空间的一次数据传输,并且与磁盘IO时间相比,内存使用量降低基本可以忽略。
嵌套是为了实现关联关系,比如es的嵌套结构。
数据库关联的实现是什么?
如何支持range查询?
mapdb.........
madvise:预读。
system-call:flock,mmap,madvise,fcntl,munmap,fdatasync,FreeList,
读:mmap(share, PROT_READ,MAP_SHARE)
写:fdatasync
https://en.wikipedia.org/wiki/Free_list
缺页中断。https://zh.wikipedia.org/wiki/%E9%A1%B5%E7%BC%BA%E5%A4%B1
https://en.wikipedia.org/wiki/Page_fault
https://liam.page/2017/09/01/page-fault/
https://stackoverflow.com/questions/66828363/why-does-malloc-cause-minor-page-fault
Akka Classic Cluster
介绍
时间: 2022年4月13日
PPT
做完上传到Google Doc
内容简介
内容列表
集群基本概念(概念本身和AKKA特有的概念,成员状态,集群演示)
Cluster API Extension:Joining and Leaving a Cluster,Cluster Subscriptions,Cluster State Cluster Membership API: Joining,Leaving,Downing Node Roles: Failure Detector: Test Configuration: Higher level Cluster tools:Cluster Singleton,Cluster Sharding,Distributed Data,Distributed Publish Subscribe,Cluster aware routers ,Cluster across multiple data centers,Reliable Delivery
集群功能与模块(带演示集群状态变更和脑裂/集群案例)
ShardRegion ShardCoordinator
Cluster Sharding:ShardCoordinator,Message,ShardRegion,Shard,Entity
Distributed Publish Subscribe:
集群设计与实现
Akka Cluster provides a fault-tolerant decentralized peer-to-peer based Cluster Membership Service with no single point of failure or single point of bottleneck. It does this using gossip protocols and an automatic failure detector.
集群使用场景-教务案例
源码速览
akka-cluster:remote,coordination,
akka-cluster-sharding:cluster,distributedData,persistence,clusterTools
akka-cluster-tools:cluster,coordination
akka-distributed-data:cluster
akka-coordination:actor
集群其它技术
和分布式的区别(stateless vs stateful)
和服务注册发现区别
去中心化和中心化区别是什么?通信协议(gossip),节点职责?
membership change:raft是配置,akka cluster是节点。
membership(每个人知道全部节点)
availability:membership,distributed data,PubSub,Multi-DC consistency: singletons,sharding,lease
Classic Cluster和Typed Cluster的区别
Reliable delivery
Akka与应用架构
反应式架构
Fast Data Architectures for Streaming Applications
LAMP VS SMACK
Akka Play Lagom
参考
https://doc.akka.io/docs/akka/current/project/examples.html
akka sbr(Akka Split Brain Resolver):https://www.lightbend.com/blog/lightbend-to-contribute-commercial-features-to-akka-open-source
实验
脑裂: sh akka cluster start
sh akka node stop 9
sh akka node down 8
Java的并行函数式编程
2022-11-09 李晨曦分享
架构图:https://www.processon.com/view/link/5c8b48ebe4b09a16b9a397e2
占用之后,只是按钮隐藏了,但是请求还是可以发送。
编辑资源锁的上限:
种类:
编辑资源锁:资源类型和资源ID。实体Actor。
占用过程:
占用失败过程:
资源类型。
强制释放。
全站通知
全站消息
实时消息推送
实时在线人数
锁和对象互相监听。
lucene入门
https://blog.mikemccandless.com/2010/12/using-finite-state-transducers-in.html
SortedMap<ByteSequence,SomeOutput>
Term vocabulary Postings list
倒排索引数据结构:Term Dict Index + Term Dict + Invert Index
Finite State Transducer (FST) 有限状态转移器
Finite State Automata
倒排索引压缩算法:Frame Of Reference 和 RBM
for压缩和rbm压缩:https://www.elastic.co/cn/blog/frame-of-reference-and-roaring-bitmaps
【ES】ElasticSearch 深入分片:https://www.jianshu.com/p/cc06f9adbe82
Lucene解析 :https://zhuanlan.zhihu.com/p/35469104
ES查找结构精确到B+tree级别。
aws安全合规
PPT:https://d1x6panposcncl.cloudfront.net/202206/ppt.zip
技术
可用区,和可用域。
CDN服务:CloudFont
ECS/EKS
S3分层存储。
Global Accelerator GCP
Aurora
Aurora Golbal Database.
大规模数据量,需要分库分表考虑,kv,或者其他存储,貌似没有newsql解决方案?
Dymoand 全球写入,多节点写入,Dymoand CDC Stream。只有这个是多点写入。 是kv,毫秒查询。全球数据同步取决于具体业务和技术选型。
Cassanrda 大宽表,分库分表。
Timestream.
EMR 托管hadoop集群。
S3中间存储。
redshift,
kenisis 比kafka有安全机制。
Amazon S3数据湖。行业标准。
AWS CDK(Cloud Development Kit)
直播方案
安全合规
GDPR:General Data Protection Regulation
安全工程
GB/T35273
CIA 完整性 安全性
数据保护官 DPO
合规方案:数据湖保护个人信息,从设计开始考虑
数据加密:存储,传输,使用。
Amazon KMS
Amazon Audit manager
Amazon Security hub
欧盟GDPR入门
Doris
领导不会看猛犸,会看有数。
Doris On ES,两个ES实现Join。
ES和MySQL进行Join。在Doris上注册。
跨库查询和联邦查询区别?
FLink写TiDB,Source Kafka写Doris。
starrocks
同时写入TiDB和Doris?场景。
rollup和物化视图区别?
定时调度,定时crud,猛犸,Azkaban。写入Doris。
FE(Java,交互,MySQL协议)和BE(C++),物理机部署,十台左右,FE三台左右。
写入LSM Tree。确定?前缀索引,稀疏索引。写入快,查询慢?Compact操作:merge on read,copy on write。
写入模型,多点还是单点。
LSM Tree和列产生关系?
向量化存储引擎。什么是向量化?https://doris.apache.org/zh-CN/docs/advanced/vectorized-execution-engine/?_highlight=%E9%87%8F%E5%8C%96
索引种类不行,多租户,资源隔离不好。贵在SSD,都是物理机。
Doris即席分析,其他架构:Hive To Doris。 有道:Doris To Hive。
数仓:
Doris还是TiDB?查询性能,不一定。
看板需求,Doris做存储末端,Kafka->Hive。
Doris Manager. 普罗米修斯监控。
TiCDC4.0有了,子航集群,没有TiCDC。
Doris建立索引,
online,offline 资源隔离,租户。
Arctic:Hive T+1取代。因为比较慢。
Hive元数据。执行引擎Hive不考虑,Spark on hive,Persteo on hive。
BE:存算结合 FE:调度节点。
SelectDB:云数仓。Doris的云数仓。
湖仓一体。
TiDB 是TiCDC。TiDB当MySQL的从。
https://selectdb.com/。
SelectDB Cloud
数据集成工具:https://github.com/alibaba/DataX:阿里云开源离线同步工具 和canal不一样。
Ceph Vs 网易开源Curve
网易数帆实时数据湖 Arctic 的探索和实践:https://www.infoq.cn/article/wgjrwk7bhrsjbh8uddhg
Doris Compaction机制解析:https://mp.weixin.qq.com/s?__biz=Mzg5MDEyODc1OA==&mid=2247485136&idx=1&sn=a10850a61f2cb6af42484ba8250566b5&chksm=cfe016c9f8979fdf100776d9103a7960a524e5f16b9ddc6220c0f2efa84661aaa95a9958acff&scene=21#wechat_redirect
Apache Iceberg
Apache DolphinScheduler
Apache SeaTunnel
你问我DataX是谁?对不起,我活在Apache SeaTunnel的时代!:https://jishuin.proginn.com/p/763bfbd707f5
Comparison of Data Lake Table Formats (Apache Iceberg, Apache Hudi and Delta Lake) :https://www.dremio.com/subsurface/comparison-of-data-lake-table-formats-iceberg-hudi-and-delta-lake/#toc_item_Delta%20Lake
箱子博客:https://blog.boluotou.tech/post/20220807-offline-data-warehouse/ https://github.com/gcnyin/hive-metastore-image/blob/master/build-hive-metastore.sh
深度对比 Delta、Iceberg 和 Hudi 三大开源数据湖方案
https://www.infoq.cn/article/fjebconxd2sz9wloykfo
数据库、缓存一致性解决方案
先删缓存,因为有的缓存计算耗时比较大。修改缓存可能缓存计算时间较长。 一种原因。 修改时间较短呢?
正常情况下,可能出现不一样。非正常情况,也可能出错。
无法完美解决,没解决一个问题,就会带来另外问题,
内存队列,会话一致性。
网络io,引发长事务问题。
1 修改(时间长短)还是删除?
2 顺序问题?先缓存,后db。先db,后缓存。
同时成功,同时失败,不重要,业务层感知。
队列保证指令有序性,一个请求必须在同一台机器,有序。
把问题留给上层。而不是机制以解决。
同步:cache sdies,通读,通写 异步:后写,队列
缓存更新方案:cache asides,通读,通写,后写。
异步队列写。
缓存更新的套路。
Cassandra指南
简介
架构
写:正常写,轻量级事务(条件插入,更新),批处理。 读:正常读,范围查询,排序,过滤,分页,UDF,UDA。
数据建模与开发
ResultSet.wasApplied()
Akka Persistence https://doc.akka.io/docs/akka-persistence-cassandra/current/index.html-案例
客户端:
NoSQL存储选型
TODO-Kafka设计与实现
ES查询与聚合
参考文档
https://www.elastic.co/guide/en/elasticsearch/reference/current/search-your-data.html
https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html
https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations.html
https://www.elastic.co/guide/en/elasticsearch/reference/current/search.html
https://www.elastic.co/guide/en/elasticsearch/reference/7.1/search.html
https://www.elastic.co/guide/en/elasticsearch/reference/7.1/query-dsl.html
笔记
ES查询和聚合的选择逻辑?
结构化搜索,全文搜索
结构化:布尔,时间,数字
字符串不是结构化的。
ES查询来自Lucene。
思考
如何对ES查询进行分类?如果找到需要的查询方法?
TODO-Consul
公司技术
腾讯云
trpc
moss
向量检索
最邻近算法
KNN(K最近邻)
ANN(近似最近邻)
LSH(位置敏感哈希)
评估最近邻搜索:速度,内存,准确性
向量数据库的核心在于相似性搜索
faiss
https://github.com/facebookresearch/faiss
https://github.com/DataIntelligenceCrew/go-faiss
openai
获取openai的Embedding: https://github.com/sashabaranov/go-openai/blob/master/embeddings.go
vector database
https://guangzhengli.com/blog/zh/vector-database/
其他
Word Embedding即词向量
检索向量后,给模型,减少了无用的语义。
视频
youtube
How to Choose a Vector Database in 2023:https://www.youtube.com/watch?v=aX_hdQEintc
IVF,HSNW
The Pinecone Vector Database System:https://www.youtube.com/watch?v=8LXotdzX_84
CMU MLDB:https://db.cs.cmu.edu/seminar2023/
b站
向量数据库技术鉴赏
https://www.bilibili.com/video/BV1BM4y177Dk
128维,每个维度32位浮点,一个向量 12832=4096位=512字节,1kw向量512字节=4.77GB
维度灾难问题
速度,质量,内存开销三个维度对近似最近邻很重要。内存是开发感知,质量和速度用户感知,牺牲内存的图结构算法:NSW算法和HNSW(Hierarchical Navigable Small Word)算法,导航小世界
OpenAI Embeddings和向量数据库速成课程
数据经过embeding模型,成了embeding
LLMs and Prompt Engineering
云厂商
腾讯 OLAMA:https://cloud.tencent.com/document/product/1709/94948
paper
Product quantization for nearest neighbor search:https://inria.hal.science/inria-00514462v2/document
Approximate nearest neighbor algorithm based on navigable small world graphs
Three and a half degrees of separation
Billion-scale similarity search with GPUs:faiss paper
向量检索算法一览与业界最新进展
https://km.woa.com/articles/show/595478
https://ann-benchmarks.com/index.html
ES
keyword search vs semantic search:关键字搜索与语义搜索
https://www.elastic.co/what-is/ https://www.elastic.co/cn/what-is/
https://www.elastic.co/what-is/vector-search
https://www.elastic.co/what-is/semantic-search
https://dbdb.io/browse?tag=nearest-neighbor-search
集团平台
Metrics
指标上报
OpenTelemetry
Prometheus
最佳实践:https://prometheus.io/docs/practices/naming/
常见公式:https://prometheus.io/docs/prometheus/latest/querying/functions/
指标类型
histogram
summary
counter
gauge
问题排查流程
Metric:发现问题 Log: 具体的错误现场 Trace:追踪链路、并发、根因、性能
OpenAI
官方文档
https://platform.openai.com/docs/introduction
使用技巧
如何写prompt
https://platform.openai.com/examples
https://platform.openai.com/docs/guides/prompt-engineering/six-strategies-for-getting-better-results
GPTs 和 AI Assistant
深入探讨GPTs和AI Assistant:技术原理和实践应用原创:https://cloud.tencent.com/developer/article/2361310
https://blog.gopenai.com/openai-assistants-api-with-langchain-c11bd018a94b
https://community.openai.com/t/difference-of-gpts-and-assistants/492689
https://medium.com/@michaelguimaraes/openai-announces-gpts-assistants-what-is-the-difference-7cf0b171ae57
https://platform.openai.com/docs/assistants/overview
https://openai.com/blog/introducing-gpts
https://platform.openai.com/playground?mode=assistant
Chat Completions API
https://platform.openai.com/docs/api-reference/chat/object
https://platform.openai.com/docs/guides/text-generation/chat-completions-api
embedding model
https://openai.com/blog/new-and-improved-embedding-model
书籍
《LangChain入门指南:构建高可复用、可扩展的LLM应用程序》
ChatGPT原理与实战:大型语言模型的算法、技术和私有化
ChatGPT风暴 大语言模型、生成式AI与AIGC颠覆创新范式
HuggingFace自然语言处理详解——基于BERT中文模型的任务实战
ChatGPT原理与架构:大模型的预训练、迁移和中间件编程
AIGC绘画ChatGPT+Midjourney+Nijijourney
大规模语言模型 从理论到实践
GPT图解
多模态大模型 技术原理与实战
自然语言处理导论:https://intro-nlp.github.io/
这就是ChatGPT
智源大会:黄仁勋,sam altman,sundar pichai,杨立昆(Yann Le Cun),yoshua bengio,geoffrey hinton
alec radford
AGI:通用人工智能
PPO,
Harnessing the Power of LLMs in Practice: A Survey on ChatGPT and Beyond:https://arxiv.org/pdf/2304.13712.pdf
A General Language Assistant as a Laboratory for Alignment:https://arxiv.org/pdf/2112.00861.pdf
Emergent Abilities of Large Language Models:https://arxiv.org/pdf/2206.07682.pdf
GPT的大思路是 通过生成来获取世界模型的压缩表示。自回归生成架构解决无监督学习问题。
https://karpathy.ai/stateofgpt.pdf
计算不可约性原理
大模型
dify
https://github.com/langgenius/dify
教程
【清华NLP】刘知远团队大模型公开课全网首发|带你从入门到实战 https://www.bilibili.com/video/BV1UG411p7zv/
Fine-tuning(大模型微调)
Pre-Learning(预训练)
预训练 就是指预先训练的一个模型或者指预先训练模型的过程。
微调 就是指将预训练过的模型作用于自己的数据集,并使参数适应自己数据集的过程。
预训练(Pre-training)是预先在大量数据上训练模型以学习通用特征,而微调(Fine-tuning)是在特定任务的小数据集上微调预训练模型以优化性能。
iCode
LLM模型评测
核心论文
A Survey on Evaluation of Large Language Models: https://arxiv.org/pdf/2307.03109
Prompt Engineering Guide : https://www.promptingguide.ai/zh
Prompt Engineering 技术:
Zero-Shot Prompting
Few-Shot Prompting
Chain-of-Thought Prompting
Self-Consistency
Generated Knowledge Prompting
Prompt Chaining
Tree of Thoughts (ToT)
Retrieval Augmented Generation (RAG)
Automatic Reasoning and Tool-use (ART)
Automatic Prompt Engineer (APE)
Active-Prompt
Directional Stimulus Prompting
PAL (Program-Aided Language Models)
ReAct Prompting
Reflexion
Multimodal CoT Prompting
GraphPrompts
评测目的
- 了解模型好坏程度和优缺点。
- 更好指导与人类交互优化,进行模型优化。
评测特点
- 不能简单说对/错,只能说好/坏,需要设计指标度量对比。
- LLM通用能力强,应用面广,单任务评测不适用,需要设计Prompt拆解多任务评测。
评测挑战
- 快速接入模型,对比效果。
- 客观量化,公平,对比模型性感差异。
- 评估成本高,效率低。
评测场景
- 通用评测。
- 业务落地评测。
- 多模态评测。
评测方式
建立一套可量化的指标,告诉哪个更好,以及好多少。
1 人工体验(体验模型效果,解决日常问题,单模型对话)
2 人工对比体验(模型多多对比,多模型对比)
3 客观自动化评估(NLP基准评测,学科考试基准评测)
4 主观自动化评估(开放问答基准评测)
方法 | 评测方法 | 适用场景 | 优劣 |
---|---|---|---|
人工体验 | 单模型对话 | 体验模型效果 解决日常问题 | 单模型打分,方便但缺乏统一评价标准 |
人工对比体验 | 多模型对比 | 模型两两对比 | 通过对比容易发现差异,但不够全面 |
客观自动化评测 | 传统算分(准确率/Bleu/Rouge) | NLP基准评测 学科考试基准评测 | 大规模评测,更客观准确和全面,但仅适合有标准答案的问题 |
主观自动化评测 | GPT4打分 | 开放问答基准评测 | 大规模评测,有统一且相对客观的评价标准,覆盖率较广,但是对复杂问题自动化打分存在BadCase。 |
评测标准
ROUGE(Recall-Oriented Understudy for Gisting Evaluation):自动摘要评价指标
BLEU(Bilingual Evaluation Understudy):机器翻译系统生成结果的质量的指标
准确率(Accuracy):准确率 = (正确预测的样本数 / 总样本数) * 100%
精确率(Precision):TP/TP+FP
召回率(Recall):TP/TP+FN
F-score
评测方案
Open AI Evals:fact,closedqa,battlw
PandaLM:https://github.com/WeOpenML/PandaLM
HELM(holistic evaluation of language models): https://crfm.stanford.edu/helm/classic/latest/
系统评测
- 评测集设计
客观(有正确答案或者参考答案):选择题,特定任务(文本摘要,机器翻译,语法纠错),few shot,cot
主观(没有正确答案):开放性问答,多轮对话【GPT4打分,主观】
- 基础能力评测
NLU:阅读理解,自然语言推理,语义相似度,安全性测试,情感分析,文本分类,常识问答,命名实体识别【Accuracy】
NLG:文本摘要(Rouge-L),机器翻译(Bleu),多轮对话(Blue),句子完成(Accuracy),语法纠错(F1 Score)
中文和英文能力
- 学科考试能力评测
MMLU:https://github.com/standardgalactic/mmlu
C-Eval:https://cevalbenchmark.com/index_zh.html
AGIEval:https://github.com/ruixiangcui/AGIEval
GAOKAO:https://gitee.com/hf-models/telechat-7B
- 鲁棒性评测
鲁棒性评测主要看diff百分比,Diff=(最佳-最差)/最佳
抗干扰评测:添加干扰信息观察模型时候可以正确作答
- FewShot学习能力评测
gpt4学习能力遥遥领先,chatgpt对比国内模型依然有明显优势;
例子数量K与Acc成正相关,但对于国内模型,K超过5之后Acc存在一定震荡。
强调学习能力,与知识储备无关。
Single-Turn-ICL/Multi-Turn-ICL(In-Context Learning)
- 思维链COT评测(思考分析推导+Prompt激活词)
思维链COT推导能力评测,就是大模型涌现出来的思考分析推导的能力,一般在Prompt中加入一些激活词,比如一步步推导、逐步推理,就可以激活模型做思考链推导分析, 非推理类,加COT没有提升反而下降。 推理类的,没训练过,加COT后可能有提升。 推理类的,训练过的,加COT不一定有提升。
激活词:请一步步的推理分析解决以下问题/请逐步推理回答问题
- 开放性问答评测
用GPT4打分+人工纠正
GPT4自动评分效果行业主流认可:1 聊天 2 主观问题 3 推理分析 4 其它 5 客观知识问题 6 创作生成
- 多轮对话能力评测
第二问依赖第一问,第二问独立于第一问,第二问质疑第一问
缺乏配套的平台支撑工具、缺少闭源业务评测集、评测覆盖面不够细,OpenAI Evals主要还是做了NLP基础能力评测这块
- 长文本评测
大海捞针评测
长文本FAQ问答评测
多文档阅读理解评测
- 多模态评测
图生文、文生图
业内常用框架
OpenAI Evals,Chatbot Arena,MT-Bench,AlpacaEval等。
评测工具 | 地址 | 所属机构 | 开放能力 | 数据规模 | 核心价值点 |
---|---|---|---|---|---|
OpenAI Evals | https://github.com/openai/evals | OpenAI | 评测框架代码/数据集均开源 | 585 | 评测框架代码扩展性强,评测集丰富全面 |
OpenCompass司南 | https://opencompass.org.cn/home | OpenXLab | 提供第三方评测服务,开源评测框架代码,数据集半公开 | 50+ | 评测框架代码可用,评测集分类丰富可借鉴 |
FlagEval天秤 | https://flageval.baai.ac.cn/#/home | 智源 | 提供第三方评测 | 100+ | 评测集分类方法可借鉴 |
CLEVA | https://github.com/LaVi-Lab/CLEVA | LaVi-Lab | 开源中文评测数据集 | 66个中文评测集,59266道题 | 中文评测集可即借鉴 |
SuperCLUE | https://github.com/CLUEbenchmark/SuperCLUE | CLEUE | 提供第三方评测服务 | 1k+ | 评测集分类方法可借鉴 |
AlpacaEval | https://tatsu-lab.github.io/alpaca_eval/ | 斯坦福大学 | 开源英文指令遵循评测集 | 5个评测集,805道题 | 提供基础验证集合 |
Prompt优化
Claude Anthropic
https://docs.anthropic.com/zh-CN/prompt-library/library
CO-STAR框架
https://mp.weixin.qq.com/s/AWnQL3forAP-gB7e2ZEXdQ
C:context O:objective S:Style T:Tone A:audience R:Response
其它笔记
平台的创新点:
-
平台可视化对比:汇总对比、详情对比、图标分析工具:胜负对战分析,对战热力分析,模型鲁棒性分析,雷达图分析,LeaderBoard
-
自助评测,自助自动化评测,
-
覆盖面广(涵盖知识,理解,推理,考试,对话,代码,安全)
从对错道好坏,分数。
In-context learning fewshot
FewShot:给例子让模型学习 COT:给出推理让模型学习。
鲁棒性测试,抗干扰测试:模型多次输入答案是不是一样的。【阅读理解:多次选项不一样,是防止刷题作弊】
GPT4评分,设计prompt,告诉评分标准。
https://github.com/MLGroupJLU/LLM-eval-survey
LLM 在生产领域的一个巨大的痛点:如何高效地评估这些开源的本地模型,能否达到我需要的生产性能?
评价体系:Chatbot Athena、Open LLM、OpenAI Evals
为什么我反而会认为 OpenAI 的Evals 框架,才是真正有价值的 LLM 生产标尺?核心原因就是 LLM 在工业生产中真正被需要评估的特性是:指令跟随。
OpenAI Evals:Match:完全匹配,FuzzyMatch:模糊匹配,Includes:模型输出
https://github.com/openai/evals/blob/main/docs/eval-templates.md
https://github.com/athina-ai/athina-evals
https://github.com/bentoml/OpenLLM
准确率以外,Evals 还提供了标准差、精确度、召回率、F-Score 、平均 F-Score
正是因为 Evals 可以自定义评估任务、评估比较方法、评估指标、评估模型,我们在业务生产中就可以轻易地使用它来检测模型性能,接入生产的CI/CD 链路中。
https://github.com/WeOpenML/PandaLM/tree/main?tab=readme-ov-file
opencompass自动化评测平台:https://opencompass.org.cn/home https://github.com/open-compass/OpenCompass/
阿里云大模型自动化评测平台:https://help.aliyun.com/zh/model-studio/model-evaluation/
opencompass:https://github.com/open-compass/OpenCompass/
COT(Chain Of Thought):https://cloud.tencent.com/developer/article/2428185 比如数学推理,给出步骤,包括Few-shot CoT,Zero-shot CoT
模版:Question ChainOfThought Answer | Test Question
Question Answer | Test Question
Zero-Shot-CoT方法存在不稳定性,而Manual-CoT方法需要大量人工成本投入。作者提出了一种基于Auto-CoT的方法
ICL(In-Context Learning):https://cloud.tencent.com/developer/article/2428186
一文总结提示工程框架,除了CoT还有ToT、GoT、AoT、SoT、PoT:https://blog.csdn.net/xixiaoyaoww/article/details/133101929
增强LLM推理:Chain-of-Thought,Chain-of-Thought-Self-Consistency,Tree-of-Thoughts,Graph-of-Thoughts,Algorithm-of-Thoughts,Skeleton-of-Thought,Program-of-Thoughts
COT:与其直接输出答案,不如为语言模型提供中间推理示例来指导其响应。
COTC:构建多个思维链,对每个思维链进行评估,最终选择最有效、最连贯的思维链。
TOT:以树状形式展开思维链。允许回溯,探索从一个基本想法产生的多个推理分支。 https://arxiv.org/pdf/2305.10601
GOT:将树结构演化为直接非循环图,引入了自我循环。自我循环可以巩固一条特定的思路,也可以将多个想法聚合成一个连贯的思路。
AOT:维护单个不断发展的上下文链,消除了对思维树中冗余查询的需求。它探索了一条多变的推理之路。
SOT:首先生成一个答案蓝图,然后并行地充实细节,从而减少生成完整答案所需的时间。
PoT:将问答背后的推理过程公式化为一个可执行程序,将程序解释器输出作为最终答案的一部分。
大模型评测:https://wqw547243068.github.io/llm_eva
Prompt Engineering Guide 学习笔记
LLM研究:Agent(记忆,规划,工具),RAG(输入,索引,检索,生成),推理,忠实度,上下文记忆,减少幻觉,
对话平台技术
对话的技术栈。
学习笔记
https://github.com/alibaba/nls-dialog-sdk
https://github.com/alibaba/nls-dialog-toolkit
https://github.com/alibaba/nls-dialog-demo
类别 | |
---|---|
etcd,mongodb,redis,rabbitmq | 中间件 |
docker,docker-compose | 容器 |
Faas | 架构 |
etcd
mongodb
rabbitmq
docker
supervisor
jmh
区块链交易所技术
我在区块链交易所工作时候的技术栈。
技术学习笔记
后端 | 类别 |
---|---|
AWS: EKS,EC2,ELB,Aurora,Rancher 阿里云:Logtail,SLS K8S,isito等 | 云厂商/运维 |
Redis Cluster,RocketMQ/RabbitMQ,MySQL master-slave,Sharding-JDBC | 中间件 |
服务化:Spring Cloud Alibaba 2.1.0.RELEASE、Spring Boot 2.1.5.RELEASE,Spring Cloud Gateway 2.1.0.RELEASE 注册中心:Eureka -> Nacos 1.1.0 -> k8s service+ coreDNS 配置中心:Nacos->ConfigMap 限流,降级:Guava RateLimter -> Sentinel 1.6.3 熔断: resilience4j 链路追踪:Sleuth RPC:OpenFeign | 微服务 |
单元测试:junit5+assertj+Mockito+JSONAssert 性能测试:JMH 代码审查:Alibaba P3C, NCSS,PMD,SpotBugs,jdepend 数据库审计平台:Yearning | 持续集成 |
Disruptor,disruptor-spring-manager,dragonboat , SOFAJRaft,RoaringBitmap,Arthas,唯一ID生成:uid-generator | 其他 |
Gin Web Framework,Redigo,gomail,logrus,go-sql-driver,go.uuid | Golang |
Arthas
https://arthas.aliyun.com/
方法耗时追踪
curl -O https://arthas.aliyun.com/arthas-boot.jar
java -jar arthas-boot.jar
https://arthas.aliyun.com/doc/trace.html
trace outfox.ke.students.service.adaplearn.AdapWeekService createWeekCards
AWS
RocketMQ
Sharding-JDBC
极客时间
02-左耳听风-陈皓
https://time.geekbang.org/column/intro/100002201
12-从0开始学大数据 李智慧
https://time.geekbang.org/column/intro/100020201
16-技术与商业案例解读-徐飞
软件 | 商业公司/发行商/专业公司 | 创始人 |
---|---|---|
MongoDB | MongoDB.com | |
Hadoop | Cloudera | |
Hadoop | MapR | |
Hadoop | Hortonworks | |
Kafka | Confluent.com | |
Palantir | ||
Splunk | ||
HBase | ||
Cassandra | DataStax | |
Spark | Databricks | |
Flink | Data Artisans | |
Spring,RabbitMQ,Greenplum,Cloud Foundry | Pivotal | |
MySQL, MariaDB, PostgreSQL, MongoDB and RocksDB | Percona | |
MySQL | Oracle | |
Akka | Lightbend | |
Apache Drill,Apache Arrow | Dremio | |
Apache Druid | Imply | |
Apache Kylin | Kyligence | |
Snowflake | Snowflake | |
TiDB | PingCAP | |
Hazelcast | Hazelcast.com | |
Redis | redis.com | |
Dubbo,Seata,RocketMQ,SpringCloudAlibaba ..... | Alibaba | |
Databend | Databend | |
Apache Pulsar,Apache BookKeeper | steamnative |
56-大规模数据处理实战 蔡元楠
https://time.geekbang.org/column/intro/100025301
62-ElasticSearch核心技术与实战-阮一鸣
https://github.com/geektime-geekbang/geektime-ELK
关键字
近实时,分布式存储/搜索/分析引擎
es节点类型:master,coordinate,data,hot,warm,ml
结构化,全文,地理位置,自动补全
同一文档并发更新
索引是文档的容器
每个节点都保存了集群的状态,只有master才能修改集群的状态。任意节点修改会导致数据不一致。 集群状态包括:1 所有节点信息 2 所有索引和mapping setting信息 3 分片的路由信息。
每个节点默认起到了协调节点的作用,接受Client请求,并请求发送到合适的节点,最终将结果汇聚。
主分片在索引创建时指定,后面不可修改,除非reindex。
一个分片是一个Lucene实例。
通过分片实现水平扩展和数据的可用性。
429:集群过于繁忙。
每个文档有一个版本号,用于并发控制避免冲突。
倒排索引实现:单词词典(Term Dictionary- B+ tree或哈希实现,记录单词到倒排列表关系)+倒排列表(Posting list- 记录单词到对应文档)
通过Analyzer进行分词:文本转成单词过程叫分词。Character Filter -> tokenizer -> token filter
ICU Analyzer
分页:from size
排序:sort
修改字段类型,必须reindex,重建索引。
多字段类型:一个字段既可以是keyword,也可以是text。
精确值:keyword,数字,日期,布尔 全文本:text(非结构化文本)
精确值不需要被分词,但是会为每个字段建立索引。精确值在索引时,不需要特殊分词处理。
Index Template,Dynamic Template
聚合类型:bucket(划分文档可以term或range),metric(min,max,sum,avg,cardinality),pipeline,matrix
term查询,对输入不分词,在倒排索引中查询准确的词项,并且使用相关度算分公式为词项的文档进行相关度算分。通过constant score将查询转换成giltering,避免算分,并利用缓存,提高性能。
term查询:term,range,exist,prefix,wildcard
将query转换成filter,忽略tf-idf计算,避免相关性算分开销。
全文查询:索引和搜索都进行分词。match,match_phrase,query string,必须要进行相关算分
结构化检索:精确匹配或者部分匹配,不需要打分判断相似性 。 结果:有或无。根据场景需要,来看结构化搜索是否需要打分。
相关性打分:文档和查询语句匹配度。打分本质是排序。settings.similarity
boosting:控制相关度的方法 boosting query
打分es5.0从TF-IDF升级为BM25
Query Context:相关性算分 Filter Context:不需要算分,利用缓存性能更好
bool查询:复合查询 must 必须匹配,贡献算分 should 选择性匹配,贡献算分 must_not filter context,查询字句,必须不能匹配 filter:必须匹配,不贡献算分。4种子句,2个影响算分,2个不影响。
单字符串多字段查询:bool,disjunction max query,multi match
多语言检索技巧:归一化词元,单词词根抽取,同义词,拼写错误
search template
index alias 实现零停机运维,创建不同的查询视图
查询后重新算分:function score query,用来控制算分
搜索建议 suggest as you type
term/phrase suggester
自动补全:completion suggester(基于FST和索引,而不是倒排索引)
基于上下文提示:context suggester
精准度:completion>phrase>term 召回率:term>phrase>competion 性能:completion>phrase>term
处理请求节点-协调节点:如果是创建/删除索引请求,需要路由到master。请求可以发送到任何节点。
master node决定把分片分发到data node上。
master node:创建,删除索引请求,决定分片分发到哪一个数据节点,维护并且更新集群状态,然后同步给其它节点。
如何避免脑裂:限制选举条件,设置仲裁quorum。quorum=master节点/2+1,从而避免脑裂问题。
副本分片出现导致每个节点都有完备的数据。不设置副本分片数,一旦节点关闭,就会导致数据丢失。
文档到分片的路由算法:shard=hash(_routing) % number_of_primary_shard _routing默认是文档ID。
近实时 1s后被搜到。倒排索引的不变性。不变性带来挑战:如果让一个新的文档可以被搜索,那么需要重建整个索引。
refresh:index buffer写入segment过程叫refresh。不执行fsync操作。每秒执行一次,查询后查找所有的segment,对结果汇总。refresh之后,文档可以被搜索了。清空index buffer,不会清空trans log。
index buffer,tran log。
flush:30分钟一次,调用refresh,index buffer清空,调用fsync缓存种segment写入磁盘,清空tran log,
tran log:segment写入磁盘耗时。refresh时候,segment先写入缓存,为了保证数据不丢失,index文档时候,既写index buffer,同时写trans log,默认落盘。
分布式搜索机制:两步 1.Query 2.Fetch 协调节点将请求发到数据节点,数据节点查询后将数据返回到协调节点,协调节点会把每个分片文档重新排序。
Query then fetch存在问题:
一 性能问题:1 每个分片查询文档from+size 协调节点需要处理number_of_shard * (from + size),存在深度分页问题。
二 相关性算分不准:主分片越多,相关性算分越不准。相关性算分在分片之间是独立的。
可以使用DFS Query then fetch:
到每个文档把各个分片词频和文档频率搜集,完整的进行一次相关性得分,耗费更多CPU和内存,性能较差。
排序是根据字段原始内容进行,倒排索引无法发挥作用,需要正排索引。通过文档ID和字段快速得到字段原始内容。
分词和相关性没有关系。结构化查询有分数,但是没有分词。
对Text类型进行排序:FieldData,搜索运行时创建。filed data只能对text进行排序。
排序实现:doc values(列式存储,不支持text)和 filed data(支持text排序)
关闭doc values:明确不需要排序和聚合分析。
from:990 size:10 协调节点会在每个分片获取1000个文档,协调节点聚合所有结果,最后排序选前1000个。页数越深,占用内存越多。es避免深度分页,设置了10000个文档。from+size < 10000
search after避免深度分页,不支持指定页数from,只能往下翻。实时获取下一页文档信息。类似于书签。如果size=10,查询990-1000,实现通过唯一排序值定位,将每次处理文档控制在10以内。每次使用上一个文档的sort值进行查询。
scroll 获取全部数据快照。
三种搜索类型:实时获取顶部部分文档 search after 需要全部文档,导出数据 scroll 分页 from size,深度分页,选择search after
Query(结构化) VS Search(非结构化)
Restful API VS Transport API
近实时分析,近实时搜索
Logstash Persistent queue
ELKB(Beats)
Instant Aggregation
Logstash ArcSight
基于词项和基于全文搜索
相关度算分公式
多字段mapping。多字段属性。
复合查询:Constant Score转为Filter
结构化搜索。
Boosting Relevance:Boosting Query
Context:Query Filter
解决结构化查询:包含而不是相等问题。
如何实现should not逻辑?
单字符串多字段查询:Disjunction Max Query:Tie Breaker
单字符串多字段查询:Multi Match
统计的机器学习算法:CRF算法,HMM算法,svm算法
HighLight
Search Template
Index Alias
Function Score Query
Suggester:4种 有拼写检查,自动补全(Finite-state transducer),上下文提示。
https://github.com/seperman/fast-autocomplete
相似性算分:Levenshtein Edit Distance
Precision 和 Recall
Coordination Node:处理请求的节点。 Data Node:保存数据的节点。
ES如何避免脑裂问题?
https://github.com/lmenezes/cerebro
Refresh和Flush
ES搜索过程。
Github代码搜索实现用ES。
近实时搜索和分析能力。
集群滚动升级。
查询评分,过滤不评分。评分计算相关度。
使用查询(query)语句来进行 全文搜索或者其它任何需要影响 相关性得分 的搜索。除此以外的情况都使用过滤(filters)。
boolean查询:must,must_not,should,filter。
constant_score查询取代只有filter的bool查询。
多字段:一个字段用于搜索(index=analyzed),一个字段用于排序(index=not_analyzed)。
TF/IDF (词频次数,文档频次数)
倒排索引用来检索(关键字找结果集),DocsValue(结果集找关键值的集合)用来字段排序,聚合。
分布式检索的过程:query then fetch。或者 dfs_query_then_fetch
“深分页” 很少符合人的行为。一般是爬虫或者机器人的行为。
bouncing results问题:两次查询,结果不一样。
ES字段可以自动推算。all字段7.0废除。版本用来解决文档冲突功能。_score 相关性分数。
索引设置Mapping和Settings。
ES:相关性,高性能全文索引, RDMS:事务,join。
节点类型:master-eligible, master, data, coordinating,hot/warm,machine learning node,tribe node。每个节点单一类型,master才能对集群数据,状态修复。
主分片不能修改,除非reindex,副本分片可以动态调整。一个索引三个主分片,一个副本分片。
修改POST,索引PUT,POST create会自动创建id,PUT必须指定。POST是修改,PUT的新增。
BULK一条失败,不会影响其他。
批量命令:BULK,MGET,MSEARCH。
倒排索引:索引页。关键字在书本的位置。正排索引:目录页。
倒排索引结构:term dictionary和posting list(倒排列表),记录位置,因为需要语句搜索。
phrase:语句
mapping中某些字段不做索引,缺点无法被搜索,优点节省空间。
Analysis:文本分析把全文转换成一系列term/token。通过Analyzer实现。分词器由三部分组成。Analyser原理是什么?Character Filter -> Tokenizer -> Token Filter
输入不用分词,用keyword analyzer。
中文分词器:ICU,IK,THULAC 清华
计算机学科:Information Retrieval
Precision=True Positive / (True Positive + False Positive),
Recall= True Positive / (True Positive + False Negative)
Ranking。
查询评估:
- 查到该查到 True Positive 真阳性
- 查到不该查到 False Positive 假阳性
- 没查到不该查到 True Negative 真阴性
- 没查到应该查到 False Negative 假阴性
表头 | 查到 | 没查到 |
---|---|---|
正确 | True Positive | False Negative |
错误 | False Positive | False Negative |
Dynamic Mapping 自动推断(自动识别)类型,索引不存在,自动创建。
Dynamic Mapping的Text字段会自动加keyword子字段。但是strict不会自动加keyword子字段。
多字段类型:特定字段特定分析器,指定不同的analyzer。
精确值keyword VS 全文text,精确值不需要被分词。text是文本类型,keyword关键字类型。
ES默认创建文档,“name”:"Alibaba",name会text并且keyword子字段,term查询”Alibaba“会查不到。term查询不会分词。要想查询到,需要用keyword查询。term查询也会算分,跳过算分,使用constant_score不算分了。
TF/IDF,BM25
条件组合,bool查询。对字段查询,bool查询两个算分,两个不算分。
- 单字符串多字段查询(Google,百度的查询模式)
- bool query(字段算分加和)
- disjunction(分离) max query。
- multi match query
分词,nlp,搜索引擎关系,nlp是自然语言处理技术,其中可以用来中文分词。
百度analysis-baidu-nlp:百度NLP中文分词插件。
HanLP作者的书《自然语言处理入门》 https://www.ituring.com.cn/book/2706
Search Template 查询模板化。 https://mustache.github.io/
索引别名
- 别名是只读的。
- 多个索引对应一个别名。
- 一个索引对应多个别名。可以加过滤器。
function score query中,bm25分数一样,但是可以修改分数。可以优化默认算分。算分重排。
分片number_of_shards 副本number_of_replicas
只有一个master节点,多个master eligible节点。
脑裂:限定选举条件。
主分片设置为1,单个分片数据量太大,单机。
ES三节点,3分片1副本,关掉一台机器,集群变黄,过一会,集群会自动重新分配分片,然后变绿。
命令
查看mapping和settings:GET /la-adap-plan-tpl_v1
GET /la-adap-plan-tpl_v1/_settings
GET /la-adap-plan-tpl_v1/_mapping
GET /la-adap-plan-tpl_v1/_count
GET /_cat/indices
GET /_cat/indices/kibana*?v&s=index
GET /_cat/indices?v&health=green
查看文档数量:GET /_cat/indices?v&s=docs.count:desc
GET /_cat/indices/kibana*?pri&v&h=health,index,pri,rep,docs,counts,mt
查看索引所占内存:GET /_cat/indices?v&h=i,tm&s=tm:desc
URI Search(Query String)
GET /la-adap-plan-tpl/_search?q=9&df=id
{
"profile": "true"
}
泛查询
GET /la-adap-plan-tpl/_search?q=9
{
"profile": "true"
}
GET /la-adap-plan-tpl/_search?q=id:9
{
"profile": "true"
}
Analyzer
GET /_analyze
{
"analyzer": "standard",
"text":"lili 111 222 你好北京"
}
POST /users/_analyze
{
"field": "name",
"text": [111]
}
POST /_analyze
{
"tokenizer": "standard",
"filter": ["lowercase"],
"text": ["Mastering Elasticsearch"]
}
自定义分词器
CharacterFilter 加工文本 Tokenizer:文本到词 Token Filters:词再次加工
爬虫过滤了html标签
POST _analyze
{
"char_filter": ["html_strip"],
"tokenizer": "keyword",
"text": ["<html>lili</html>"]
}
输入字符串替换
POST _analyze
{
"char_filter": [
{
"type": "mapping",
"mappings": [
"- => _"
]
}
],
"tokenizer": "standard",
"text": "123-456, I-test!"
}
搜索到任意一级目录
POST _analyze
{
"tokenizer": "path_hierarchy",
"text":"/user/a/b/c/d"
}
POST _analyze
{
"tokenizer": "whitespace",
"filter": ["stop"],
"text": ["The rain"]
}
POST _analyze
{
"tokenizer": "whitespace",
"filter": ["lowercase","stop"],
"text": ["The rain"]
}
Request Body查询
高阶方法只能在RequestBody里面做。
GET /la-adap-plan-tpl/_search
{
"_source": ["id","learningPlans"],
"query": {
"match_all": {}
}
}
match,match_phrase
GET /users/_search
{
"query": {
"match": {
"title": {
"query": "111",
"operator": "and"
}
}
}
}
GET /users/_search
{
"query": {
"match_phrase": {
"title": {
"query": "111",
"slop": 1
}
}
}
}
Query String Query
POST /users/_search
{
"query": {
"query_string": {
"default_field": "user",
"query": "mike OR lili2"
}
}
}
POST /users/_search
{
"query": {
"simple_query_string": {
"query": "lili OR mike",
"default_operator": "OR"
}
}
}
Dynamic Mapping
PUT mapping_test/_mapping
{
"dynamic":true
}
PUT mapping_test/_mapping
{
"dynamic":false
}
PUT mapping_test/_mapping
{
"dynamic":"strict"
}
自定义Mapping
NULL_VALUE
论文
Karen Sparck Jones: A statistical interpretation of term specificity and its application in retrieval
Stephen Robertson: The Probabilistic Relevance Framework: BM25 and Beyond
74-消息队列高手课-李玥
78-Zookeeper实战与源码剖析-么敬国
90-分布式技术原理与算法解析 聂鹏程
https://time.geekbang.org/column/intro/100036401
Keywords
分布式互斥(集中式算法,分布式算法P2P,令牌环算法,两层结构的分布式令牌环算法)
分布式选举(Buddy,Raft(2014),ZAB(2011)) crash-recovery atomic broadcast algorithm
分布式共识(PoW 工作量证明,PoS 权益证明,DPos 委托权益证明)
分布式事务(2PC,3PC,MQ) 刚性事务 ACID 柔性事务 BASE
ACID:2pc,2pc Base:MQ
分布式锁(ZK,DB,Redis) 分布式锁羊群效应
分布式体系结构:集中式(Borg(2015),Mesos(2013),K8S(2014)) Mesos+Marathon(Docker,cgroups)
分布式体系结构:非集中式(Akka Cluster(可容错,去中心化集群管理), Redis Cluster, Cassandra Cluster) akka,redis是去中心化,但是需要选主,而cassandra是p2p,不用选主
分布式调度
单体调度:Bord Scheduler,Hadoop,Spark,K8S
两层调度:Mesos(MMF-最大最小公平算法,DRF-主导资源公平算法),Yarn
共享状态调度:Google Omega,Microsoft Apollo,Hashicorp Nomad
分布式计算 MapReduce(Fork-Join) Stream:Storm,Flink,Spark,yahoo S4,Facebook Puma,Baidu Dstream,Taobao银河流数据处理平台,InfoSphere Stream Actor:Erlang/OTP, Akka,Quasar 流水线:tersorflow
分布式通信 RPC,RMI,Dubbo 消息(P2P,PubSub),Kafka 消息队列 RocketMQ
CAP CA:mysql,oracle CP:Redis,HBase,ZK AP:Eureka,CoachDB,Cassandra,DynamoDB
分布式存储 分布式数据库(结构化):MySQL sharding,Microsoft SQL Azure, Spanner, OceanBase 分布式键值对(半结构化):Redis,Memcache 分布式存储(非结构化):Ceph,GFS,HDFS,Swift(OpenStack)
数据分布(Sharding) Hash 一致性Hash(Cassandra) 带有限负载的一致性Hash(Google Cloud Pub/Sub, HAProxy) 带有虚拟节点的一致性Hash(Memcache)
数据复制 同步复制(MySQL) 异步复制(MySQL默认,Redis Cluster) 半同步复制(ZK CP,Microsoft SQL Azure Cloud SQL Server, ETCD)
MySQL 全同步复制 半同步复制 异步复制 Oracle 最大保护模式 最大性能模式 最大可用性模式
故障检测 固定心跳检测策略 (K,T) 历史心跳信息预测故障策略:phi φ值检测:akka,hz
网络分区处理策略(产生很多分区后,选择一个分区对外服务) 集中式拓扑与非集中式拓扑 Static Quorum Keep Majority(保留子集群节点数w>n/2的集群,如果分区过多,很难从很多分区找出一个>n/2集群) 设置仲裁机制 基于共享资源方式处理网络分区
Akka network partion 发现 stable-after 处理策略 Static Quorum Keep Majority Keep Oldest Keep Referee Down All Lease Majority
Hazelcast network partion Bron–Kerbosch algorithm
OOP vs Aoctor
E-PVM算法
Akka Cluster:面向应用程序平台的分布式集群管理
Spark,Hadoop,Marathon
Docker,Rocket
Memcache Ketama算法
Repcache实现Memchche的复制功能
Notes
吞吐量 qps tps bps
akka虽然有Leader和非Leader节点,但是不影响非集中式结构的节点的平等关系。节点有角色,但是没有控制关系。
去中心化和选主没有必然关系。一般master/slave是集中结构,而leader/非leader是非集中结构。也不一定。
Acotr=状态+行为+消息
Omega是Borg的下一代。
Question
为什么需要分布式系统?
一致性和共识区别?
Wiki
Person
Jeff Dean
Sage Weil: https://en.wikipedia.org/wiki/Sage_Weil
Sanjay Ghemawat
Paper
PacificA: Replication in Log-Based Distributed Storage Systems 2008
Large-scale cluster management at Google with Borg
Dominant Resource Fairness: Fair Allocation of Multiple Resource Types
Apollo: Scalable and Coordinated Scheduling for Cloud-Scale Computing
Omega: flexible, scalable schedulers for large compute clusters
Consistent Hashing with Bounded Loads Google 2017
The φ Accrual Failure Detector
Paper Recommend
理论基础
Time, Clocks, and the Ordering of Events in a Distributed System 1978 Lamport
The byzantine generals problem 1982 LAMPORT
Brewer’s Conjecture and the Feasibility of Consistent, Available, Partition-Tolerant Web 2002 Seth Gilbert Nancy Lynch
CAP Twelve Years Later: How the "Rules" Have Changed 2012 Eric Brewer
Base: An Acid Alternative 2008 Dan Pritchett, Ebay
A simple totally ordered broadcast protocol 2008
Virtual Time and Global States of Distributed Systems 2002
分布式一致性算法
A brief history of Consensus, 2PC and Transaction Commit. 2007
Paxos Made Simple 2001 Lamport
Paxos Made Practical 2007 David Mazieres
Paxos Made Live - An Engineering Perspective 2006 Tushar Deepak Chandra Robert Griesemer Joshua Redstone
In Search of an Understandable Consensus Algorithm(Extended Version) 2014 Diego Ongaro and John Ousterhout
ZooKeeper: Wait-free coordination for Internet-scale systems 2010
Using Paxos to Build a Scalable, Consistent, and Highly Available Datastore 2011
Impossibility of Distributed Consensus with One Faulty Process 1985
Consensus in the Presence of Partial Synchrony 1988
分布式数据结构
Chord: A Scalable Peer-to-peer Lookup Protocol for Internet Applications 2003
Pastry: Scalable, Decentralized Object Location, and Routing for Large-Scale Peer-to-Peer Systems 2001
Kademlia: A Peer-to-Peer Information System Based on the XOR Metric 2002
A Scalable Content-Addressable Network 2001
Ceph: A Scalable, High-Performance Distributed File System 2006 OSDI Sage Weil
The Log-Structured Merge-Tree (LSM-Tree) 1996
HBase: A NoSQL Database 2017 Hiren Patel
Tango: Distributed Data Structures over a Shared Log 2013
分布式系统实战
The Google File System 2003 Sanjay Ghemawat
Bigtable: A Distributed Storage System for Structured Data 2006
The Chubby lock service for loosely-coupled distributed systems 2006
Finding a needle in Haystack: Facebook's photo storage 2010
Windows Azure Storage: A Highly Available Cloud Storage Service with Strong Consistency 2011
Resilient Distributed Datasets: A Fault-Tolerant Abstraction for In-Memory Cluster Computing 2012
Scaling Distributed Machine Learning with the Parameter Server 2014
Dremel: Interactive Analysis of Web-Scale Datasets 2010
Pregel: A System for Large-Scale Graph Processing 2013
Spanner: Google's Globally-Distributed Database 2012
Dynamo: Amazon’s Highly Available Key-value Store 2007
S4: Distributed Stream Computing Platform 2010
Storm @Twitter 2015 https://cs.brown.edu/courses/cs227/archives/2015/papers/ss-storm.pdf
Large-scale cluster management at Google with Borg 2015
F1: A Distributed SQL Database That Scales 2013
Cassandra - A Decentralized Structured Storage System 2009
Megastore: Providing Scalable, Highly Available Storage for Interactive Services 2011
Dapper, a Large-Scale Distributed Systems Tracing Infrastructure 2010
Kafka : a Distributed Messaging System for Log Processing 2011
Amazon Aurora: Design Considerations for High Throughput Cloud-Native Relational Databases 2017
Amazon Aurora: On Avoiding Distributed Consensus for I/Os, Commits, and Membership Changes 2018
Product
mongodb bully: https://docs.mongodb.com/manual/core/replica-set-elections/
es bully: https://www.elastic.co/blog/found-leader-election-in-general
es pacificA:https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-replication.html
kafka pacificA: https://kafka.apache.org/documentation/#design_replicatedlog
k8s:https://kubernetes.io/blog/2016/01/simple-leader-election-with-kubernetes/
zk leader selection:https://zookeeper.apache.org/doc/r3.2.2/zookeeperInternals.html
etcd: https://etcd.io/docs/v3.5/learning/why/
Bookeeper https://zookeeper.apache.org/doc/r3.2.2/bookkeeperStarted.html
https://mesos.apache.org/documentation/latest/high-availability/
https://doc.akka.io/docs/akka/current/typed/cluster-concepts.html (Gossip+ Phi Accrual Failure Detector)
https://redis.io/topics/cluster-spec
https://redis.io/topics/sentinel
https://docs.datastax.com/en/cassandra-oss/3.x/cassandra/architecture/archTOC.html
https://docs.hazelcast.com/imdg/4.2/network-partitioning/partial-network-partitions
Book
Site
https://hazelcast.com/glossary/cap-theorem/
https://docs.hazelcast.com/imdg/4.2/consistency-and-replication/consistency
https://ai.googleblog.com/2017/04/consistent-hashing-with-bounded-loads.html
https://www.metabrew.com/article/libketama-consistent-hashing-algo-memcached-clients
https://doc.akka.io/docs/akka-enhancements/current/split-brain-resolver.html
103-后端存储实战课-李玥
107-分布式协议与算法实战 韩健
https://time.geekbang.org/column/intro/100046101
Keywords
BFT(Byzantine fault tolerance),CFT(Crash fault tolerance)
TCC/XA-DTP/2PC
All/Quorum/One/Any
Basic Paxos/Multi Paoxs(Chubby,Spanner)
Raft(Etcd,Consul,CockroachDB)
Raft(Leader Select/Log Replication/Membership change(Joint Consensus/Single-Server Changes))
logcabin(joint consensus)
Hashicorp Raft:Consul,IPFS,InfluxDB
https://www.consul.io/docs/architecture/consensus
区块链共识机制:POW、POA、POS、DPOS、PBFT、DBFT
ZAB:基于主备的原子广播协议-2007年
一致性算法时间顺序 Basic Paxos -> Multi Paoxs -> ZAB -> Raft
Raft+:配置中心,名字路由,KV存储
Notes
实现AP比CP复杂。
MuitiPaxos没有考虑顺序问题,只是对共识,而ZAB解决了顺序问题,后面Raft也考虑顺序。
Wiki
https://en.wikipedia.org/wiki/Eventual_consistency
https://en.wikipedia.org/wiki/Gossip_protocol
https://en.wikipedia.org/wiki/Byzantine_fault
https://en.wikipedia.org/wiki/Replication_(computing)
Person
Nancy Lynch https://people.csail.mit.edu/lynch/
Seth Gilbert https://www.comp.nus.edu.sg/~gilbert/
Eric Brewer https://people.eecs.berkeley.edu/~brewer/
Leslie Lamport http://www.lamport.org/
Werner Vogels https://www.allthingsdistributed.com/
Paper
The Byzantine Generals Problem
Brewer’s Conjecture and the Feasibility of Consistent, Available, Partition-Tolerant Web Services
Practical Byzantine Fault Tolerance:https://pmg.csail.mit.edu/papers/osdi99.pdf
Zab: High-performance broadcast for primary-backup systems
Product
https://www.influxdata.com/time-series-platform/telegraf/
Cassandra: Read Repair, Hinted Handoff
https://www.influxdata.com/blog/eventual-consistency-hhq/
https://docs.amazonaws.cn/en_us/amazondynamodb/latest/developerguide/Introduction.html
https://cassandra.apache.org/doc/latest/cassandra/architecture/dynamo.html#tunable-consistency
https://docs.influxdata.com/enterprise_influxdb/v1.9/concepts/clustering/
zilliqa: https://dev.zilliqa.com/docs/basics/basics-zil-consensus/
sawtooth: https://sawtooth.hyperledger.org/docs/pbft/nightly/master/using-pbft-consensus.html
https://zookeeper.apache.org/doc/current/zookeeperInternals.html#sc_consistency
influxdb:meta node:CP,raft data node:AP,hinted-handoff,quorum,anti-entropy,自定义副本
Book
Concurrency Control and Recovery in Database Systems
Site
https://www.allthingsdistributed.com/2008/12/eventually_consistent.html
https://www.influxdata.com/blog/multiple-data-center-replication-influxdb/
https://www.influxdata.com/blog/influxdb-clustering-design-neither-strictly-cp-or-ap/
https://github.com/influxdata/influxdb-comparisons
C: https://github.com/willemt/raft C++:https://github.com/logcabin/logcabin
https://github.com/hashicorp/raft-boltdb
162-分布式数据库30讲 王磊
https://time.geekbang.org/column/intro/100057401
238-大数据经典论文解读 徐文浩
https://time.geekbang.org/column/intro/100091101
笔记
Apache ORC (Optimized Row Columnar)
Paper
AI大模型之美-徐文浩
https://cookbook.openai.com/
GPT-3、Stable Diffusion,Whisper,ChatGPT
处理内容:文本、语音、视频、图像
分类、聚类、文本摘要、聊天机器人
https://github.com/xuwenhao/geektime-ai-course
https://colab.research.google.com/
AI 应用
工具
Midjourney,Dall-E 2
https://aituts.com/ai-generated-coloring-books/
https://poe.com/
彩云小译
https://chrome.google.com/webstore/detail/glarity-chatgpt-summary-t/cmnlolelipjlhfkhpohphpedmkfbobjc/related
scispace:
ChatPDF
GitHub Copilot
notion.ai
机器翻译、文本生成、知识推理、命名实体识别
一个模型来解决所有的自然语言处理问题
Complete 可以让模型根据你的输入进行自动续写,Embedding 可以将你输入的文本转化成向量。
两个简单的 API 来解决传统的自然语言处理问题。
朴素贝叶斯算法
特征工程:2-Gram(Bigram 双字节词组)和 3-Gram(Trigram 三字节词组)
大语言模型:20 行代码的情感分析解决方案
零样本分类(Zero-Shot Classification)。
temperature:随机性
text-davinci-003 模型,允许最多有 4096 个 token。这个数量既包括你输入的提示语,也包括 AI 产出的回答
API:https://platform.openai.com/docs/api-reference/completions
Few-Shots Learning(少样本学习)
文本变成向量:Word2Vec、Bert,open-api Embedding
GPT-3预训练模型(Pre-trained Model)。GPT 的英文“生成式预训练 Transformer(Generative Pre-trained Transformer)
Facebook 的 Fasttext,Google 的 T5,Text-to-Text Transfer Trasnformer:文本到文本的迁移 Transformer.GPT-3 的 1750 亿参数。
Fasttext、T5-small 和 T5-base 这三个预训练模型
情感分析分类器。好评和差评。
text-embedding-ada-002: Tiktoken+cl100k_base编码
模型评估:准确率,召回率 F1 Score = 2/ (1/Precision + 1/Recall)
Embedding+传统机器学习 LogisticRegression进行分类,而不是简单的向量相似性距离进行计算。
HuggingFace
ChatCompletion,gpt-3.5-turbo,role:assistant,user,system
HuggingFace+Gradio 的部署方式,特别方便我们演示给其他人看。
Gradio应用。
每次要把全部对话发给ChatGPT。
文本分类:embedding+k-means 然后 completion,可以产生有意义的分类。
利用文本摘要支持无限轮数的聊天。
使用提示语对文本进行总结。
Notion AI
同样含义的中文,目前消耗的 Token 数量是比英文多的。
模型:GPT-4 家族,GPT-3.5 家族,Ada、Babbage、Curie 以及 Davinci, text-embedding-ada-002、text-similarity-ada-001
维度: embedding-ada: 1536 similarity-ada: 1024 babbage-similarity: 2048 search-babbage-query: 2048 curie-similarity: 4096 davinci-similarity: 12288
text-davinci-003支持文本插入功能;帮助色情、暴力等内容进行审核过滤的moderate接口
文本改写应用
控制输出的内容参数:presence_penalty(存在惩罚),frequency_penalty(重复惩罚),temperature,logit_bias(精确控制内容)
通过 Embedding 进行语义搜索
利用 Embedding 信息进行商品推荐的冷启动
通过 FAISS 加速搜索过程:Facebook AI Similarity Search,高维向量的相似性搜索。
Faiss 的原理,是通过 ANN 这样的近似最近邻的算法,快速实现相似性的搜索。
Faiss数据量受限于内存大小。数据量进一步增长,需要选用一些向量数据库来进行搜索。OpenAI推荐Pinecone和Weaviate,也有国人的Milvus( https://milvus.io/docs )。
llama-index框架:https://www.llamaindex.ai/
Llama Index阅读一本书,自己数据和llm联系起来
ChatGPT plugins:https://openai.com/blog/chatgpt-plugins
Vector database
Chroma, an open-source embeddings store:https://docs.trychroma.com/ Elasticsearch, a popular search/analytics engine and vector database:https://www.elastic.co/guide/en/elasticsearch/reference/current/knn-search.html Milvus, a vector database built for scalable similarity search:https://milvus.io/docs/architecture_overview.md Pinecone, a fully managed vector database:https://docs.pinecone.io/docs/overview Qdrant, a vector search engine:https://qdrant.tech/documentation/ Redis as a vector database:https://redis.io/docs/interact/search-and-query/advanced-concepts/vectors/ Typesense, fast open source vector search Weaviate, an open-source vector search engine Zilliz, data infrastructure, powered by Milvus
A vector database is a type of database that indexes and stores vector embeddings for fast retrieval and similarity search
Semantic search:https://www.elastic.co/guide/en/elasticsearch/reference/current/semantic-search.html
Knn search:https://www.elastic.co/guide/en/elasticsearch/reference/current/knn-search.html
https://github.com/pgvector/pgvector
自己数据在大语言模型上实现两种方式:
- 找数据利用OpenAI提供的“微调”(Fine-tune)接口,在原来的基础上训练一个新模型出来:https://platform.openai.com/docs/guides/fine-tuning
- 先搜索,后提示(比如llama-index加载本地文件)
llama_index 对于文章进行小结:将文章进行拆分,llama-index最简单的索引结构:GPTListIndex
引入多模态,让 llamd-index 能够识别小票。
DataConnector:https://llamahub.ai/
llama-index是一种使用大语言模型的设计模式,为“第二大脑”模式。通过先将外部的资料库索引,然后每次提问的时候,先从资料库里通过搜索找到有相关性的材料,然后再通过 AI 的语义理解能力让 AI 基于搜索到的结果来回答问题。
Bing 的解法——先搜索,后提示。搜索到结果作为提示语给AI。
sentence-transformers 是目前效果最好的语义搜索类的模型。
ChatGLM:清华大学语言模型:https://github.com/THUDM/GLM-130B
单机的开源小模型:paraphrase-multilingual-mpnet-base-v2(128 token) 模型来计算 Embeddding 并进行语义搜索,然后通过 chatglm-6b-int4 的模型来进行问答的解决方案了。而且这两个模型,可以跑在一块家用级别的显卡上。
模型的推理能力。
ChatGPT让人震撼的原因效果还是要远远超出任何一个竞争对手和开源项目的。
ChatGPT现在极其擅长的是做一些不需要新知识更新的任务。比如生成贺词、生成Excel表格、生成经典代码等等。而对于需要新知识的任务,如对新的学术知识的查找, 总结,生成一份新机器的说明书,生成对当下新闻的报导,对新资讯的总结分析归类等等,ChatGPT就显得力不从心了,即使生成的文本看似流畅,但是内容却一定是错误的。
https://sharegpt.com/c/pGYAz2p
通过大语言模型写单元测试代码。
Unit test writing using a multi-step prompt (with the older API)
通过多个 Prompts 来完成单元测试
LangChain简化多步提示语
https://www.langchain.com/: Get your LLM application from prototype to production
Langchain 可以顺序地通过多个 Prompt 调用 OpenAI 的 GPT 模型.
大语言模型进行链式调用:LangChain 通过将多个 LLMChain 组合成一个 SequantialChain 并顺序执行,大大简化了这类任务的开发工作。
Stable Diffusion 是文本到图像的模型: https://zh.wikipedia.org/zh-cn/Stable_Diffusion
Wolfram
LLMChain 是一个很强大的武器,它可以把解决一个问题需要的多个步骤串联到一起。
LLMChain增强了 AI 的实用性,解决了几个之前大语言模型处理得不好的问题,包括数学计算能力、实时数据能力、和现有程序结合的能力,以及搜索属于自己的资料库 的能力。你完全可以定义自己需要的 LLMChain,通过程序来完成各种任务,然后合理地组合不同类型的 LLMChain 对象,来实现连 ChatGPT 都做不到的事情。
Langchain:BufferWindowMemory,SummaryMemory,BufferSummaryMemory,EntityMemory,KnowledgeGraphMemory
LangChain:BufferWindow,滑动窗口记忆
ConversationSummaryBufferMemory
命名实体识别的算法:nlu实现,NER算法
langchain rag模式(检索增强生成(Retrieval Augmented Generation, RAG)) rerank模式 rewrite模式。
rerank:rag:https://luxiangdong.com/2023/11/06/rerank/ 重排序
rewrite:rag:https://docs.dify.ai/v/zh-hans/learn-more/extended-reading/retrieval-augment/rerank
Prompt Engineering Guide:https://www.promptingguide.ai/
Retrieval-Augmented Generation Pipeline:大模型训练Pipeline
langchain agent:https://python.langchain.com/docs/modules/agents/ agent帮忙插订单号。
把回答不同类型问题的 LLMChain 封装成不同的 Tool,也可以直接让 Tool 去调用内部查询订单状态的功能。
电商客服功能的聊天机器人。
langchain:Agent、Memory、VectorStore、LLMChain
OpenAI 提供的模型微调(Fine-tune)
这个模型“微调”完成之后,就可以直接向模型提问了。而不用再像之前使用 llama-index 或者 LangChain 那样, 先通过 Embedding 来查询相关资料,然后把查找到的资料也一并提交给 OpenAI 来获得所需要的答案。
模型微调的成本考量:Ada、Babbage、Curie 和 Davinci https://openai.com/pricing#language-models
流式生成:Completion接口stream=True
语音识别模型 Whisper的方法transcribe,语音转文字:https://platform.openai.com/docs/guides/speech-to-text
能够在音频内容的转录之前提供一段 Prompt,来引导模型更好地做语音识别,是Whisper模型的一大亮点。
音频分割:PyDub
Whisper:https://openai.com/research/whisper
语音合成(Text-To-Speech)
SSML 是 Speech Synthesis Markup Language,语音合成标记语言
语音合成:百度开源的 PaddleSpeech https://github.com/PaddlePaddle/PaddleSpeech/blob/develop/demos/text_to_speech/README_cn.md
Azure AI 服务:https://azure.microsoft.com/zh-cn/products/ai-services
“数字人”
文本聊天机器人->语音输入->语音合成与播放
用 D-ID 给语音对口型
gradio
ChatGPT用ChatGLM来代替,语音识别我们可以使用本地的Whisper模型,语音合成也可以通过PaddleSpeech里的fastspeech2的开源模型来完成。D-ID可以通过开源模型PaddleBobo来合成这样的口播视频。
Diffuser 类型,GAN 生成影像
Huggingface 的火爆离不开Transformers库
小尺寸的 T5-base 和裁剪过的ChatGLM-6B-INT4,而不是FLAN-UL2或者ChatGLM-130B这样真正的大模型
Transformers Pipeline:https://huggingface.co/docs/transformers/main_classes/pipelines
Pipeline 是 Transformers 库里面的一个核心功能,它封装了所有托管在 HuggingFace 上的模型推理预测的入口。
https://huggingface.co/models
ChatGPT 的强大之处?上面这些自然语言处理任务,常常需要切换使用不同的专有模型。但是在 ChatGPT 里,只需要一个通用的模型,就能直接解决所有的问题。这也是很多人惊呼“通用人工智能”来了的原因。
HuggingFace:Inference API
如何部署自己的大模型? HuggingFace Inference Endpoint
HuggingFace 将部署一个开源模型到线上的成本基本降低到了 0。不过,目前它只支持海外的 AWS、Azure 以及 Google Cloud,并不支持阿里云或者腾讯云
So-Vits-SVC 算法实现的 AI 孙燕姿
AutoGPT 和 BabyAGI 这样的自主智能体(Autonomous Agent)
DoNotPay:AI 律师
Meta 开源:LLaMA
OpenAI:三维建模的生成式模型 Shap-E
AI应用网站:https://www.futurepedia.io/
深度学习:PyTorch/Tensorflow/Paddle/Mxnet
NLP课程:https://huggingface.co/learn/nlp-course/zh-CN/chapter1/1
Retrieval-Augmented Generation for Large Language Models: A Survey:https://arxiv.org/pdf/2312.10997.pdf
2017年Transformer架构:Attention Is All You Need https://arxiv.org/pdf/1706.03762.pdf
BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding:https://arxiv.org/pdf/1810.04805.pdf
深度学习百科及面试资源:https://paddlepedia.readthedocs.io/en/latest/index.html
腾讯云混元大模型:https://cloud.tencent.com/document/product/1729
OpenClip:多模态的 CLIP 模型,零样本分类
OpenAI开源的CLIP模型:Contrastive Language-Image Pre-Training 对比性语言-图像预训练
CLIP 这样的模型出现之前,图像识别是一个准确率非常高的领域了。通过 RESNET 架构的卷积神经网络,在 ImageNet 这样的大数据集上,已经能够做到 90% 以上的准确率了。 但是这些模型都有一个缺陷是基于监督学习的方式来进行分类的。这意味着两点,一个是所有的分类需要预先定义好,比如 ImageNet 就是预先定义好了 1000 个分类。 另一个是数据必须标注,训练模型前要给训练的图片标注好属于什么类。
softmax 算法
Google基于CLIP开发了OWL-ViT
通过关键词搜索商品图片的功能。也可以实现以图搜图。
Text-To-Image:OpenAI的DALL-E 和 DALL-E 2,Google发表了 Imagen,最好的用户端产品是 Midjourney。最流行的产品则是 Stable Diffusion。
Huggingface 的 Diffusers 库,通过 DiffusionPipeline 加载了 RunwayML 的 stable-diffusion-v1-5。
Stable Diffusion 背后不是单独的一个模型,而是由多个模型:1 Text-Encoder(CLIP 模型) 2 Generation(UNet+Scheduler) 3 Decoder(VAE模型)
Stable Diffusion 实现图生图。
VAE:https://huggingface.co/stabilityai/stable-diffusion-x4-upscaler/blob/main/vae/config.json
UNet:https://huggingface.co/stabilityai/stable-diffusion-x4-upscaler/blob/main/unet/config.json
Stable Diffusion:文生图、图生图、提升图片分辨率
Stable Diffusion 模型的平台:https://civitai.com/
ControlNet:对图片进行调整。通过图片的框架结构可以精确地控制图片的输出。这里就是通过边缘检测,控制了整个人物头像的姿势和大致轮廓。【换脸-不同名人展示的“蒙娜丽莎的微笑”】
AI拍动画片也成为了可能。只需要通过Open Pose将原本真人动作里每一帧的人体姿势都提取出来,然后通过 Stable Diffusion 为每一帧重新绘制图片, 最后把绘制出来的图片再重新一帧帧地组合起来变成动画就好了。
ControlNet 支持的8个模型:https://github.com/lllyasviel/ControlNet
Canny边缘检测算法
controlnet-canny:边缘检测 Open Pose:捕捉动作复刻图片 Scribble:简笔画生成图片 HED Boundary:边缘检测 Depth:深度估计 Normal Map:法线贴图 Semantic Segmentation:语义分割图 M-LSD:获取图片中的直线段
微软开源的 Visual ChatGPT:边聊边画 https://github.com/moymix/TaskMatrix 聊天窗口完成图片的编辑和修改。原理:LangChain 的 ReAct Agent 模式。Task Matrix 机制机制。
Midjourney都是一个值得研究的AI产品。
ShareGPT、FlowGPT
用户在内容生成的过程中就获取到反馈,是现在很多 AI 应用一个比较常见的产品设计策略。
数据飞轮:好的产品 -> 更多的用户数据 -> 更好的模型质量 -> 更好的产品就进入了一个正向循环
Redis核心技术与实战-蒋德钧
深入剖析Kubernetes-张磊
许式伟的架构课-许式伟
参考资料
Akka
优先看:https://academy.lightbend.com/
其次:classic: https://doc.akka.io/docs/akka/current/index-classic.html
typed:https://doc.akka.io/docs/akka/current/
API文档:https://doc.akka.io/api/ JAPI:https://doc.akka.io/japi/akka/2.6/akka/actor/AbstractActor.html
AKKA中文指南:https://www.bookstack.cn/read/guobinhit-akka-guide/711c3ba85a66f758.md
http://jasonqu.github.io/akka-doc-cn/2.3.6/scala/book/index.html
快速开始demo:https://developer.lightbend.com/start/?group=akka
代码示例:https://github.com/akka/akka-samples
https://github.com/typesafehub/activator-akka-java-spring https://github.com/lightbend
Akka 响应式架构 https://book.douban.com/subject/26829063/
Akka实战:Akka实战:快速构建高可用分布式应用 https://book.douban.com/subject/30218333/
Akka入门与实践 https://book.douban.com/subject/27055163/
Akka实战 https://book.douban.com/subject/30431012/
TTT:【技术分享】Akka入门与精品课教务系统分布式实战 http://training.corp.youdao.com/play.php?id=139
官方文档 https://doc.akka.io/docs/akka/current/typed/guide/index.html
akka生态:https://akka.io/docs/
https://developer.lightbend.com/docs/akka-platform-guide/index.html
使用akka开发微服务:https://developer.lightbend.com/docs/akka-platform-guide/microservices-tutorial/index.html
lightbend academy: https://academy.lightbend.com/courses
EBOOK: https://www.lightbend.com/akka-platform/resources
Consul
官方文档 https://www.consul.io/docs
生态:https://www.hashicorp.com/
Hazelcast
优先看:https://training.hazelcast.com/
Hazelcast文档:https://docs.hazelcast.com/hazelcast/5.1/
IMDG文档: https://docs.hazelcast.com/imdg/latest/getting-started.html
hazelcast mc文档:https://docs.hazelcast.com/management-center/latest/getting-started/overview
代码示例:https://github.com/hazelcast/hazelcast-code-samples
https://github.com/hazelcast/hazelcast/wiki
Quick Start:https://hazelcast.org/imdg/?samplelang=Java+Member&sampleindex=0
Mastering Hazelcast:https://hazelcast.com/resources/mastering-hazelcast/
Jackson
https://github.com/FasterXML/jackson-docs
https://github.com/FasterXML/jackson
https://github.com/FasterXML
ElasticSearch
优先看oreilly出版的《ElasticSearch权威指南》
中文版:https://www.elastic.co/guide/cn/elasticsearch/guide/current/index.html(中文有些esquery写的不对,需要辅助英文的看)
英文版:https://www.elastic.co/guide/en/elasticsearch/guide/master/index.html
https://www.elastic.co/guide/index.html
ElasticSearch Elasticsearch源码解析与优化实战 https://book.douban.com/subject/30386800/
Elasticsearch实战 https://book.douban.com/subject/30380439/
深入理解ElasticSearch https://book.douban.com/subject/27066928/
官方文档 https://www.elastic.co/guide/en/elasticsearch/reference/current/docs.html
极客时间 62.极客时间-Elasticsearch核心技术与实战
模型:https://dbdb.io/db/elasticsearch
Elasticsearch:权威指南 : https://www.elastic.co/guide/cn/elasticsearch/guide/2.x/index.html
Elasticsearch: The Definitive Guide: A distributed real-time search and analytics engine
IR:https://nlp.stanford.edu/IR-book/information-retrieval-book.html
Kafka
优先看:https://developer.confluent.io/ course:https://developer.confluent.io/learn-kafka/ 其次:https://kafka.apache.org/ 以及 https://cwiki.apache.org/confluence/display/KAFKA/Index
API:https://kafka.apache.org/30/javadoc/index.html
https://kafka.apache.org/30/javadoc/org/apache/kafka/clients/producer/KafkaProducer.html
https://kafka.apache.org/30/javadoc/org/apache/kafka/clients/consumer/KafkaConsumer.html
Kafka 深入理解Kakfa核心设计与实践原理 https://book.douban.com/subject/30437872/
Apache Kafka源码剖析 https://book.douban.com/subject/27038473/
Apache Kafka实战 https://book.douban.com/subject/30221096/
Kafka权威指南 https://book.douban.com/subject/27665114/
Kafka Streams实战 https://book.douban.com/subject/33425155/
官方文档 https://kafka.apache.org/documentation/#gettingStarted
https://jaceklaskowski.gitbooks.io/mastering-kafka-streams/content/
Canal
Canal 官方文档 https://github.com/alibaba/canal
Gradle
Gradle Gradle实战 https://book.douban.com/subject/26609447/ 官方文档 https://docs.gradle.org/current/userguide/userguide.html
MapDB
官方文档:https://mapdb.org/
https://dbdb.io/db/mapdb
mapdb作者youtube:https://www.youtube.com/user/jankotek
Seata
深入理解分布式事务 冰河
正本清源分布式事务之Seata
Cassandra
Datastax文档,Cassandra OSS:https://docs.datastax.com/en/landing_page/doc/landing_page/docList.html
OSS Cassandra:https://docs.datastax.com/en/pdf/osscassandra3x.pdf
OSS CQL:https://docs.datastax.com/en/pdf/osscql3x.pdf
Apache:https://cassandra.apache.org/doc/latest/
Apache:https://cwiki.apache.org/confluence/display/CASSANDRA2/
Github Repository
https://github.com/xiaozhiliaoo/akka/tree/akka-practice
https://github.com/xiaozhiliaoo/elasticsearch/tree/es-practice
https://github.com/xiaozhiliaoo/kafka/tree/kafka-practice
https://github.com/xiaozhiliaoo/hazelcast/tree/hazelcast-practice
参考资料
Akka
优先看:https://academy.lightbend.com/
其次:classic: https://doc.akka.io/docs/akka/current/index-classic.html
typed:https://doc.akka.io/docs/akka/current/
API文档:https://doc.akka.io/api/ JAPI:https://doc.akka.io/japi/akka/2.6/akka/actor/AbstractActor.html
AKKA中文指南:https://www.bookstack.cn/read/guobinhit-akka-guide/711c3ba85a66f758.md
http://jasonqu.github.io/akka-doc-cn/2.3.6/scala/book/index.html
快速开始demo:https://developer.lightbend.com/start/?group=akka
代码示例:https://github.com/akka/akka-samples
https://github.com/typesafehub/activator-akka-java-spring https://github.com/lightbend
Akka 响应式架构 https://book.douban.com/subject/26829063/
Akka实战:Akka实战:快速构建高可用分布式应用 https://book.douban.com/subject/30218333/
Akka入门与实践 https://book.douban.com/subject/27055163/
Akka实战 https://book.douban.com/subject/30431012/
TTT:【技术分享】Akka入门与精品课教务系统分布式实战 http://training.corp.youdao.com/play.php?id=139
官方文档 https://doc.akka.io/docs/akka/current/typed/guide/index.html
akka生态:https://akka.io/docs/
https://developer.lightbend.com/docs/akka-platform-guide/index.html
使用akka开发微服务:https://developer.lightbend.com/docs/akka-platform-guide/microservices-tutorial/index.html
lightbend academy: https://academy.lightbend.com/courses
EBOOK: https://www.lightbend.com/akka-platform/resources
Consul
官方文档 https://www.consul.io/docs
生态:https://www.hashicorp.com/
Hazelcast
优先看:https://training.hazelcast.com/
Hazelcast文档:https://docs.hazelcast.com/hazelcast/5.1/
IMDG文档: https://docs.hazelcast.com/imdg/latest/getting-started.html
hazelcast mc文档:https://docs.hazelcast.com/management-center/latest/getting-started/overview
代码示例:https://github.com/hazelcast/hazelcast-code-samples
https://github.com/hazelcast/hazelcast/wiki
Quick Start:https://hazelcast.org/imdg/?samplelang=Java+Member&sampleindex=0
Mastering Hazelcast:https://hazelcast.com/resources/mastering-hazelcast/
Jackson
https://github.com/FasterXML/jackson-docs
https://github.com/FasterXML/jackson
https://github.com/FasterXML
ElasticSearch
优先看oreilly出版的《ElasticSearch权威指南》
中文版:https://www.elastic.co/guide/cn/elasticsearch/guide/current/index.html(中文有些esquery写的不对,需要辅助英文的看)
英文版:https://www.elastic.co/guide/en/elasticsearch/guide/master/index.html
https://www.elastic.co/guide/index.html
ElasticSearch Elasticsearch源码解析与优化实战 https://book.douban.com/subject/30386800/
Elasticsearch实战 https://book.douban.com/subject/30380439/
深入理解ElasticSearch https://book.douban.com/subject/27066928/
官方文档 https://www.elastic.co/guide/en/elasticsearch/reference/current/docs.html
极客时间 62.极客时间-Elasticsearch核心技术与实战
模型:https://dbdb.io/db/elasticsearch
Elasticsearch:权威指南 : https://www.elastic.co/guide/cn/elasticsearch/guide/2.x/index.html
Elasticsearch: The Definitive Guide: A distributed real-time search and analytics engine
IR:https://nlp.stanford.edu/IR-book/information-retrieval-book.html
Kafka
优先看:https://developer.confluent.io/ course:https://developer.confluent.io/learn-kafka/ 其次:https://kafka.apache.org/ 以及 https://cwiki.apache.org/confluence/display/KAFKA/Index
API:https://kafka.apache.org/30/javadoc/index.html
https://kafka.apache.org/30/javadoc/org/apache/kafka/clients/producer/KafkaProducer.html
https://kafka.apache.org/30/javadoc/org/apache/kafka/clients/consumer/KafkaConsumer.html
Kafka 深入理解Kakfa核心设计与实践原理 https://book.douban.com/subject/30437872/
Apache Kafka源码剖析 https://book.douban.com/subject/27038473/
Apache Kafka实战 https://book.douban.com/subject/30221096/
Kafka权威指南 https://book.douban.com/subject/27665114/
Kafka Streams实战 https://book.douban.com/subject/33425155/
官方文档 https://kafka.apache.org/documentation/#gettingStarted
https://jaceklaskowski.gitbooks.io/mastering-kafka-streams/content/
Canal
Canal 官方文档 https://github.com/alibaba/canal
Gradle
Gradle Gradle实战 https://book.douban.com/subject/26609447/ 官方文档 https://docs.gradle.org/current/userguide/userguide.html
MapDB
官方文档:https://mapdb.org/
https://dbdb.io/db/mapdb
mapdb作者youtube:https://www.youtube.com/user/jankotek
Seata
深入理解分布式事务 冰河
正本清源分布式事务之Seata
Cassandra
Datastax文档,Cassandra OSS:https://docs.datastax.com/en/landing_page/doc/landing_page/docList.html
OSS Cassandra:https://docs.datastax.com/en/pdf/osscassandra3x.pdf
OSS CQL:https://docs.datastax.com/en/pdf/osscql3x.pdf
Apache:https://cassandra.apache.org/doc/latest/
Apache:https://cwiki.apache.org/confluence/display/CASSANDRA2/
Github Repository
https://github.com/xiaozhiliaoo/akka/tree/akka-practice
https://github.com/xiaozhiliaoo/elasticsearch/tree/es-practice
https://github.com/xiaozhiliaoo/kafka/tree/kafka-practice
https://github.com/xiaozhiliaoo/hazelcast/tree/hazelcast-practice
技术面试
算语,中框,容系,架计
算法
算法
Java
Java集合,并发,反射,jvm
中间件
6个核心中间件
框架
rpc,ssm
容器
k8s,docker
架构
微服务,云元生,分布式架构
系统
Linux
计算机基础
分布式系统,操作系统,网络
Algorithm
Java
Golang
Spring
Spring-Cloud
MyBatis
RPC
dubbo
thrift
grpc
MySQL
SQL
优化SQL:where,range,order,group by,or,limit
系统
一条SQL Insert时候,发生了什么?
一条SQL Select时候,发生了什么?
存储引擎
慢SQL优化
必然问题,偶现问题
慢的根本原因在于:磁盘(寻址和旋转延时)+网络(数据包大小)
查询,分组,排序。
实践:减少磁盘+建立索引。
Kafka
kafka里consumer group如果其中一个consumer一直没有消费成功,其他consumer也会卡住吗,consumer offset也就会一直停止不前?
消息顺序性,幂等性,可靠性,高可用,事务,消息挤压
Redis
redis分布式锁的实现?以及遇到问题
ElasticSearch
集群内的原理
分布式文档存储
执行分布式检索
分片内部原理
结构化搜索
Zookeeper
Flink
Kubernetes
Docker
架构-架构设计
Linux
系统-模式
操作系统
网络
分布式系统
技术札记
技术札记,类似于顾炎武的日知录,随感记录一些技术感悟,技术名言,软件开发,想法等零碎的东西汇总成册,内容非严格意义的科学知识点,甚至可能有错误。
第一章
-
1 面向过程:程序 = 数据结构+算法
面向对象:程序 = 对象+消息
面向模式:程序 = 模式+ 反模式
面向业务:程序 = 重构 + 粘贴复制(业务数据+业务逻辑)
业务=数据+逻辑
系统设计=服务+数据存储
-
面向all:程序 = 数据 + 逻辑
- 2 架构 = 组件 + 组件间的关系
- 3 martin flower:架构是项目组员对软件的共同的理解。什么是系统关键?什么是代码库重要的东西?什么是工作中经常记住的东西?
- 4 martin flower: important stuff = shared understanding + hard to change
- 5 martin flower:我们做好工作通常基于道德上的原因,但是手艺人和经济人之间的战争,经济总会获胜。质量和成本间的折0中。
- 6 martin flower:软件质量 = 内部质量 + 外部质量。 内部质量通常理解为好的模块设计,外部设计是好的用户体验。
- 7 martin flower: 如果我们不在软件内在质量付诸努力,最终我们就是欺骗客户,我们在放慢客户竞争的能力。
- 8 martin flower:好的设计和坏的设计会有一个临界点。前期坏的设计累加功能快,而后期好的设计的市场价值才会显现出来。
- 9 martin flower: 持续集成,持续交付,快速响应变化。新时代软件信条。
- 10 GOF23设计模式口诀: 两个慈母在阿里云上看电视,唱着abcdffp,结果ab型号的电视fps变快了。
行为:CCIIMMOSSTV 结构:ABCDFFP 创建:ABFPS
- 11 抱怨CRUD和IF-ELSE没技术含量是因为掌握的模式太少,这和初级还是高级开发并没有必然联系。
-
12 招式:Java,SSH,Eclipse,JSP,ASP,.Net等框架技术。
内功:数据结构,算法,重构,软件工程,设计模式等。
- 13 重构:在不改变软件可观察行为前提下改善其内部结构。
- 14 重构是在代码写好后改进它的设计。设计-》编码-》设计-》编码......
- 15 什么是技术沉淀?沉淀知识?沉淀经验?沉淀工龄?看xx源码?看底层原理?都不是,沉淀的是方法论和软件观。但是前提是看xx源码,看xx原理。
- 16 算法:空间和时间的平衡艺术。算法代价的数学表述:常数-一次-二次-指数-幂数。 GC算法也是如此。
- 17 Java,JS书籍对比。《Java编程思想》-《JS权威指南》 《Efftive Java》-《JS语言精粹》 《Java核心技术》-《Js高级程序设计》
- 18 业务代码:时间和质量呈现不相关关系。写“坏味道”代码依旧“坏味道”,写“优雅代码”依旧“优雅”。时间短就写不出好代码是多么的愚蠢逻辑!
- 19 技术再深,无非就是源码,但是源码的背后是什么?
- 20 面向对象四大特征:封装,继承,多态,抽象。而继承和封装是矛盾的,所以才有了委派[delegate]。
- 21 做不到共享的CodeReview不是好的CodeReview。
- 22 孙玄:一切抛开业务的架构设计都是耍流氓 。
- 23 架构选择:All in One 还是 One in One[SOA,MicroService, distributed],对于创业初期,All in One更加普遍。
- 24 阅读源码:一次精神洗礼之旅。
- 25 技术和业务影响团队的组织结构。
- 26 设计模式:总是将变化的事物和不变的事物分离开。
- 27 设计模式: 可复用面向对象软件的基础。
- 28 编程的一种方法论:Talk is cheap,Show me the code。
- 29 《人件》更像本管理指南,而不是本管理书。
- 30 康威定律:设计系统的组织,最终会将其沟通结构复制到产品的设计中。
- 31 没有银弹也是银弹。
- 32 写代码如同写诗,灵感来源于大量的积累。
- 33 必须将技术提升和学习作为日常生活之战略。如同吃饭喝水一样平常。
- 34 十个字以内描述GOF模式:
- A抽象工厂:产品族的创建。
- B构建者:复杂对象创建与组装
- F工厂方法:多态工厂
- P原型:对象克隆
- S单例:确保对象唯一性
- 简单工厂:集中工厂 [静态工厂]
- A适配器:不兼容结构协调
- B桥接:处理多维变化
- C组合:树形结构处理
- D装饰:扩展系统功能
- F外观:提供统一入口
- F享元:实现对象复用
- P代理:对象间接访问
- C职责链:请求链式处理
- C命令:请求发送者和接受者解耦
- I解释器:自定义语言
- I迭代器:遍历聚合对象元素
- M中介者:协调多对象交互
- M备忘录:撤销功能的实现
- O观察者:对象联动
- S状态:对象状态转换
- S策略:算法封装与切换
- T模板方法:定义算法框架
- V访问者:操作复杂对象结构
- 35 软件变化是必然的,有变化就要维护,随着时间的推移,维护成本远远大于初期的开发成本,因此,在软件开发中,最重要的是降低维护成本,维护成本正比于系统复杂度,所以降低维护成本,系统设计就要追求简单清晰。
- 36 软件质量取决于:机器质量+想法质量+代码质量+沟通质量
- 37 程序是什么?对于程序员是机器指令,对于用户是用户指令。
- 38 某种程度上技术的瓶颈可能取决于业务的瓶颈。
- 39 软件的目的是帮助他人。
- 40 软件设计方程式:D = Vn+Vf / Ei + Em
D:变化可行性 Vn:当前价值 Vf:未来价值 Ei:开发成本 Em:维护成本 随着时间推移方程转化为:D = Vf / Em 结论:相比于降低开发成本,降低维护成本更重要。
- 41 变化定律:程序存在时间越长,他的某个部分变化可能性越大。
- 42 缺陷定律:程序中新增缺陷可能性与代码修改量成正比
- 43 简洁定律:软件某部分的维护难度,反比于该部分的简洁程度。
- 44 测试定律:你对软件行为了解程序,等于你真正测试他的程度。
- 45 相比降低开发成本,降低维护成本更重要。而维护成本正比于系统复杂性。
- 46 Rod Johnson :市面J2EE作品过分强调各种J2EE规范,而忽视规范所解决现实问题。
- 47 “多瘤程序员”:已经掌握一项技术的实际使用技巧但同时留下了许多疤痕。
- 48 Rod Johnson:设计一次,在任何地方重新实现几个接口。而不是设计一次到处运行。
- 49 Rod Johnson谈优质代码。
- 50 OO设计比任何一项特定的实现技术(比如J2EE,Java)都重要。好的编程习惯和健全的OO设计使得J2EE应用具有坚实基础。劣质的Java代码就是劣质的J2EE代码。
- 51 OO原理加强J2EE开发。
- 52 许多开发花太多时间应付API,却花太少时间坚持好的编程习惯。
- 53 J2EE必读书目:《poeaa》,《expert one-to-one J2EE Design and Development》,《core J2EE patterns》,《expert one-to-one J2EE development without ejb》
- 54 技术提升两条路:1 广 2 深 在某个时间点他们会汇合起来。深会追求广,广会反哺深。
- 55 对知识(包括编程)产生崇敬感:先让其知道学问之大,进而产生渺小感,遂而从渺小感生出崇敬感。培养人才要从此入手。 今夫天,斯昭昭之多,及其无穷也,日月星辰系焉,万物覆焉。今夫地,一撮土之多。及其广厚,载华岳而不重,振河海而不泄,万物载焉。
- 56 异常的定义:我对此感到意外。
- 57 代码量的定义:1 不重复代码。 2 上线的代码。
- 58 好的程序设计语言能够帮助程序员写出好的程序,但是无论哪种语言,都阻止不了程序员用它写出坏程序。
- 59 无限接近自己所在领域的大师境界。
- 60 毕业五年内看完Spring源码和Netty源码。
- 61 重要的不是你学到什么,而是感受到什么。没有感受是白痴,感受比别人强是下道,感觉比自己强是中道,感觉和大师相通是大道。很多人止于超越自我。而兴趣或许可以加速这一切发生。
- 62 一定要有专门时间段学习软件业大师的非技术书。 比如温伯格, Kent Beck,Frederic Brooks(人月神话)
- 63 行业对比:投资框架和编程框架。
- 64 Cache和Pool都是资源管理方式,区别在于有无资源标识符。因为有了标识符,缓存持久化才有了意义。
- 65 类间关系:关联,依赖,泛化(继承),实现。
- 66 源码UML类图口诀:一进二出三关联 四多五少六抽象。
- 67 Java数组的协变的,无通配符的泛型是非协变的,有通配符的泛型是协变的。
- 68 你的水平就是团队的水平,提升团队水平先提升自我。
- 69 每天几条effective java,就是力量。
- 70 POSA:
- 71 POSA2:Patterns for Concurrent and Nerwork Objects
服务访问和配置模式: 包装器外观[Wrapper Facade],组件配置器[Component Configurator],拦截器[Interceptor],扩展接口[Extension Interface]
事件处理模式: 反应器[Reactor],主动器[Proactor],异步完成标记[Asynchronous Completion Token],接受器-连接器[Acceptor-Connector]
同步模式: 定界加锁[Scoped Locking],策略加锁[Strategized Locking],线程安全接口[Thread-Safe Interface],双重加锁优化[Double-Checked Locking Optimization]
并发模式: 主动对象[Active Object],监视器对象[Monitor Object],半同步半异步[Half-Sync/Half-Async],领导者追随者[Leader/Flowers],线程特定存储[Thread-Specific Storage]
- 72 POSA3: Patterns for Resource Management
资源获取: 查找模式[Lookup],延迟获取[Lazy Acquisition],预先获取[Eager Acquisition],部分获取[Partial Acquisition ]
**资源生命周期:**缓存 [Caching],池[Pooling],协调者[Coordinator],资源生命周期管理器[Resource Lifecycle Manage]
资源释放: 租约 [Leasing],驱逐者[Evitor]
- 73 POSA4:A Pattern Language for Distributed Computing 114个模式
从混沌到结构: Domain Model[领域模式] ,Layer[分层], Model-View-Controller[模式-视图-控制器],Presentation-Abstraction-Controller[表现-抽象-控制],Microkernel[微内核],Reflection[反射],Pipes And Filters[管道和过滤器],Shared Respository[共享仓库],Blackboard[黑板报],Domain Object[领域对象]
分布式基础设施: Messaging[消息传递] 【 Message Channel[信道],Message Endpoint[消息端点],Message Translator[消息转换器],Message Router[消息路由] 】 ,Pub-Sub[发布者-订阅者],Broker[经纪人],【Client Proxy[客户端代码],Requestor[请求者],Invoker[调用者],Client Request Handler[客户端请求处理],Server Request Handler[服务端请求处理]】
事件分离和分发: Reactor[反应器],Proactor[前摄器],Acceptor-Connector[接受器-连接器],Asynchronous Completion Token[异步完成令牌]
接口划分: Explicit Interface[显示接口],Extension Interface[扩展接口],Introspective Interface[内省接口],Dynamic Invocation Interface[动态调用接口],Proxy[代理],Bussiness Delegate[业务委派],Facade [外观],Combined Method[组合方法], Iterator [迭代器],Enumeration Method[枚举方法],Batch Method[批处理方法]
组件划分: Encapsulated Implementation[封装实现],Whole-Part[整体-部分],Composite[组合],Master-Slave[主-从],Half-Object plus Protocol[半对象加协议],Replicated Component Group[复制组件组]
应用控制: Page Controller[页面控制器],Front Controller [前端控制器],Application Controller [应用控制器],Command Processor[命令处理程序],Template View[模板视图],Transform View[转换视图], Firewall Proxy[防火墙代理],Authrization[授权]
并发: Half-Sync/Half-Async[半同步-半异步],Leader-Followers[领导者-追随者],Active Object[活动对象],Monitor Object[监控对象]
同步: Grarded Suspension[守护挂起],Future[未来/期货],Thread-Safe Interface[线程安全接口],Double-Checked Locking[双重锁检测],Stategized Locking[策略锁],Scoped Locking[区域锁],Thread-Special Storage[线程专属存储],Copied Value[副本值],Immutable Value[不变模式]
对象间交互: Observer[观察者],Double Dispatch[双分派],Mediator[中介者],Command[命令],Memonto[备忘录],Context Object[上下文对象],Data Transfer Object[数据传输对象],Message[消息]
适配和扩展: Bridge[桥接],Object Adapter[对象适配],Chain of Responsibility[职责链],Interpreter[解释器],Interceptor[拦截器],Visitor[访问者],Decorator[装饰者],Execute-Around Object[环绕执行对象],Template Method[模板方法],Strategy[策略],Null Object[空对象],Wrapper Facade[包装外观],Declarative Component Configuration[声明组件配置]
模态行为: Objects for States[状态对象],Method for States[状态方法],Collections for States[状态集合]
资源管理: Container[容器],Component Configurator[组件配置],Object Manager[对象管理器],Lookup[查找],Virtual Proxy[虚代理],Lifecycle CallBack[生命周期回调],Task Coordinator[任务协调者],Resourse Pool[资源池],Resourse Cache[资源缓存], Lazy Acquisition [延迟获取/懒加载],Eager Acquisition[提前获取],Partial Acqusition[局部获取],Activator[激励器],Evictor[驱逐器],Leasing[租借],Automated Garbage[自动回收],Counting Handles[计数句柄],Abstract Factory[抽象工厂],Builder[构建者],Factory Method[工厂方法],Disposal Method[销毁方法]
数据库访问: Database Access Layer[数据库访问层],Data Mapper[数据映射器],Row Data Gateway[行数据网关],Table Data Gateway[表数据网关],Active Record[活动记录]
- 74 如果不为业务,不为功利,不为职业,什么都不为,你要学的东西是什么?学的技术是什么?别着急给答案,仔细思考。
- 75 Poeaa:
领域逻辑模式: Transaction Script[事务脚本],Domain Model[领域模式],Table Moudle[表模块],Service Layer[服务层]
数据源架构模式: Table Data GateWay[表数据入口],Row Data GateWay[行数据入口],Active Record[活动记录],Data Mapper[数据映射器]
对象-关系行为模式: Unit of Work[工作单元],Identity Map[标识映射],Lazy Load[延迟加载]
对象-关系结构模式: Indentity Field[标识域],Foreign Key Mapping[外键映射],Association Table Mapping[关联表映射],Dependent Mapping[依赖映射],Embedded Value[嵌入值],Serialized LOB[序列化LOB],Single Table Inheritance[单表继承],Class Table Inheritance[类表继承],Concrete Table Inheritance[具体表继承],Inheritance Mappers[继承映射器]
对象-关系元数据映射模式: Metadata Mapping[元数据映射],Query Object[查询对象],Repository[资源],
Web表现层模式: Model-View-Controller[模型-视图-控制器],Page Controller[页面控制器],Front Controller[前端控制器],Template View[模板视图],Transform View[转换视图],Two-Step View[两步视图],Application Controller[应用控制器]
分布模式: Remote Facade[远程外观],Data Transfer Object[数据传输对象]
离线并发模式: Optimistic Offline Lock[乐观离线锁],Pessimistic Offline Lock[悲观离线锁],Coarse Grained Lock[粗粒度锁],Implicit Lock[隐含锁]
会话状态模式: Client Session State[客户端会话状态],Server Session State[服务器会话状态],Database Session State[数据库会话状态]
基本模式: GateWay[入口],Mapper[映射器],Layer Supertype[层超类型],Separated Interface[分离接口],Registry[注册表],Value Object[值对象],Money[货币],Special Case[特殊情况],Plugin[插件],Service Stub[服务桩],Record Set[记录集]
- 76 Core J2EE Patterns:
表现层: Intercepting Filter [拦截过滤器],Context Object [上下文对象],Front Controller[前端控制器],Application Controller[应用控制器],View Helper[视图助手],Composite View[复合视图],Dispatcher View[分配器视图],Service To Worker[服务到工作者]
业务层: Business Delegate[业务代表],Service Locator[服务定位器],Session Facade[会话门面],Application Service[应用服务],Business Objec[业务对象],Composite Entity[复合实体],Transfer Object[传输对象],T O Assembler[传输对象包装器],Value List Handler[值列表处理器]
*集成层: *Data Access Object[数据访问对象],Service Activator[服务激活器],Domain Store[业务领域存储],Web Service Broker[Web Service中转]
- 77 百度能带来短期快感,但是解决不了长期满足感。
- 78 学技术本质是学一个解决方案。解决方案是方法,方法背后是模式,学技术其实就是学模式。
- 79 企业应用架构模式讲的是架构还是模式,还是认为架构是一种模式?
- 80 对于生命来说,每一天都是一样的,并不存在周六周日,做技术也是如此。
- 81 Hibernate是解决方案,数据源架构模式是本质,要分清技术方案和模式区别。
- 82 现象学高手不代表就是数理高手。所以对于开发,技术原理不是必须的。单独寻求原理的百度党,还是现象学的产物。问题:你是怎么掌握技术原理的?区分掌握原理是否有用在于对方停留现象还是数理层面------伪原理开发。
- 83 形容一下你掌握的技术知识?我会xxx,还是思维导图。还是什么?
- 84 以技术理解技术就好比拿着一个榔头看所有东西都是钉子一样。
- 85 “格物致知”同样适用于技术。求的就是个豁然贯通,身性通明。
- 86 思维导图关键看出发点,而非知识点的累积。
- 87 做技术心不要太满,满了就只能看见自己了。
- 88 十个类一天,二十个类三天,三十个类一周。这是正常源码速度。
- 89 源码:代码复杂程度随着类的增加而成呈现指数增长关系。
- 90 源码分析:抽象层/实现层/工具层/模式层/测试层/异常层/入口类。
- 91 面向对象设计原则:SOLID,DRY(Don’t Repeat Yourself),YAGNI(You Ain’t Gonna Need It),GRASP(General Responsibility Assignment Software Patterns),KISS(Keep It Simple & Stupid)。
GRASP:Infomation Expert,Creator,Low coupling,High cohesion,Controller,Polymorphism,Pure Fabrication,Indirection,Protected Variations
比设计模型更重要的是设计原则。
- 92 软件开发方法论:
- 93 有其一套完整的哲学体系的技术大师,或者技术体系的书最具价值。当然他的作品也是他的代码。可否像投资大师分类方法去划分?分门别派。
- 94 人和技术关系思考:成天和老婆在一起,就能领悟男女之道吗?
- 95 业内对技术人员需要掌握的知识并没有达成共识。数据结构,操作系统向来叫好不叫座。同时是重要不紧急的知识。
- 96 面试一定要问:1 你觉得软件开发需要掌握哪些知识?[他觉得的往往是他会的和他的视野], 2 你未来要学习哪些知识?
- 97 当你提出技术有什么意义,目的的时候,是你对自己和技术关系产生了疑问。人与技术最直接关系用技术来解决问题。
- 98 对象池有Config,池对象有Info or State。对象池不需要Factory,本身就具备Factory的特性。但是池对象需要。因为Config不同Info才不同。线程池,连接池,缓存亦如此。
参考设计:
- 99 一般来说先有技术后有规范。比如DI。Java技术规范-JSR,Web技术规范-RFC。有的技术实现遵循了规范,有的不然。
- 100 我的技术学习方法论: 规范 + 实现 + 应用。 JSR51[NIO Since J2SE 1.4] + Grizzly, Netty + 基于Netty的应用。
第二章
- 101道生机器语言,机器语言生汇编器,汇编器生编译器,编译器生上万种高级语言。
- 102 编程是一种事物,事物均有其道,编程也是,有之以为利,无之以为用。
- 103 源码阅读:好的作品要拿来抄,临摹高手作品。
- 104 虽然技术解决了公司的问题,但是解决了自己的问题吗?
- 105 技术二深:技术本身深,自我认识深。技术两广:技术本身广,自我外延广。
- 106 对技术有用没用的认知折射一个人对有用没用本身的思考。人们对事物的认知很少从有用没用为出发点开始思考,而是利益,对我有利就是有用。天底下,无用之事多如牛毛...二元论....
- 107 一种通用模式:用函数对象[通常为接口+泛型]作为策略。
常用的有:Comparable,Comparator,Listner[ContextListener,ServletContextListener,EventListener],Predicate[Guava,JDK8],Filter[FilenameFilter ,Servelt Filter接口],Function[JDK8],Functor,RowCallbackHandler[JdbcTemplate],XXXCallback....
- 108 广义模式的书:POSA[面向资源的软件架构1-5],PLoPD[程序设计的模式语言1-5]
- 109 模式中的模式,编写模式的模式语言。
- 110 GoF模式不是最有用,也不是最本质的,只是较早归纳写在书中。
- 111 不到native决不罢休,难道到了native就该停了?
- 112 每当把类图画成妙龄少女,就有看源码的冲动了。
- 113 脱光代码比脱光少女更有意思。
- 114 抄完源码一份代码就成了两份代码了。手抄Spring源码???这点可以学习顾炎武手抄资治通鉴。
- 115 编程,学习,读书是件老老实实的事,必须认真忠实地对待它。
- 116 大多数人对编程认识止于职业认识。因为启蒙时间太晚了。
- 117 一件事做十年还是五年还是一年还是百年,其思考角度会不同。 编程暂时只有7年之心。
- 118 任何事物都是对象是近20年来最强大的技术。任何事物都是模型是MDE/MDA的中心原则。
Object isInstanceOf Class,System isRepresentedBy Model.
- 119 面向对象技术:
- 120 也许学习Java的一个终极目的是学习面向对象技术。而非详尽其API。详尽其技术实现。
-
121 技术发展轨迹:
我的学习思考:纯Java,Web -》 Patterns- 》Framework- 》MDD,DDD,MDA
- 122 如何判断一项技术的发展趋势?在没人用,在没知名度,在没业界背书的情况下?
- 123 一家技术先进与否取决于三点:1 业务是否先进,复杂 2 团队技术理念是否先进,超前。 3 Leader是否有执行力和想象力将理念实现,变现。
- 124 知道一个技术名词和理解他和码出他是三件不同的事。
- 125 前端技术虽然层出不穷,但是方向是模块化,傻瓜化,一统化。百家争鸣,启蒙时代,文艺复兴是对历史现象的高度概括。思考的暂时结论,而不要有结果。
- 126 任何变化的东西事物其不变的一面。
- 127 经常陷入变化产生现象的思考,而缺乏变化本身的思考。从E = MC^2 看变化是时间和空间的产物。
- 128 技术变化两要素,技术本身变化[简单为理解版本更新],社会变革。后者是变化关键。
-
129 面试前最起码要:搜索enhancements in java se 8 或者 collections framework enhancements in java se 8。
其次进入JEP180,JEP155,最后看源码的变更。
- 130 每使用一个API,要知道其变更记录。每使用一个技术,要追根溯源。[JEPS,JSR]
- 131 软件业的一条发展主线:建立一种可重复应用的东西。以及制造出一种“可重复应用的东西”的方法。子程序,程序,函数,类,函数库,类库,组件,结构化设计,模块化设计,oo设计,模式.....
- 132 伟大的软件来自伟大的程序员,而不是劳苦工作的大众。
- 133 [模式在分类](http://java-design-patterns.com](http://java-design-patterns.com)
Architechtural: API GateWay,Aggregator Microservices,CQRS,Data Bus, Data Transfer Object,Event Driven Architecture,Event Source,Hexagonal Architecture, Layers, Naked Objects, Server Layer
Behavioral: Chain of Responsoibility, Command, Delegation, Dependency Injection, Extension Ojects, Feature Toggle, Intercepting Filter,Interpreter,Iterator,Mediator, Memeto,Null Object, Observer, Specification, State, Strategy, Template method, Visitor
Bussiness Tier: Bussiness Delegate
Concurrency: Async Method Invocation, Balking, Double Checked Locking,Event Queue, Event-based Asynchronous, Guarded Suspension,Half-Sync/Half-Async,Mutex,Producer-Consumer,Promise,Reactor,Reader Writer Lock,Semaphore, Thread Local Storage,Thread Pool
Creational: Abstract Factory,Builder,Factory Kit,Factory Method,Moudle,MonoState,Multiton,Object Mother,Object Pool,Property,Prototype,Singleton,Step Builder,Twin,Value Object
Integration: Message Channel,Publish-Subscribe,Tolerant Reader
Other: Caching,CallBack,Double Dispatch,Execute Around,Fluent Interface,Lazy Loading,Monad,Mute Idiom,Poison Pill,Private Class Data,Queue based load leveling,Resource Acquisition Is Initilazation
Persistence Tier: DAO,DataMapper,Repository
Presentation Tier: Flux,Front Controller,MVC,MVP
Structural: Abstract Document,Adapter,Bridge,Composite,Decorator,Event Aggregator,Facade,FlyWeight,Proxy,Servant,Service Locator
Testing: Page Object
134 模式wiki分类:
- 135 技术讲究顿悟与渐悟。
- 136 工作三年经验,还是一年经验用了三年,取决于是否领悟了道,是否更加认识了自己。君不见,朝闻道,夕死可矣。
- 137 编程三个老师:老子-学会遗忘,杜威-实用主义,斯托曼-自由精神。
- 138 为什么刻意拥有技术?刻意记住,不就是为了忘记吗?学习要东西结合。精确的数理科学+模糊不可言的东方哲学。以其不有,是为大有。忘记才是真正拥有。
- 139 庖丁解牛:先是深入细节,后是忘记细节,最后无形看到全牛。技术也必须深入细节,然后忘记细节。
- 140 问题驱动式的学习一个弊端在于容易忘记。兴趣驱动式的学习终究会成为自己的。两者间的协调是必要的。
- 141 你对技术理解有超越现实的价值存在吗?
- 142 技术有时候需要在现实和超越现实价值中做折中。我学习,因为探索的快乐,求知的渴望。即使没有问题驱动。
- 143 遇到问题去学其实是高效但容易健忘的学习方式。有一种虚假的错感,就是感觉“我会了”。
- 144 懂原理和懂面向对象是两个问题。面向对象最起码会UML+设计模式+面向对象原则。原理才会问HashMap原理。诚然,懂原理和写出优秀面向对象的程序没有必然联系。
- 145 根据业务来学要这么理解:学习技术方案才是根据业务来学。比如Kafka。
- 146 MySql 事务
-
147 JavaIO中最重要的两个设计模式:
1 装饰器:一流多用。包装作用。
2 适配器:兼容类库。字节流当做字符流使用。
- 148 JavaNio核心概念:Buffer + Channel
-
149 易经:形而上者谓之道,形而下者谓之器: -tor,-ter 翻译 为XXX-器或者XXX者 [器多好干活]
-
器[拟物化]: Listener 监听器 Adapter 适配器 Filter 过滤器 Iterator 迭代器 IntBuffer int视图缓冲器 Connector 连接器 Decortor 装饰器 Iterepter 解释器 Interceptor 拦截器 Reactor 反应器 Configurator 配置器 Wrapper 包装器 Proactor 主动器 Monitor 监视器 Controller 控制器 Translator 转换器 Acceptor 接收器 Selector 选择器 Container 容器 Manager 管理器 Evictor 驱逐器 Activator 激活器 Mapper 映射器 Locator 定位器 Handler 处理器 Assembler 汇编器 Driver 驱动器 Spliterator 分割器 Builder 构建器 Formatter 格式器 Scanner 扫描器 Timer 定时器 Converter 转化器 Dispatcher 分配器 Multicaster 广播器 Transfer 传输器 Desriptor 描述器 Encoder/Decoder 编码器/解码器 Introspector 内省器 Tokenizer 分词器 Loader 加载器 (ClassLoader) Logger 记录器 Parser 解析器 Resolver 分解器 Incrementer 增加器/累加器 Counter 计数器 Collector 收集器 Initializer 初始化器 Setter 设置器 Getter 取值器 Marshaller 编组器UnMarshaller 解组器 Helper 帮助器/助手 Accessor 访问器/存取器 Visitor 访问器 Reflector 反射器 Serializer 序列器 Unserializer 反序列器 Embedder 嵌入器 Finalizer 回收器 Specifier 标识器 Supplier 供应器 Processor 处理器 Joiner 接合器 Recorder 记录器 Reducer 还原器/减少器 Analyzer 分析器 Invoker 调用器 Provider 供应器/提供者 Renderer 渲染器 Holder 存储器/持有器 Closer 关闭器 Operator 操作器 Appender 添加器 Printer 打印器 Tuplizer 元组器 Caller 调用器 Identifier 标识器 Walker 浏览器,漫步器[DomWalker,DirectoryWalker] Brower 浏览器, Server 服务器 Aggregator 聚合器 Wokrer 工作器 Binder 绑定器 Validator 校验器 Finder 查找器 Launcher 发射器 Weaver 织入器 Messenger 信差/消息器 Modeler 模型器 Extractor 提取器[InterfaceExtractorProcessor,MethodExtractor ,ClassExtractor ] Sampler 取样器 Profiler 分析器 Tracer 追踪器 Estimator 预估器,估计器 Generator 生成器 Instrumenter 插装器 Viewer 查看器 Cleaner 清除器 Debugger 调试器 Analyser 分析器 Inspector 检查器 Linker 链接器 Decompiler 反编译器 Editor 编辑器 Recognizer 识别器 Translator 解释器 Lexer 词法分析器 Tracker 追踪器 Constructor 构造器 Destructor 析构器 Executor 执行器 Synchronizer 同步器 Barrier 障碍器 Allocator 分配器(Memory Allocator) Bundler 打包器 Applier 分发器 Trigger 触发器
-
**者[拟人化]:**Consumer消费者 Producer 生产者 Observer 观察者 Caller 调用者 [两种并没有太大区别,拟人化] Supervisor监管者 Overseer 监工 Javaer Java开发者 Keeper 管理员[ZooKeeper]
- 150 器可以理解为Idiom,也可以理解为模式。
- 151 GOF分类维度:目的(创建-结构-行为)和范畴(类-对象)。 POSA1分类维度:模式类别(架构模式-设计模式-成例)和问题类别(从混沌到有序-分布式系统-交互式系统-可适应系统-结构分解-工作组织-访问控制-管理-通信-资源管理)。
- 152 GOF在分类:
目的/范畴 | 类模式(编译时确定) | 对象模式(运行时确定) |
---|---|---|
创建(创建对象) | 工厂方法 | 其他所有 |
结构(组合类和对象) | 类适配器 | 其他所有 |
行为(类和对象交互以及职责分配) | 解释器,模板方法 | 其他所有 |
- 153 真实世界的Visitor模式[出自Apt处理注解需要的tools.jar]
- 154 架构分类:
- 155 响应式宣言:
- 156 DTrace Toolkit 工具图
- 157 IO
一种新的类结构表示法
- 158 lang
- 159 reflect
- 160 math
- 161 net
- 162 text
- 163 util
- 164 util.zip
- 165 用户体验5大要素
- 166 委派是实现设计模式的一项重要的基础技术,靠继承能实现多动态啊?
- 167 UML三大师:Grady Booch,Ivar Jacobson,James Rumbaugh。三位方法学大师,软件业的教父人物。
- 168 有本叫《thinking in 大象》,说是可以走向技术自由的梦想之路。问:什么是技术自由的梦想之路?
- 169 Linus谈生活的意义:性,战争,linux。生存-》社会-》乐趣
- 170 技术社会家:Richard Stallman,Aaron Swartz - 技术和政治以及社会运动的结合作品。
- 171 Aaron Swartz:为理念而献身的技术家。
- 172 Why GC is eating all my CPU? you should measure who is eating . but you can not manage what you can not measure. So Let us instrument bytecodes. Use aprof.
- 173 有意思的C/C++和Java对比
- 174 JavaAPI具备自解释性。必须很熟练。量产生质。
- 175 java.lang.Comparable可比较的,java.util.Comparator是比较器。Comparable优于Comparator进行设计。
- 176 一般类名后面+s 说明是一个工具类,一般包含大量静态方法和静态属性。
JDK:Arrays,Objects,Beans,Channels[工厂],Spliterators,
Guava:Charsets,Defaults,Enums,Equivalences,Functions,Objects,Predicates,Strings,Suppliers,Throwables,Interners,Iterables,Iterators,Lists,Maps,Multimaps,Multisets,ObjectArrays,Ranges,Sets.........
- 177 Java的问题的答案可深可浅。 equals,comparable。语言基础的方法。
- 178 学习JVM时候,一定要想为什么这么设计?为什么这么设计数据结构?当然想也想不出来啥。
- 180
- 181 JavaNio之linux实现(参考资料):
EPollArrayWrapper.c , EPollArrayWrapper eventpoll.c wait.h
- 182 You can only manage and improve on what you can measure....
- 183 学习封装多类库的例子(通用日志接口,抽象日志类库的思想): common.log 与 SLF4J 。 具体的日志实现 log4j,java.util.logging,logback。jcl(common log) jul(java.util.log) ,juz(java.util.zip)
- 184 应用级的Facade模式:SLF4J(Simple Logging Facade for Java)
- 185 用户体验不是说按钮放对位置,界面花哨点,或者说解决用户的问题。而是帮助用户学习新的知识。学习用户体验不会让你代码水平有多大提高,而会让你对系统的思考更加全面。
-
187 marker interface:
-
java.lang.Cloneable
-
java.io.Serializable
-
java.util.RandomAccess java.util.EventListener
-
java.util.concurrent.CompletableFuture.AsynchronousCompletionTask
-
javax.xml.stream.events.EndDocument
-
javax.management.loading.PrivateClassLoader
-
java.security.KeyStore.Entry
-
java.security.KeyStore.LoadStoreParameter
-
java.security.KeyStore.ProtectionParameter
-
java.security.Policy.Parameters
-
javax.security.auth.callback.Callback
-
javax.security.auth.login.Configuration.Parameters
- 188 内存管理最高水平:
glibc2.5(未考虑多处理器) dlmalloc(doug lea) ptmalloc3 hoard concur tcmalloc jemalloc(tengine,redis,可优化mysql,nginx)
- 189 每周逛一逛各大出版社。
- 190 开源一家亲
- 191 沈询:技术有三个层次
- 第一个层次是:技术没有拖业务的后腿
- 第二个层次是:技术帮业务拓展边界
- 第三个层次是:技术驱动业务边界,我们都在路上。
- 192 沈询在谈到GTS时候说:GTS是怎么做到的?理解事务先理解db事务,在实现中做了哪些取舍,失去了什么,又带来了什么,在理解原理情况下,做出更多取舍,做出和业务贴合后更加符合业务诉求的方案。
- 193 学习原理是为了做出取舍,做出更加符合业务的技术方案。
- 194 设计模式观点:基于接口的复用,代码重载的方案。代码全部设计模式系统就完美了?满足业务场景业务诉求。不是什么神奇技术。
- 195 计算机分形观点:计算机解决问题都是从原始简单方案迭代成复杂系统,而这些_微妙的变化_就是优化的核心。有时候可以复用方案,有时候复用不了方案,不知道怎么变化的,就无法知道未来在哪里。
- 196 数据库范式:大部分没有用到。范式解决的问题是尽可能减少数据冗余,怎么设计表结构合理,多对多关系有中间表,大量join操作,范式完美,但是效率低,是指导意见,但不是优秀方案。优秀方案是一个削足适履,脚在长出来的一个过程,往回看。
- 197 客户第一,拥抱变化,团队合作。谁是客户?客户要什么?客户满意度?领导满意度?3,4,5分是什么?超出预期又是什么?超出几份?
- 198 技术服务于业务是技术最终归宿。业务服务于客户是业务最终归宿。客户服务于自我需求是最终归宿。只不过每个人理解的业务层次不同。个人,业务就是一个模块。上级,业务就是一个职能单位,对于公司,就是生存之本,对于资本,就是一颗子弹。对于社会,就是一点推动力。
- 199 交流不是寻求认可,不是刻意攻击,不是自夸自擂,而是启发新思考。
- 200 当你一方面强于他人时候,不要认为别人菜。因为你也曾经被别人这么认为过。要思考他为什么这样,他的未来,他的前景,他可能的突破点。
第三章
- 201 干一行,爱一行
- 202 为什么要做技术?生存?一个领域有成就?对事物本身的理解?推动业务发展?出人头地?有所成就,有所高度。 有所领悟,有所得失。
- 203 真正的学习的以不断完善思考能力为基础的,其次才是记忆。只有记住了大量知识才谈理解,只有理解了才会大量记住,才谈融会贯通。
- 204 看完书记不住,因为没有理解。更重要的没有融汇贯通。任督二脉....
- 205 所有性能问题都来自:CPU,内存,IO,所有的瓶颈都是这三项。
- 206 线程状态
- 207 世界是分形的。一种哲学观点。
计算机系统是自下而上的分形系统,在CPU层面看到的东西,在磁盘层面看到的东西,在os层面看到的东西,在软件应用看到的东西,其实都是一个东西,没有特别明显的差异。无非怎么做信号?怎么做相互通知机制?怎么做时间片切换?无非这么几件事。只是不同的层次因为不同的需要而改变。问题本质没变化,无非怎么通信,怎么计算,怎么数据存取,只有这么几件事情。收拢到简单关键词时候,就是树状结构。形成这种认知,往外看,计算机不过如此,特定场景特定的优化而已。大部分特定优化其实并不复杂。多问为什么,问题本质是什么?构造图景理解新的问题就会很快。[DB,应用系统,os,分布式软件最终都要在CPU上执行]
- 208 计算机问题:分层与分形。
- 209 响应时间级别: 内存:纳秒, 网络:毫秒,5000-10000时钟周期:几微秒
- 210 数据库的事务和Java中的并发解决方案,本质是一回事。数据库成为操作远程共享数据叫事务,而应用操作本地共享数据,内存中的共享数据叫并发。
- 211 一个技术的利与弊就是选了他,得到了什么,失去了什么。对于业务取舍了什么,又得到了什么。
- 212 世界上解决一个计算机问题最简单的方法:“恰好”不需要解决它!—— 沈询
- 213 系统如果需要高性能,必然要进行精心的设计。必须有所取舍。计算机解决方案就是一个折中的过程。解决一个问题就会带来另外一个问题。
- 214 复杂的模型越难理解,但是性能越好。越简单的模型,性能往往不好。快速排序和冒泡排序。
- 215 吞吐量问题(单位时间内处理更多的任务)的解决方案:硬件层面,CPU层面,操作系统层面,应用系统层面。
高可用问题解决方案:冗余。
- 216 程序员觉得程序是顺序执行的,其实在CPU层面是乱序的。什么不能乱?Happen-Before规则。维持有序系统需要付出代价。乱不是目的,目的是高效利用CPU。
- 217 消息交互三模型:推,拉,推拉结合。Kafka拉模型,适合海量日志处理,日志处理特点是不需要实时性-》消息堆积能力必然强-》占内存。
- 218 协议是合约解决问题的一种方式。一种协议的产生必然会带来另一钟问题的产生。Paxos协议,TCP协议,Zab协议。解决不了问题,加层,加层做什么?加协议。多台机器数据同步,怎么同步?数据层加paxos协议。技术选型就是一个取舍的过程。
- 219 并发控制产生根源是CPU宏观并行,微观串行。多线程对共享数据的读读,读写,写读,写写。
- 220 性能问题分析:自上而下,自下而上。所有的数据读写问题都可以转化为CPU层面读写问题。
- 221 所有的折中都在时间和空间层面折中。时间足够长,所有消息都是有序的,但是没有意义。将时间压缩到空间,追求更加巧妙的设计。
- 222我们所得到的和所失去的都会在CPU,内存,IO上得到体现。
- 223 这张图代表了什么?
- 224 排序算法比较[log2(n) log以2为底的n]
排序算法 | 最好时间 | 平均时间 | 最坏时间 | 辅助空间 | 稳定性 |
---|---|---|---|---|---|
直接插入排序 | O(n) | O(n^2) | O(n^2) | O(1) | 稳定 |
希尔排序 | O(n(log2(n))^2) | O(n^1.3) | O(1) | 不稳定 | |
直接选择排序 | O(n^2) | O(n^2) | O(n^2) | O(1) | 不稳定 |
堆排序 | O(nlog2(n)) | O(nlog2(n)) | O(nlog2(n)) | O(1) | 不稳定 |
冒泡排序 | O(n) | O(n^2) | O(n^2) | O(1) | 稳定 |
快速排序 | O(nlog2(n)) | O(nlog2(n)) | O(n^2) | O(log2(n)) | 不稳定 |
归并排序 | O(nlog2(n)) | O(nlog2(n)) | O(nlog2(n)) | O(n) | 稳定 |
基数排序(链式队列) | O(mn) | O(mn) | O(mn) | O(n) | 稳定 |
基数排序(顺序队列) | O(mn) | O(mn) | O(mn) | O(mn) | 稳定 |
- 225 JMM核心概念:
- 原子性(一个操作不可中断)
- 可见性(一个线程改变了值,另其他线程立马得知,Volatile)
- 有序性(线程内有序,线程间观察无序,指令重排,Happen-Before)。
- 226 哪些指令不能重排:Happen-Before。
- 227 Volatile作用:可见性和禁止指令重排,比synchronized更轻量级同步机制。
场景:1 volatile最适用一个线程写,多个线程读的场合 2 检查某个状态标记以判断是否退出循环。
volatile boolean shutdownRequested; //不加volatile可能会导致指令重排,-server模式产生死循环
public void shutdown() {
shutdownRequested = true;
}
public void doWork() {
while (!shutdownRequested) {
// do stuff
}
}
- 228 加锁可以保证原子性和可见性,但是volatile只能保证可见性。
- 229 使用场景:BIO:低负载,低并发 NIO:高负载,高并发 AIO:异步处理
- 230 排序算法一览:
插入排序 | 直接插入 | 希尔排序 |
---|---|---|
选择排序 | 直接选择 | 堆排序 |
交换排序 | 冒泡排序 | 快速排序 |
归并排序 | 桶排序 |
插入排序:
直接插入排序:
public static void insertSort(int[] keys) {
for (int i = 0; i < keys.length; i++) {
int temp = keys[i];
int j;
for (j = i - 1; j >= 0 && temp < keys[j]; j--) {
keys[j + 1] = keys[j];
}
keys[j + 1] = temp;
System.out.print("第" + i + "趟 temp=" + temp + "\t");
System.out.println(Arrays.toString(keys));
}
}
public static void insertSort2(int[] keys) {
for (int i = 0; i < keys.length - 1; i++) {
int temp = keys[i + 1];
int j = i;
while (j > -1 && temp < keys[j]) {
keys[j + 1] = keys[j];
j--;
}
keys[j + 1] = temp;
System.out.print("第" + i + "趟 temp=" + temp + "\t");
System.out.println(Arrays.toString(keys));
}
}
希尔排序:
public static void shellSort1(int[] keys) {
//每次增量减半,初始为数组长度
for (int delta = keys.length / 2; delta > 0; delta /= 2) {
for (int i = delta; i < keys.length; i++) {
int temp = keys[i], j;
for (j = i - delta; j >= 0 && temp < keys[j]; j -= delta) {
keys[j + delta] = keys[j];
}
keys[j + delta] = temp;
}
System.out.print("delta=" + delta + " ");
System.out.println(Arrays.toString(keys));
}
}
/**
*
* @param keys 数组
* @param n 数组个数
* @param d 增量数组 [6,3,1]
* @param numOfD 增量数组个数 3
*/
public static void shellSort2(int[] keys, int n, int[] d, int numOfD) {
int i, j, k, m, span, temp;
for (m = 0; m < numOfD; m++) {
span = d[m];
for (k = 0; k < span; k++) {
for (i = k; i < n - span; i += span) {
temp = keys[i + span];
j = i;
while (j > -1 && temp <= keys[j]) {
keys[j + span] = keys[j];
j = j - span;
}
keys[j + span] = temp;
}
}
System.out.print("delta=" + span + " ");
System.out.println(Arrays.toString(keys));
}
}
交换排序
冒泡排序
public static void bubbleSort(int[] keys) {
int flag = 1;
int n = keys.length;
for (int i = 1; i < n && flag == 1; i++) {
flag = 0;
for (int j = 0; j < n - i; j++) {
if (keys[j] > keys[j + 1]) {
int temp = keys[j + 1];
keys[j + 1] = keys[j];
keys[j] = temp;
flag = 1;
}
}
System.out.print("第" + i + "趟: ");
System.out.println(Arrays.toString(keys));
}
}
public static void bubbleSort2(int[] keys){
boolean exchange = true;
for (int i = 1; i < keys.length && exchange; i++) {
exchange = false;
for (int j = 0; j < keys.length - i; j++) {
if (keys[j] > keys[j + 1]) {
int temp = keys[j];
keys[j] = keys[j + 1];
keys[j + 1] = temp;
exchange = true;
}
}
System.out.print("第" + i + "趟: ");
System.out.println(Arrays.toString(keys));
}
}
快速排序
public static void quickSort(int[] keys, int begin, int end) {
if (begin < end) {
int i = begin;
int j = end;
int vot = keys[i]; //标准元素
while (i != j) {
while (i < j && vot <= keys[j]) j--;
if (i < j) {
keys[i++] = keys[j];
}
while (i < j && keys[i] <= vot) i++;
if (i < j) {
keys[j--] = keys[i];
}
}
keys[i] = vot;
System.out.print("["+begin + "-" + end + "], vot=" + vot + " ");
System.out.println(Arrays.toString(keys));
quickSort(keys, begin, j - 1);
quickSort(keys, i + 1, end);
}
}
public static void quickSort2(int[] keys, int begin, int end) {
if (begin < end) {
int i = begin;
int j = end;
int temp = keys[i]; //标准元素
while (i < j) {
while (i < j && temp <= keys[j]) j--;
if (i < j) {
keys[i] = keys[j];
i++;
}
while (i < j && keys[i] < temp) i++;
if (i < j) {
keys[j] = keys[i];
j--;
}
}
keys[i] = temp; //插入标准元素
System.out.print("["+begin + "-" + end + "], temp=" + temp + " ");
System.out.println(Arrays.toString(keys));
quickSort2(keys, begin, i - 1);
quickSort2(keys, j + 1, end);
}
}
选择排序
直接选择排序
public static void selectSort(int[] keys) {
for (int i = 0; i < keys.length - 1; i++) {
int min = i;
for (int j = i + 1; j < keys.length; j++)
if (keys[j] < keys[min]) {
min = j;
}
if (min != i) {
int temp = keys[i];
keys[i] = keys[min];
keys[min] = temp;
}
System.out.print("第" + (i + 1) + "趟: ");
System.out.println(Arrays.toString(keys));
}
}
堆排序
public static void heapSort(int[] keys){
heapSort(keys,true);
}
public static void heapSort(int[] keys, boolean minHeap) {
for (int i = keys.length / 2 - 1; i >= 0; i--) {
//创建最大堆or最小堆
sift(keys, i, keys.length - 1, minHeap);
}
for (int i = keys.length - 1; i > 0; i--) {
//交换顶部和底部元素
int temp = keys[0];
keys[0] = keys[i];
keys[i] = temp;
sift(keys, 0, i - 1, minHeap);
System.out.println("第" + (keys.length - i) + "趟" + Arrays.toString(keys));
}
}
private static void sift(int[] keys, int parent, int end, boolean minHeap) {
//System.out.println("sift " + parent + "..." + end + " ");
int child = 2 * parent + 1;
int value = keys[parent];
while (child <= end) {
if (child < end && (minHeap ? keys[child] > keys[child + 1] :
keys[child] < keys[child + 1])) {
child++;
}
if (minHeap ? value > keys[child] : value < keys[child]) {
keys[parent] = keys[child];
parent = child;
child = 2 * parent + 1;
} else {
break;
}
}
keys[parent] = value;
}
public static boolean isMinHeap(int[] value) {
if (value.length == 0) {
return false;
}
for (int i = value.length / 2 - 1; i >= 0; i--) {
int j = 2 * i + 1;
if (value[i] > value[j] ||
j + 1 < value.length && value[i] > value[j + 1]) {
return false;
}
}
return true;
}
public static boolean isMaxHeap(int[] value) {
if (value.length == 0) {
return false;
}
for (int i = value.length / 2 - 1; i >= 0; i--) {
int j = 2 * i + 1;
if (value[i] < value[j] ||
j + 1 < value.length && value[i] < value[j + 1]) {
return false;
}
}
return true;
}
public static void whatKindOfHeap(int[] value) {
if (isMinHeap(value)) {
System.out.println("最小堆");
}else if(isMaxHeap(value)){
System.out.println("最大堆");
}else{
System.out.println("非最大堆或者最小堆");
}
}
归并排序
public static void mergeSort(int[] X) {
System.out.println("归并排序");
int[] Y = new int[X.length];
int n = 1;
while (n < X.length) {
mergepass(X, Y, n);
System.out.println(Arrays.toString(Y));
n *= 2;
if (n < X.length) {
mergepass(Y, X, n);
System.out.println(Arrays.toString(X));
n *= 2;
}
}
}
private static void mergepass(int[] X, int[] Y, int n) {
System.out.print("子序列长度n=" + n + " ");
int i = 0;
for (i = 0; i < X.length - 2 * n + 1; i += 2 * n) {
merge(X, Y, i, i + n, n);
}
if (i + n < X.length) {
merge(X, Y, i, i + n, n);
} else {
for (int j = i; j < X.length; j++) {
Y[j] = X[j];
}
}
}
private static void merge(int[] X, int[] Y, int m, int r, int n) {
int i = m, j = r, k = m;
while (i < r && j < r + n && j < X.length) {
if (X[i] < X[j]) {
Y[k++] = X[i++];
} else {
Y[k++] = X[j++];
}
while (i < r) {
Y[k++] = X[i++];
}
while (j < r + n && j < X.length) {
Y[k++] = X[j++];
}
}
}
- 231 排序算法:算法详情
- 232 分布式的好处:理论上无限可扩展能力和高可用能力。
- 233 消息中间件作用:解耦,异步,最终一致性,并行
- 234沈询:“特别注重基础,操作系统、网络、算法数据结构、离散数学、数据库原理与实践,这些看起来枯燥而无味的基础科学,是我目前感到知识最为匮乏,但却最为急需的部分,要了解它们是必须付出非常多的时间才有可能理解通透些。而这些基础的扎实程度,就直接决定了你的高度”。
- 235 线程与QPS计算公式(吞吐量提升一倍,服务器数量减少一半)
线程数 = (线程总时间/瓶颈资源时间) * 瓶颈资源线程并行数
QPS = (1000/响应时间[线程总时间])* 线程数 = 1000/瓶颈资源时间 * 瓶颈资源并行数
QPS和响应时间没有关系,优化响应时间效果不大。
- 236 QPS三要素:线程,响应时间,瓶颈资源。
QPS瓶颈:磁盘IO,网络IO,CPU,内存GC hold,线程限制,线程同步锁,远程系统QPS
- 237 JUC
JUC 详情
- 238 JUC使用场景:
ReentantLock (互斥锁,可重入锁,独占锁-Mutex-读读互斥)可定时,可轮询,可中断,公平队列,非块结构加锁。
ReentrantReadWriteLock (读写锁-读读共享) 一个共享资源被大量读取操作,而只有少量写操作。
StampedLock 实现乐观悲观锁
Volatile 一个线程修改,多个线程读取
CopyOnWrite 读多写少 白名单,黑名单,商品类目访问和更新
DelayQueue 缓存系统设计,定时任务调度
LinkedBlockingDeque ForkJoinPool 工作窃取算法
BlockingQueue 生产者消费者模式实现
ConutDownLatch 等待某个条件满足后才做后面的事情。Zk连接集群的时候。
AbstractQueuedSynchronizer 实现自己的同步器
Semaphore 流量控制 资源有限情况。排队场景,线程池,连接池等
CyclicBarrier N个线程互相等待 用于多线程计算数据,最后合并计算结果
ForkJoinPool 任务拆分在汇总的计算
ThreadLocal 线程内变量 Connection,防止对可变单利变量或者全局变量进行共享。
SynchronousQueue 有足够多消费者,并且总有一个消费者准备好交付工作的情况下使用
Deque(ArrayDeque,LinkedBlockingDeque) 即是生产者也是消费者问题。执行某个工作时候可能出现更多的工作。
Exchanger 遗传算法,校对工作(AB-excel)
ExecutorCompletionService 向Executor提交一组计算任务,计算完成后分别获得计算结果。
Future.get 指定时间内没有完成,则取消任务 任务没有完成则阻塞 指定时间完成某些任务,页面渲染器,指定时间获取广告信息
守护线程:执行辅助工作,执行“内部”任务,周期性从内存的缓存中清除过期数据。不用于应用程序服务的生命周期
...待补充
- 238 优先使用有界队列:1 稳定性和预警 2 单一模块不可用不会造成整个系统不可用 3 强大的资源管理工具,防止产生过多的工作项,使得程序在负载过荷情况下变得更加健壮。
无界队列:内存撑满问题。
- 239 线程池线程数的一种思考:
1 Tomcat,Nginx 最大限度发挥单机server最大并发量。
2 CPU密集:N+1 IO密集型 2 * N
3 IO+CPU差不多:(N+1 + 2 * N)/2
- 240 线程安全: 当多个线程访问某个类时,不管运行时环境采用何种调度方式,或者这些线程将如何交替执行,并且在主调代码中不需要任何额外的同步或协同,这个类都能表现出正确的行为,那么就称这个类是线程安全的。
- 简单定义::当多个线程访问某个类的时候,这个类始终表现出正确的行为,那么这个类就是线程安全的。
- 241 对象一些状态的共享和可变决定了对象是否线程安全。线程安全最核心的概念是正确性。正确性是某个类的行为与其规范完全一致。单线程正确性是“所见即所知”。
- 242 JUC分类:
- 1 并发集合 BlockingQueue CopyOnWrite(CopyOnWriteArrayList,CopyOnWriteArraySet) Concurrent(ConcurrentHashMap,ConcurrentLinkedDeque,ConcurrentLinkedQueue,ConcurrentSkipListMap,ConcurrentSkipListSet)
- 2 同步器 Semphore CountDownLatch CyclicBarrier Exchanger FutureTask(语义上的)
- 3 执行器 Executors Callable ThreadPoolExecutor Future
- 4 锁和条件类 Synchronized ReentrantLock ReentrantReadWriteLock StampedLock Condition LockSupport
- 5 原子变量 AtomicXXX
- 243 AQS
- 244 Queue
- 245 Lock
- 246 实现等待通知
等待/通知 | 等待 | 通知一个 | 通知所有 |
---|---|---|---|
Condition(Lock) | await | signal | signalAll |
Object | wait | notify | notifyAll |
- 247 所有并发问题都可以归结为如何协调对并发状态的访问。可变状态越少,越容易保证线程安全性。
- 248 服务器程序应该体现出良好的吞吐量和快速的响应性。
- 249 在一定范围内,增加线程可以提供系统吞吐量,但是超出范围,反而降低性能。(创建开销,资源消耗占内存,GC压力)
-
250 实现一个线程:Thread(单继承局限),Runnable(不能返回值或者抛出受检异常,多继承),Callable(有返回值,泛型)
Runnable和Callable都是对任务的抽象。
- 251 同构任务并行化(真正的性能提升)和异构任务并行化(获取重大性能提升很困难)
- 252 中断是一种协作机制。它不会真正中断运行的线程,而只是发出中断请求,然后线程在下一个合适的时间中断自己。
- 253 通常,中断是实现取消的最合理方式。也可以循环检测某个状态位(volatile) 取消。
- 254 幂等:多次请求得到结果一样。
- 255 Java线程分为两类:普通线程,守护线程。两者唯一区别仅在于:线程退出时候的操作。
- 256 提问的技巧:所有问题后面加实现原理。AQS原理,线程池原理,ArrayList原理,synchronized** 原理 ,分布式事务原理**,Condition原理,AOP原理,Spring事务实现原理.......
- 257 ThreadFactory很受欢迎 !!!
- 258 线程池作用:1 提高执行任务性能 2 资源管理
从ThreadPoolExecutor理解线程池的原理:Core and maximum pool sizes,On-demand construction,Creating new threads,Keep-alive times,Queuing,Rejected tasks,Hook methods,Queue maintenance,Finalization。
详情请看 这里
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler){}
- 259 阿姆达尔定律告诉我们:光加CPU不一定吞吐量上的去,还要考虑程序串行比。
- 260 阿姆达尔定律:在增加计算资源的情况下,程序理论达到的最高加速比取决于程序的串行化比例。
- 261
- 262 内存栅栏(内存屏障):刷新缓存使缓存无效,刷新硬件的写缓存以及停止执行管道,抑制编译器优化,实现内存顺序限制,操作是不能被重排序的。
- 263 悲观锁适合并发争抢比较严重的场景;乐观锁适合并发争抢不太严重的场景。
- 等待时间较短,适合自旋等待(JVM实现阻塞)。等待时间较长,采取os挂起。
- 264 非竞争同步可以在JVM中处理,竞争的同步可能需要os介入。
- 265 阻塞的本质是等。非阻塞同步算法还是要等。等 = for(;;){}
- 266 Little定律:在一个稳定系统中,顾客平均数量 = 平均到达率 * 平均停留时间
- 系统中物体的平均数量等于物体离开系统的平均速率和每个物体在系统中停留的平均时间的乘积
- 267 通常,对象分配操作(new )的开销比同步开销更低。所以对对象池说“不”。
- 268
后半段,随着线程数增加,吞吐量趋于稳定,因为大部分时间消耗在上下文切换和调度延迟上。线程太多不好,太少也不好。
- 269 上下文切换:运行和阻塞之间转换。
- 270 提升可伸缩性:1 减少锁持有时间 2 降低锁粒度(锁分解,锁分段) 3 采取非独占锁 4 非阻塞锁代替阻塞锁
- 271 一种学习思路:性能调优。log4j性能调优,kafka性能调优,redis性能调优,ngnix性能调优,jvm性能调优,mysql性能调优....
- 272 Java中的锁(ReentrantLock-非阻塞加锁)必须要和内置锁(Synchronized-阻塞加锁)必须提供一样的内存语义(可见性,原子性,顺序性)。但是实现可以不同。monitorenter,monitorexit和CAS(CMPXCHG),实现的核心不在于锁,而在于如何实现一样的内存语义
- 273 读写锁:写可以降低为读,而读不能升级为写。因为会发生死锁。
- 274 hash算法的评估:单调性和平衡性。一致性hash主要用在缓存系统。移除/添加一个cache时候,尽可能少的改变已存在的key映射关系,满足单调性。
- 275 一致性hash映射过程:1 构建环形hash空间 2 对象映射到hash空间 3 cache映射到hash空间 4 对象映射到cache上。
- 276 分布式的理论:CAP 。(强一致性,可用性,分区容错性)
CA-》RDBMS-》ACID-》强一致性
AP-》NoSQL,DNS,QQ头像修改-》BASE(基本可用,软状态,最终一致性)-》最终一致性
CP-》分布式DB
- 277 **ACID **VS BASE
比较 | ACID | BASE |
---|---|---|
一致性 | 强一致性 | 最终一致性 |
特征 | 一致性优先 | 可用性优先 |
方法 | 悲观 | 乐观 |
适应变化 | 难以变化 | 适应变化 |
- 278 基础知识是打通知识体系的针线。对基本问题思考越深,对变化就会越理解,对现象也就越理解。因为计算机学科基础问题决定了上层建筑的扎实程度。
- 279 计算机学科基础问题有哪些?
- 280 数据库理论很完备了。实际运用可能会完善和补充理论,但是不会超越理论。
- 281 请求servlet
-
282 Cookies原理
- 283 Session原理
- 284 Servlet工作图
- 285 对比
Cookis,保留用户上次登录时间,保存浏览记录,登录不用重复输入密码,记录用户喜好(背景色,有无背景音乐),网站个性化(定制服务),
Session 购物车,全局用户名,防止用户非法登录到某个界面,用户验证码,判断新用户,取得用户操作时间,注销用户,
ServeltContext(application对象) 在线人数,累计访问量(db,file,servletContext),公共聊天室,多个Servlet通过ServeltContext共享数据,获取web初始化参数,读取WEB目录和WEB-INF目录文件,聊天系统,网站在线用户显示,
- 286 有生命周期的对象:JVM加载Class对象,SpringBean生命周期,Servlet生命周期,线程生命周期,线程池生命周期,Hibernate对象生命周期,对象生命周期(JVM GC机制核心)。
- 287 JSP和Servlet都是单例模式,多个请求对应一个JSP/Servlet。
- 288 JSP原理
- 289 一个类是否是同一个类,有两个条件。 1 包名.类名是否相同。 2 加载这个类的ClassLoader是否是同一个。
- 290 同一个ClassLoader不能同时加载两个相同的类,但是同一个类可以被两个不同的ClassLoader加载。
- 291 类加载机制
- 292 GC解决了下面三问题: 1 哪些内存需要回收?(堆和方法区) 中已经"死"的对象? 1 引用计数 2 可达性分析算法
- 2 什么时候回收? 3 如何回收?
- 293 垃圾收集器
- 294 垃圾回收算法: 1 标记-清除 2 标记-复制 3 标记-整理 4 分代收集算法(hotspot)
- 295 Java是一种静态多分派,动态单分派的语言。
方法调用:1 解析 2 分派(静态分派-重载,动态分派-覆写)
- 296 Java是一种动态语言(反射),但是是静态类型语言。
- 297 动态类型语言:变量无类型而变量值才有类型。
动态语言:Java 静态语言:C/C++
动态类型语言:Js,Python 静态类型语言:C/C++,Java
- 298 代码编译的结果从本地机器码转变为字节码,是存储格式发展的一小步,却是编程语言发展的一大步。
- 299 Java程序信息分为: 代码(Code属性)和元数据(除去代码外所有的信息,注解,注释,javadoc)。
- 300 理解字节码:
SuppressPropertiesBeanIntrospector.class和String.class
第四章
- 301 Synchronized原理分析(Javac+Java虚拟机共同协作,比如JMM层面):
方法:常量池flags=ACC_SYNCHRONIZED
代码块:字节码指令 monitorenter和monitorexit
机器码:lock(read,load,use),unlock(store,write,assign)
- 302 世界上没有完美的程序,但是我们不应该沮丧,因为写程序本身就是一个不断追求完美的过程。
- 303 执行Java程序
- 304 理解运行时
- 305 为什么JVM采用分代回收策略?基于观察事实:1 大部分分配对象的存活时间很短 2 存活时间久的对象很少引用存活时间短的对象。基于弱分带假设。
- 306 MinorGc触发条件:Eden没有足够内存空间来分配对象。
- 307 垃圾回收器工作图解
- 308 Java学的好的标志:掌握从java层到jvm层映射。例如:对象池会加大老年代的存活时间,不好的编程实践,ArrayList给定初始化尺寸,内部数组不断调整,导致不必要的内存分配。
- 309 程序怎么优化?1 吞吐量 2 响应性 这些优化映射到CPU,内存,IO层上,在映射到Java层,就体现出掌握JVM内存分配的重要性了。
- 310 程序优化本质是一个调整映射过程。代码到jvm到os到机器。区别不同在于自上而下还是自下而上。
- 311 MinorGC:新生代垃圾收集。 FullGC:整个堆(新生代+老年代+永久区)收集。
MinorGC:当Eden区满时,触发Minor GC。
FullGC:1 System.gc 2 老年代空间不足 3 永久代空间不足 4 CMS GC时出现promotion failed和concurrent mode failure 5 统计得到的Minor GC晋升到旧生代的平均大小大于老年代的剩余空间 6 堆中分配很大的对象
- 312 缓存命中率和和缓存大小没有关系。频繁UPDATE操作,缓存设置再大也没有用。命中率取决于工作负载。
- 313 InnoDB是大多数情况下最好的选择。
- 314 MySQL服务器逻辑架构图:
- 315 MySQL逻辑详细图
- 316 垃圾回收器本质是一种空间管理技术。缓存也是。只不过一个希望对象存活久,一个希望对象存活短。而垃圾回收机制对应缓存的清除策略。反面想,缓存的设计也可以划分为年轻代与老年代。此时对象更希望进入老年代,保持长期有效对象。此时关键在于缓存数据结构的设计。
- 317 内存回收技术反面就是内存不回收策略。也就是内存常驻技术。
- 318 设计一个垃圾回收器的思路: 1 分布式垃圾回收器,两个jvm运行一段程序 ,n个jvm,n台机器,在提供一个抽象网络jvm层 2 高并发的垃圾回收器 3 反垃圾回收器
4 插件体系架构类似存储引擎的垃圾回收器,每一部分做成可插拔式的。 精简版,按需定制。对外提供API。开源社区提供插件。
- 319 性能优化的前提是监控与统计,否则无从谈起。
- 320 MySQL调优顺序:1 Schema与数据类型优化 2 索引优化 3 查询优化 4 优化服务器设置 5 操作系统与硬件优化 6 应用层优化 -《高性能的MySQL》 完美调优不存在,服务器设置是调优时间投入产出很小的调优。而前三者投产比大。
- 321 my.cnf的配置:映射到os,io,cpu,内存。zk,nginx也是如此。
- 322 进程间通信是所有分布式系统的核心。不谈分布式机器间信息交换机制,对分布式系统研究成了空谈。
- 323 对分布式系统研究角度:
1 体系结构:集中,非集中,混合?
2 进程:线程实现?虚拟化?客户端?服务端?代码迁移?
3 通信 :远程过程调用(同步RPC,异步RPC),消息通信(瞬间与持久)
4 命名
5 同步
6 一致性与复制
7 容错性
8 安全性
- 324 学习网络其实本质是在学协议栈。如何层与层之间通信,也就是信息交换机制。
- 325 协议是解决方法的高级抽象。TCP协议思路也可以应用到应用程序,仅此而已。
- 326 OSI看所有分布式系统都只是应用程序而已。
调整后的网络通信模型。越往下,越通用,越抽象,越不变。
- 327 中间件协议:认证协议,授权协议,分布式提交协议(在一组进程内,某种操作要么由全部进程共同完成,要么不执行),分布式锁定协议(保护资源免受分布于多台机器上一组进程的并发访问),通信协议等。均与应用程序无关的协议。可用来实现通用的中间件服务。
- 328 通信模型
分类 | 持久通信 | 瞬间通信 |
---|---|---|
同步通信 | 消息队列(请求提交时同步化) | RPC(请求完全处理后同步化) |
异步通信 | mom | Berkeley套接字,mpi |
- 329 参数传递机制:1 call by value 2 call by reference 3 call by copy/restore (Ada语言)取决于语言设计者。
- 330 构建服务器的三种方式: 1 单线程 2 多线程 3 有限状态机
- 331 RPC分类:单向RPC,同步RPC,异步RPC(转账,启动远程服务,执行批处理),两步RPC(延迟的同步RPC)
- RPC系统(DCERpc,SunRpc),RPC框架(gRpc偏重于语言)
,
- 332 两个节点交换更新信息方式:1 pull 2 push 3 pull-push 感染算法:传播更新信息。
- 333 互联网架构八荣八耻,DevOps
以可配置为荣,以硬编码为耻
以系统互备为荣,以系统单点为耻
以随时可重启为荣,以不能迁移为耻
以整体交付为荣,以部分交付为耻
以无状态为荣,以有状态为耻
以标准化为荣,以以特殊化为耻
以自动化工具为荣,以人肉操作为耻
以无人值守为荣,以人工介入为耻
- 334 Java八荣八耻
以动手实践为荣,以只看不练为耻。
以打印日志为荣,以出错不报为耻。
以局部变量为荣,以全局变量为耻。
以单元测试为荣,以手工测试为耻。
以代码重用为荣,以复制粘贴为耻。
以多态应用为荣,以分支判断为耻。
以定义常量为荣,以魔法数字为耻。
以总结思考为荣,以不求甚解为耻。
- 335 python之禅
Beautiful is better than ugly.Explicit is better than implicit.Simple is better than complex.Complex is better than complicated.Flat is better than nested.Sparse is better than dense.Readability counts.
Special cases aren't special enough to break the rules.Although practicality beats purity.
Errors should never pass silently.Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.Although that way may not be obvious at first unless you're Dutch.
Now is better than never.Although never is often better than right now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
- 336 一种感悟:XXX性能优化,XXX优化,XXX设计总会归结于几个简单的思考出发点。IO,CPU,内存,磁盘。这是一种在计算机领域相同的思维逻辑,一种统一的思维出发点,无论再难的问题,执行总是在CPU进行读-取-执的过程循环。计算机是一个封闭的系统,系统内有其客观规律存在,不会超越硬件规律。存不存在一种通用的思考出发点去看待所有问题,但是解决方案却是不同的。知识无涯,而道有止。
- 337 为什么有时候学了原理好像没有什么用?因为对原理解决的简单问题,问题的演化,其他解决方案没有进行深入探索。出于简单的思考点,一步一步演化,才能真正理解原理。消息队列的出发点是通信,而不是存储信息的容器,也不是Producer-Consumer模型,更不是Kafka。而高性能Kafka一定通过其固有模型来映射OS层icmd来体现。但是通用的消息中间件所面临的设计问题的类似。通信方式有RPC,消息,流,多播通信。设计模式的出发点是代码复用,重构出发点是旧代码的重设计。
- 338 高性能指的是ICMD之间的权衡。对外体现给计算机一个任务他可以立马处理完。设计高性能的XXX中间件,离不开ICMD的权衡。Netty高性能也必然体现在此。IO多路复用和网络通道复用异曲同工。计算机处理问题方式和人处理问题方式没太大差别。都是人海战术。一个不行上两个(多线程)。更多和更巧体现了设计上的差异。
- 339 哪一个高才是你所需要突破的?高性能,高可用,高吞吐,高并发,高响应,高可扩,高体验,高收益?
-
340 三星索引设计过程:1 等值谓词放入索引。 2 order by 列放入索引。 3 其余列加入索引。
一星:最小化索引片宽度。 二星:排除排序 三星:排除回表。
三星索引为什么快? 一次查询只需要一次磁盘随机读和一次窄索引片的扫描。可能的最好索引。
- 341
为其设计索引?
两星索引(CITY,FNAME,LNAME),(FNAME,CITY,LNAME)
一星索引(CITY,LNAME,FNAME),
最差(LNAME,CITY,FNAME) CITY列不参与索引匹配
- 342 好的技术书一般都带设计,模式,原理,高性能,内幕,权威之类的字眼。这类书和XX天精通区别在于一个讲设计和原理,一个在讲应用。会用和会设计书两种能力。
- 343 分布式系统设计的公共特性与设计问题(设计层抽象):
1 物理模型:硬件模型
2 体系结构模型:cs/p2p
3 基础模型:交互模型,故障模型,安全模型
分布式系统有其公共的设计问题,而不同类型的中间件也有其公共的设计问题。消息中间件和NoSql的公共设计问题不同,但是本质是类似的。技术选型的过程其实是理解其设计问题背后假设的一个过程,也就是应用场景问题。通用消息中间件设计问题有:消息重复和消息顺序问题。而这个设计问题属于基础模型中的故障模型。两者区别在于设计的抽象层不同。还有通用的RPC框架经典的设计问题等等【NELSON Implementing Remote Procedure Calls】
- 344 设计问题需要看Papper。
- 345 你能从支持随机读写的特性可以推断出其他什么特性?理解某一个开源应用的特性过程其实就是理解其设计问题背后假设的一个过程。可否特性推断,可否产品推断。MYSQL的inndb和myisam的设计问题代表一类软件的设计问题。
- 346 设计一个XXX系统?先思考假设是否成立。设计秒杀?这个问题本身就是错误的。抽象成:在极短时间进行对共享资源进行海量读写情况下,如何保证数据一致性以及系统的可用性?继续抽象:高并发的数据一致性问题。继续抽象:ICMD层。设计一个通用场景的解决方案难在假设的正确性。
- 347 任何“不完美的系统”必然存在某些形式上的妥协。
- 348 不完美的系统因为人类思维的局限性。即不可能预测未来。
- 349 从解决方案到设计方案的区别在于是否理解基本的设计问题。
- 350 TCP和UDP之间有趣权衡。UDP提供了简单消息传递机制,有遗漏故障却无性能故障。TCP保证消息传递,但需要以额外的消息高延迟和存储开销作为代价。
- 351 Consistent Hashing:本质是减少remapping的技术。在分布式中就是当节点离开或者加入时候使得原先节点变动最少。在缓存中意味着减少节点的缓存失效。其核心概念来自DHT。
- 352 当你不知道系统处于什么状态的情况下,要针对不同情况进行相应的可接受的策略设计,并设计不可接受的补救措施。比如悲观情况,乐观情况,最有可能情况,没有情况。分布式系统是一个证伪的技术范畴。作为证伪的系统体系中,你知道不是什么很容易,但是知道是什么很难。数据库的事务等级也是种假设,对读多写少进行设计是概率,不是必然。所以系统设计总不是完美的,因为你不可能考虑到所有假设情况。
- 经典的策略:乐观锁和悲观锁以及自旋锁等。补救措施:锁升级,但是锁升级又会带来设计上的复杂。设计复杂和性能优化的权衡。
- 高可用的数据复制策略以及数据刷盘的补救措施。
- 353 分布式系统的特点是什么,就是分布式数据库的特点,也就是消息队列的特点,也就是mysql集群的特点。
- 354 分布式系统是一个证伪的系统。
- 355 一致性问题本质是一个收敛性问题。所有节点值一样的情况下,系统是一种理想的平衡状态。A+B>=2根号(A*B)
- 356 读写分离以及主库只写,从库只读。本质是对“所有节点均可读可写”的简化。所有节点均可读可写情况下系统可以收敛吗?或者说可以系统状态一致吗?
- 357 Roger Needham 在计算机科学上,所有问题都可以通过某个层次上的间接方式来解决。
- 358 Jim Gary 没有通过消除某种层次上的间接方式解决不了的性能问题。
- 359 通信范型中时间与空间的耦合与解耦。
- 360 计算机最重要的能力是抽象能力,但是编程语言带来不了抽象性,数学可以带来抽象。
- 361 什么是计算?
- 362 集中式意味着缺少弹性和可伸缩性。更重要的是存在单点故障和性能瓶颈。
- 363 pub/sub系统设计体系
Pub/Sub例子
- 364 Do you know the future of jvm?the future of java?the future of data?the future of compute? the future of language?
- 365 设计好的API先从方法命名和方法参数做起。
- 366 分布式算法(Distributed algorithm)分类:原子提交(2PC,3PC),一致性(Paxos,Raft),分布式查找,领导选举,互斥,资源分配,复制,可靠广播,生成树等。
- 367 间接通信总结
- 368 CAP理解:
C+A 以2阶段提交(2 phase commit)为代表的严格选举协议。当通信中断时算法不具有终止性(即不具备分区容忍性);
C+P 以Paxos、Raft为代表的多数派选举算法。当不可用的执行过程超过半数时,算法无法得到正确结果(即会出现不可用的情况);
A+P 以Gossip协议为代表的冲突解决协议。当网络分区存在和执行过程正确时,只能等待分区消失才保持一致性(即不具备强一致性)
- 369 人类不可能制造永动机同样也不可能满足flp impossible或cap。cap打破了制造超级计算机的幻想。一台有无限存储和计算能力的“超级计算机”,可以提供无穷大的存储容量,并且可以将计算时间降低至无穷小。
- 370 分布式系统设计其实就是就权衡cap。
- 371 cap权衡在nosql中的应用
- 372 Lamport逻辑时钟(Logical clock)不能捕获因果关系,但是向量时钟(Vector clock)可以捕获因果关系。
- 373 向量时钟有可能确保所有先于某个消息的所有消息接收后才传送这个消息。
- 374 A distributed hash table (DHT) is a reliable, scalable, wide-area data storage system that frees programmers from many of the complications of building a distributed system
- 375 DHT不是一个算法也不是一个数据结构,而是一个解决分布式问题的一个存储系统。
- 376 DHT的优缺点
- 377 分布式系统和计算机网络的一个普遍问题是没有全局共享时钟。不同机器上的进程有自己的时间。
- 378 时钟概念理解:make程序。
- 379 Lamport:Happen-Before,Vector Lock,Logical Lock,Lamport TimeStamps ,Vector TimeStamps....
- 380 Lamport:时钟同步是可能的,但是不是必须的。如果两个进程间不进行交互,那么时钟无需同步。重要的不是所有的进程在时间上完全一致,而是他们在事件发生顺序上要达成一致。
- 381 互斥算法:
- 382 进程同步的基础问题:1 时钟 2 互斥 3 选举
- 383 时间,时钟,事件顺序。
- 384 复制可以提高可靠性和性能,但是带来多副本间数据不一致的问题和消耗更多网络带宽。复制代价大小取决于进行一致性处理的代价。
- 385 一致性实现的关键思想:以单个原子操作或者事务的形式在所有副本上执行更新。
- 386 可扩展问题可以通过复制和缓存技术得到缓解,但是保持所有副本一致性通常需要全局同步,而全局同步又会带来严重的性能下降。可行的方法是放宽一致性的限制。如放松以原子操作方式执行的要求。可放宽程度取决于复制数据的访问模式和更新模式更取决于数据的用途。
- 389 Mark Richards 在software architecture patterns一书中将架构分类以及架构特点:
Overall Agility:整理灵活性 Deployment 部署 Testability 可测性 Performance 性能 Scalability 扩展性 Development 开发
- 390 常见的编程范式:命令式,申明式,结构化,过程化,函数式,面向对象,事件驱动,基于自动机的(有限状态机)
- 391 没人实现Chrome浏览器使用分层架构模式,也没人实现Web网站使用微内核架构模式。但是Web框架本身可以采用插件模式。RPC框架实现用Broker模式。但是RPC本身请求过程可能是分层模式(去Db请求数据)。
- 392 POSA1。分类架构模式
- 393 多副本写实现一致性:Lamport时间戳+定序器的对称多播
- 394 分布式系统中向量时间戳提供了一种表示历史记录的方法。(历史读写操作集合)
- 395 原子性是很多应用程序的重要特征。分布式系统(包括分布式事务)中的原子性基础是分布式提交协议。
- 396 容错的关键技术-----冗余(Redundancy)
- 397 分布式服务器故障模型
Arbitrary failure 也叫 Byzantine failure。
- 398 CAP
- 399
第五章
- 400 一致性模型:较少限制的模型比较容易使用,而带来较多限制的模型使用起来比较困难,但是容易使用的模型的执行效果不如复杂模型那样好,这就是生活。
- 401 开发人员为应用程序指出一致性需求但是获得这种需求可能是很困难的。开发人员往往不熟悉处理复制问题,更不要说让他们理解一致性的详细信息了,因此,编程接口必须是简单的且容易理解的。
- 402 冗余技术:1 信息冗余 2 时间冗余 3 物理冗余。 物理冗余是提高容错性最著名的技术。眼睛,耳朵,手,飞引擎。
电路设计的TMR-三倍模块冗余
- 403 Quorum:多数表决的一个操作是否在分布式环境中执行。可用于提交协议或者复制协议。
- 404 语言的分类@
- 405 多语言金字塔
- 406 编程上下文设计思路影响了开发工具:
复合型抽象:细粒度组建构成整体。Unix shell
上下文抽象:基于插件的架构。elispe,maven,ant。必须先理解上下文。
- 407 基于微内核的架构(也叫基于插件的体系):Eclipse IDE和Amoeba。其他基于插件的架构:mysql引擎,hybris加速器。
- 408 JVM是个什么架构体系?
- 409 思考软件架构与业务架构:spring什么架构?网络什么架构?netty什么架构?elispeIDE什么架构?dubbo什么架构?linux内核什么架构?秒杀什么架构?平台开发什么架构?消息队列什么架构?编译器什么架构?mysql什么架构?微服务什么架构?hybris什么架构?jvm什么架构?垃圾回收器什么架构?spanner什么架构?hdfs什么架构?大数据平台什么架构?uds什么架构?word什么架构?任何软件均有其架构,也就是设计思路。
- 410 架构就是设计思路。设计思路就是解决系统关键的几个问题,提出关键的问题并解决就是架构。
- 411 设计rpc,设计rpc的框架和设计基于rpc的应用架构。第一个是设计架构的架构,第二三个是设计架构的应用。设计RPC更抽象。
- 412 SPI在JDBC中的应用
- 413 各种SPI机制对比
- 414 框架灵魂:bean之于spring,handler之于jetty,valve(阀)/container之于tomcat,而HSF框架本身没有灵魂。它们是面向新需求的扩展点,是框架解决变化的原则。
- 415 SPI
- 416 Cassandra设计 = Google Bigtalbe(HBase) + Amazon Dynamo,特点:分布式,无中心(对等架构,Gossip),弹性可扩展,高可用,容错,可调一致性,面向列。
- 417 最终一致性的“最终”一般是毫秒。
- 418 区块链是分布式技术的应用,一种去中心化的技术架构。
- 419 区块链通用架构 。POW,POS,PBFT,RAFT
- 420 spanner和aurora区别
- 421 OLTP和OLAP区别
- 422 数据库对比
- 423 IT本质是计算。图灵机是现代计算机的理论基础。冯诺伊曼架构主导了计算机60多年的发展。宏观架构的几次变化,从最底层看,在新的场景中为突破底层冯诺伊曼的瓶颈(指令串行执行,程序和数据共享总线,计算和数据分离)在而进行的上层调整,在IT层面遇到的问题,将冯诺伊曼按照特定的协议按某种架构进行组合。以满足特定的需求。
- 424 分布式存储系统对比
- 425 可用性
- 426 可用性分析
- 427 赵班长的缓存知识体系(点击查看)
- 428 运维知识体系(点击查看)
- 429 分布锁兼容表
NL:Null 对资源不访问 CR/W:并发读/写 PR/W :保护性读写 Ex:互斥,独占
-
430 数据库锁兼容性
- 431 Oracle锁兼容性:
- 432 SqlServer锁兼容性
- 433 技术趋势
技术热点到炒作到企业产品输出。
- 434 进程间通信方式
-
435 进程间通信方法,协议,库
-
436 学Lisp就好比学道德经,对现在有什么作用?
- 437 编程本质是和计算机(图灵机)交流,和一种计算模型交流,编程语言只是交流途径,但是交流的思维和层次不一样。更有意思的是你在和人造的东西在交流。这种计算模型是科学的,但是又是艺术的。编译器怎么看设计模式?披着狼皮的羊而已。
- 438 函数式编程语言
- 439 大部分高级语言是图灵等价,或者图灵完备的。
- 440 解决一个困难的问题(制度化):1使用一个强大的语言 2 为难题写一个事实解释器(跨平台的JVM) 3 自己变成难题的人肉编译器。设计模式就是人肉编译器。设计模式更多是工程范畴。
- 441 模式与Lisp:23种设计模式16种List语言本身已经提供了。
- 442 PaulGraham谈模式:当我在自己程序中用到了模式,表明某个地方出错了,程序的形式应该仅仅反映他所解决的问题,代码其他地方外加的形式都是一个信号,说明我对问题的抽象还不够深,也经常提醒自己在手工完成的事情,本应该通过宏的扩展自动实现。
- 443 工具论本质在于目的大于过程,目的到达。手段无所谓。语言是工具,数据库是工具,服务器是工具,人是为了商业目的服务。不免,有些悲哀。你是生死的工具么?工具思维下越学人越变得像工具,全然失去编程的乐趣。失去了对事物本质的追寻。原理的意义也竟然丧失。
- 444 架构图:栈式和流式。栈式体系软件组成,流式体现软件信息流。
- 445 eclipse架构解析:
核心运行时: Extension Object,IAdaptable,AdapterFactories
核心工作区: 访问文件系统资源Proxy,Bridge,工作区:Composite,遍历资源树:Visitor,跟踪资源变化:Observer,批量修改:Execute Around Method
JavaCore: 从资源到java元素:Adapter,Java元素:Virual Proxy,Java元素树:Composite,类型体系:Objectify Assocations
,跟踪Java元素变化:Observer,收集结果:Builder,抽象语法树:Visitor
SWT: 组合窗体组件:Composite,定义布局:Strategy,响应事件:Observer
JFace: Viewer :连接窗体组件和领域模型:Pluggable Adapter,动作:Command
UI工作台: 懒加载:Virtual Proxy,持久化UI状态:Memento,工作台服务:IAdaptable
- 446 eclispe架构:微内核+插件
- 447 技术选型本质是取舍与权衡过程。对技术细节理解越深,踩坑将越少。每到一个点,就是一个取舍。不能领悟取舍,就不能领域技术精髓。
- 448 HashMap体现了工程取舍思维。
- 449 新问题有新解法,新解法又会带来新问题。
- 450 顺序磁盘比随机内存快?Kafka?
- 451 CAP在工程中的应用
- 452 CAP新解
-
453 分布式系统8条错误假设
-
网络是稳定的。
-
网络传输的延迟是零。
-
网络的带宽是无穷大。
-
网络是安全的。
-
网络的拓扑不会改变。
-
只有一个系统管理员。
-
传输数据的成本为零。
-
整个网络是同构的。
-
network is reliable.
-
Latency is zero.
-
Bandwidth is infinite.
-
The network is secure
-
Topology doesn't change.
-
There is one administrator
-
Transport cost is zero.
-
The network is homogeneous.
- 454 集群和容器的“OSI模型”:
- 456 虚拟机:系统与进程的通用平台。
- 457 虚拟机多样性举例:
- 458 设计一个虚拟机jikesrvm
- 459 高级语言虚拟机的理解:
- 460
- 462 微服务设计模式:(click here)
- 463 CAP
- 464 Gabage Collector
- 465 编译器和解释器架构区别
- 466 Java编译器和解释器模型
- 467 JVM架构【Class Loader Subsystem,Runtime Data Area,Execution Engine】
- 468 Java原理两问:1 Javac HelloWrold.java 发生了什么? 2 Java HelloWorld 发生了什么 ?
- 469 Python解释器
- 470为什么Java没有eval()? 如果加入?在编译时加还是运行时?
- 471 BSF-Bean Scripting Framework Java调用其他语言通用框架。Nashorn和Rhino是JDK官方实现的JS脚本引擎。JSR223。而JPython是非官方实现的脚本引擎。scripting-languages,List_of_JVM_languages,jvm-languages
- 472 开源协议
- 473 Apache Harmony
- 474 Dynamic Runtime Layer Virtual Machine(DRLVM)架构图
- 475 JavaVm 和 DRLVM架构区别是什么?
- 476 MediaWik架构图
- 477 架构:The fundamental organization of a system, embodied in its components, their relationships to each other and the environment, and the principles governing its design and evolution. IEEE定义ISO/IEC_42010 IEEE_1471
- 478 Enterprise architecture framework(企业应用框架):TOGAF等
- 479 TOGAF体系
- 479 计算模型的演进
- 480 理解语言分类(Understanding the Taxonomy of Languages)
从平坦到结构化,
- 481 开源流计算引擎
- 482 Unix代表一种文化,一种现象,一种人类思维,这种文化和禅宗有点像。它代表这一种思想体系,在这种思想体系下诞生的语言,工具,生态无不体现出这种哲学思想。
- 483 计算机领域经典的,思想几乎前人已经思考过了。伟大的思想诞生与哪里?
- 484 历史告诉我们一门学科的巅峰水平在其开始时候,会出现一个集大成者。其他后来者仅仅对其思想进行衍生或者补充。后世能有超越老子思想的人么?Unix编程艺术便是对历史的追溯和基本问题的重新思考。
- 485 It产业技术日新月异,然而在这其中,真正称得上伟大的东西寥寥无几。
- 486 软件世界的爱迪生:Bill Joy:发明了BSD,TCPIp,csh,vi,nfs
- 487 【C语言造就的Unix】是其他后续语言和工具和设计的思想的重要来源。
- 488 摘抄一段话:
伟大思想是什么?计算机体系伟大思想:缓存。 计算机软件伟大发明:Web,Lisp,Hash,Linux等等。
- 489 正则表达式引擎分类和比较:
- 490 Douglas McIlroy经典语录:
"Those types are not "abstract"; they are as real as int and float."
"As a programmer, it is your job to put yourself out of business. What you do today can be automated tomorrow."
"Keep it simple, make it general, and make it intelligible."
"The real hero of programming is the one who writes negative code."
- 491 面向问题抽象。面向底层具体。
- 492 要学习计算机名言。
- 493 DB发展:【From TiDB】
- 494 Java安全策略:(From:Java安全第二版)
- 495 Domain-specific language (noun): 一种专注于某一领域,仅针对部分表达方式的计算机编程语言。
- 496 字节码校验器(定理证明机):
- 497 安全管理器存取控制器关系:
- 498 安全管理器作用域(详见源码)
- 499 理解权限继承体系:
-
500 double-check idiom在jdk源码中在:Policy.getPolicyNoCheck()