“40 year old frontline veteran architect Nien's must-have high concurrency core programming eBooks and other materials for large factories
│ │ │ "Nien Java Interview Dictionary" V107 (the most complete ever).zip
│ │
│ ├óΓé¼┼ôValuable: 3-high architecture of large factories, cases in classic industries
│ │ Industry Case: 12306 billion traffic architecture analysis (the most complete ever).pdf
│ │ Industry Case: 180Wtps Ultra-High Concurrency, High-Traffic Production Case: Byte Wallet Architecture and Solution.pdf
│ │ Industry Case: 21Wqps Billion DAU, How is the small game "Sheep a Sheep" structured? .pdf
│ │ │ Industry Case: 2 big factories 10 billion super large traffic Red Packet Architecture Solution.pdf
│ │ Industry Case: Offsite Multi-Live Practice with 6 Version Iterations of OPPO Caching Layer .pdf
│ │ Industry Case: shopee 70W people online pop-up system, how is the structure? │ │ Industry Case: shopee 70W people online pop-up system, how to structure?
│ │ Industry Case: vivo global mall billion order center, coupon center architecture design and practice-v1.pdf
│ │ Industry Case: Where to Go 100Wqps L2 Cache Component Architecture Case.pdf
│ │ Industry Case: Volkswagen Dianping's Trillion-Dollar Order Bank Split Database and Split Table Solution.pdf
│ │ Industry Case: Ctrip Offsite Multi-Live - MySQL Real-Time Bidirectional (Multi-Directional) Replication Practice.pdf
│ │ Industry Case: Yourzine 100Wqps Transparent Multi-Level Caching Solution (TMC).pdf
│ │ Industry case: an e-commerce platform billion orders DB branch library and table architecture.pdf
│ │ Industry Case: Taobao Double 11 Billion Flow Pentacost Architecture Evolution.pdf
│ │ Industry Case: Redis Cluster Architecture for 20 Million QPS in Zhihu.pdf
│ │ Industry Case: MySQL Cluster Evolution from MMM to MHA+Zebra and MHA+Proxy for Meituan.pdf
│ │ Industry Case: HungryMe's Offsite Multi-Live Architecture Evolution.pdf
│ │ Industry Case: Goldtek Service Unitization Solution and Architecture Practice.pdf
│ │
│ ├óΓé¼╦£Neon 3 High Architecture Core Notes'
│ │ │ │ Architecture Templates for Tier 1 Major Firms.pdf
│ │ │ │ │ Ten years of work, talk about my high availability architecture and system design experience.pdf
│ │ │ │ High-Performance Core Components No. 2: Penetrating the Architecture and Source Code of "Disruptor, the King of Queues" (Disruptor Ruby Book) v2 -release.pdf
│ │ │ │ High-Performance Core Components No. 3: Penetrating the Architecture and Source Code of "Caffeine, the King of Caches" (Caffeine Ruby Book) v2 -release.pdf
│ │ │ │ High-performance core components of the 4: the underlying principles of the time wheel, source code analysis (the most complete ever)-release.pdf
│ │ │ │ High Performance Core Components No. 5: Mpsc Architecture, Source Code Analysis in JCTool-release.pdf
│ │ │
│ └─Java Development Handbook
│ │ Google Java Programming Style Guide.pdf
│ │ Alibaba Java Development Manual-1.0.0 Public Version.pdf
│ │ Alibaba Java Development Manual-1.1.0 Official Version.pdf
│ │ Alibaba Java Development Manual-1.2.0 Upgrade.pdf
│ │ Alibaba Java Development Manual-1.3.0 Ultimate Edition.pdf
│ │ Alibaba Java Development Manual-1.4.0 Exhaustive Edition.pdf
│ │ Alibaba Java Development Manual - Huashan Edition.pdf
│ │ Alibaba Java Development Manual-Taishan Edition.pdf
│ │
│ ├óΓé¼┼ôResume Templates
│ │ 30 sets of selected programmer resume templates.zip
│ │ 58 Sets of Rice Shell Fee Resume Templates.zip
│ │ 800+Sets of Traditional Resume Templates.zip
│ │ Java Senior Engineer Resume Template.docx
│ │ General Resume.docx
│ │
│ └─Algorithmic materials
│ labuladong's Algorithm Cheat Sheet Official Full Version.pdf
│ Data Structures and Algorithms (JAVA Language Edition).pdf
│ Algorithm Brushup LeetCode Chinese version pdf.pdf
│ Introduction to Algorithms.pdf
│
“Chapter 01: The Greatest ___ Thread Pool Learning Feast Ever!
│ 1 Preparation for the Java Thread Pool Learning Feast.mp4
│ 2 Thoroughly Understood: Underlying Principles of Java Threads.mp4
│ 3 Basics: Four Ways to Create a Thread 18.mp4
│ 4 Basics: Life Cycle and Basic Operations of Java Threads.mp4
│ 5 Key Fundamentals: JUC Thread Pool Framework and Shortcut Creation Methods.mp4
│ 6 Key Fundamentals: Standard Thread Pool Creation and Principles.mp4
│ 7 thoroughly understand: big factory what to disable Executors thread pool factory class (Ali specification big bug).mp4
│ 8 Most Powerful Revealed: Thread Count Configuration for IO-Intensive Thread Pools.mp4
│ 9 Revealed: Thread Count Configuration for CPU-Intensive Thread Pools.mp4
│ 10 Thoroughly Understood: Thread Count Configuration for Hybrid Thread Pools.mp4
│ 11 Core Knowledge: ThreadLocal Usage Scenarios.mp4
│ 12 The Best of the Web: Why Modify ThreadLocal Variables with private static final.mp4
│
“Chapter 02: Netty___Core Principles and Underlying Knowledge___Learning Feast
│ 13 Netty Core: NioEventloop (Reactor) Core Principles .mp4
│ 14 Netty Core: NioEventLoop_TaskQueue_Core Principles .mp4
│ 15ChannelConfig Channel Configuration Class .mp4
│ 16 Thoroughly Understanding: Kernel State, User State, Kernel Space, User Space .mp4
│ 17 Thoroughly understand: Java's zero replication (the most powerful interpretation ever) .mp4
│ 18 Thoroughly Understood: Netty's Zero Replication (The Toughest Explanation Ever) .mp4
│
“Chapter 03: Netty_ByteBuf__ Learning Feast
│ 19 Fundamentals of ByteBuf: Template Patterns, Reference Counting, Core Classes, etc.mp4
│ 20 Thoroughly Understood: Automatic Creation of ByteBuf.mp4
│ 21 Thoroughly Understood: Automatic Release of ByteBuf.mp4
│ 22 Learning Feast: UnpooledHeapByteBuf Core Principles of Unpooled Heap Memory.mp4
│ 23 Learning Feast: NIO's DirectByteBuffer Core Principles.mp4
│ 24 Learning Feast: Core Principles of UnpooledDirectByteBuf Unpooled Direct Memory.mp4
│ 25 Learning Feast: Core Principles of Direct Memory Pooled by PooledDirectByteBuf.mp4
│
“Chapter 04: A Million IMs in Action - CrazyIM Session Management
│ 26 million user scenarios, channel how to manage (on).mp4
│ 27 million users scenario, channel how to manage (in).mp4
│ 28 million users scenario, channel how to manage (next).mp4
│
“Chapter 05: Java Essentials - Netty High Concurrency Soul Programming
│ 29Netty Soul Experiment : Local_100W_Connection_Ultra_High_Concurrency_Experiment,Instantly_Improve_Java_Internal_Power.mp4
│
Chapter 06: The Nine Suns: A Thorough Revealing of the Underlying Principles of NIO and Selector
│ 30 thoroughly understand: select, poll the core principles of the underlying system calls.mp4
│ 31 Thoroughly Understanding: Core Principles of the epoll Underlying System Calls.mp4
│ 32 Kernel Demystified: Linux's ET High Speed Mode and Netty's High Speed Selector.mp4
│ 33 Thoroughly Demystified: Core Principles of IO Events.mp4
│ 34 Thoroughly Demystified: SelectionKey Core Principles.mp4
│ 35 thoroughly understand: Selector (Selector) core principles.mp4
│ 36 Strongest Revealed: Selector.open() The underlying principle of selector open.mp4
│ 37 strongest reveal: Selector.register () the underlying principle of registration.mp4
│ 38 The Most Powerful Revealed: The Underlying Principles of Selector.select() Event Queries.mp4
│ 39 The most powerful reveal: Selector.wakeup() Wake up the underlying principles.mp4
│ Nine Suns: A Thorough Reveal of the Underlying Principles of NIO, Selector .pdf
│ Chapter 6: The Nine Suns: A Thorough Reveal of the Underlying Principles of NIO, Selector.pdf
│
‘Chapter 07: Underlying Interpretation: Deciphering the Core Difficulties and Killing Foreign Authorities'
│ 40 Revealed from the bottom: Thread.sleep is not a CPU hog.mp4
│ 41 Revealed from the Bottom: The Nature and Fundamental Sources of Threaded State.mp4
│
“Chapter 08: Netty's Big Hands-On: Starting Billion Traffic CrazyIM Development from 0 to 1
│ 42_0.4 minor version introduction.mp4
│ 43 Netty Development Essentials: EmbeddedChannel EmbeddedChannel.mp4
│ 44 Basics: ChannelPipeline Pipeline.mp4
│ 45 Using Basic Components: ChannelInboundHandler Inbound Handler.mp4
│ 46 Basic Practical: Pipeline Inbound Processing Flow.mp4
│ 47 Basic Practical: Pipeline Outbound Processing Flow.mp4
│ 48 Core Practical: Inbound JSON Message Processing.mp4
│ 49 Core Practical: Outbound Processing of JSON Messages.mp4
│ 50 Basic Hands-on: Using the Potobuf Protocol.mp4
│ 51 Core Practical: Inbound Processing Flow of Potobuf Packets.mp4
│ 52 Core Practical: Outbound Processing Flow of Protobuf Messages.mp4
│ 53 Architecture Design: Three Major Architectures for Monolithic IM.mp4
│ 54 Monolithic IM Fundamentals in Action: Command Collector 10.mp4
│ 55 Monolithic IM Basics in Action: Message Constructors.mp4
│ 56 Single IM Basics in Action: Message Sender.mp4
│ 57 Monolithic IM Fundamentals in Action: Response Processor.mp4
│ 58 Single IM Core Practice: Server-side Login Processing.mp4
│ 59 Netty Advanced Programming: isolation of server-side business processing from IO processing.mp4
│ 60 Monolithic IM Core Programming: Server Side Session Management.mp4
│ 61 Single IM Core Programming: Single Chat - End-to-End Chat Forwarding.mp4
│ 62 Monolithic IM Core Programming: End-to-End Heartbeat Processing.mp4
│ 63 Distributed High-Level Hands-On: Billion High Concurrency IM Architecture.mp4
│ 64 Distributed Environment Chapter: Distributed Development Environment Setup.mp4
│ 65 Distributed High-Level Hands-On: Command Services for Netty Nodes.mp4
│ 66 Distributed High-Level Hands-On: Netty Node Registration and Discovery.mp4
│ 67 Distributed High-Level Hands-On: Load Balancing for Netty Nodes.mp4
│ 68 Distributed High-Level Hands-On: Routing and Forwarding between Netty Nodes.mp4
│ Chapter 8_Netty Big Hands-On: Starting Billion Traffic CrazyIM Development from 0 to 1 .txt
│
Chapter 09: The Strongest Ever: Billion Flow Architecture Theory + 10WQPS Real Practice
│ │ 69 Opening: Theory of Billion Flow Architecture + The Need for 10WQPS Practice.mp4
│ │ 70 Q&A: Billion users ultra-high concurrency experience, so important, how to get it? .mp4
│ │ 71 the strongest ever: continuous iteration, combed out a value of 10W billion traffic architecture knowledge map.mp4
│ │ 72 Basic Skills: How can Java people write good documentation and draw good diagrams? .mp4
│ │ 7.3 Billion Architecture Core: Business Decoupling of _ Functional Separation.mp4
│ │ 7.4 Billion Architecture Core: Business Decoupling_System Layering.mp4
│ │ 7.5 Billion Architecture Core: System Layering_Billion Traffic Layered Filtering Model.mp4
│ │ 7.6 Billion Architecture Core: System Layering_Principle of Idempotency Design.mp4
│ │ 7.7 Billion Architecture Core: Offsite Multi-Live_Unitized Vertical Split.mp4
│ │ 7.8 Billion Architecture Core: Traffic Architecture - Low Concurrency Systems, How to Learn High Concurrency Lessons.mp4
│ │ 7.9 Billion Architecture Core: Traffic Architecture - Traffic Estimation in Billion User Volume Scenarios.mp4
│ │ 8 Billion Architecture Core: Traffic Architecture - Traffic Architecture in Billion User Volume Scenarios.mp4
│ │ 8.1 Billion Architecture Core: Storage Architecture - Architecture Design for Billion Library Tables.mp4
│ │ 8.2 Billion Architecture Core: Storage Architecture - 10 Billion Library Table Architecture Design.mp4
│ │ 8.3 Billion Architecture Core: Storage Architecture - Heterogeneous Querying of Tens of Billions of Data.mp4
│ │ 8.4 Billion Architecture Hands-on: Business Architecture, Traffic Architecture, Data Architecture of Billion Seconds System.mp4
│ │ 8.5 Billion Architecture Practice: Service Layer to Support Highly Available, Highly Concurrent Architecture for Billions of Users.mp4
│ │ 86 Practical Chapter: a key to deal with the headache of cumbersome distributed, microservices, high concurrency development environment.mp4
│ │ 8.7 Billion Architecture Hands-on: Functional Bodies that Kill Learning Cases.mp4
│ │ 8.8 Billion Seconds Practical Practice of Service Layer: Registration Center Theory & Practice.mp4
│ │ 8.9 Billion Seconds Practical Practice of Service Layer: Configuration Center Theory & Practice.mp4
│ │ Service Layer of 9 Billion Seconds Hands-on: Functions and Realization of Inventory Service.mp4
│ │ 9.1 Billion Seconds Hands-on Service Layer: Inventory Service - Seconds Exposure.mp4
│ │ 9.2 Billion Seconds Practical Practice of Service Layer: Functions and Realization of Seconds Service.mp4
│ │ 93 combat chapter: a key to deal with the headache of cumbersome nginx, lua development, testing environment.mp4
│ │ 94 Billion Seconds Hands-on Service Layer: redis_lua Scripts for Token Issuance, Inventory Pre-Decrease.mp4
│ │ 95 Billion Seconds Hands-on Service Layer: Traffic Shaving via rocketmq.mp4
│ │ 96 High Concurrency Core Knowledge: In-depth Decryption of ZK+SnowFlake Algorithm from the Perspective of Bitwise Arithmetic.mp4
│ │ 97 High Concurrency Basics: Handwriting a Distributed Lock Based on Jedis+Lua Scripts.mp4
│ │ 98 High Concurrency Advanced Practice: Handwriting a Redis Segmented Lock for Ultra-High Concurrency Scenarios.mp4
│ │ 99 Big Factory Interview Difficulties: High Concurrency Scenario, Mysql Hot Row Updates, How Should I Solve It? .mp4
│ │ 10 Billion Seconds Practical Practice of Service Layer: Practical Practice of Exporting Microservice Gateway.mp4
│ │ 101 High Concurrency Focus: a minute to understand, why limiting flow is so important! .mp4
│ │ 102 High Concurrency Limiting: Principles, Defects, and Difficulties of its Java Implementation of Counter Limiting.mp4
│ │ 103 High Concurrency Limiting: Principles, Issues, and Difficulties of Java Implementation of Leaky Bucket Limiting.mp4
│ │ 104 High Concurrency Flow Limitation: Principles, Issues, and Difficulties of Token Bucket's Java Implementation.mp4
│ │ 105 High Concurrency Flow Limiting: Explaining Nginx Leaky Bucket Flow Limiting Directives, Flow Limiting Key Extraction Techniques.mp4
│ │ 106 The absolute strongest ever: Nginx leaky bucket flow limiting burst, nodelay parameter details.mp4
│ │ 107 Distributed Flow Limiting: Simulating Jingdong's Implementation of Redis+Lua Flow Limiting Component.mp4
│ │ 108 Access Layer Distributed Flow Limiting: Nginx+Lua, Redis+Lua Distributed Token Flow Limiting in Action.mp4
│ │ 109 billion seconds of practical exercises _ access layer: Nginx reverse proxy _ load balancing _ core principles and practice.mp4
│ │ 11 billion seconds of practice_Access Layer: separation of dynamic and static, static content services through Nginx.mp4
│ │ 111 Billion Seconds Hands-on_Access Layer: How to_10x_100x_Improve_Read_Concurrency_Throughput.mp4
│ │ 112 Billion Seconds Hands-on_Access_Layer: How_to_10x_100x_Improve_Write_Concurrency_Throughput.mp4
│ │ 113 Billion Seconds Practical_Access_Layer: _Flow_Limiting_Architecture_and_Flow_Limiting_Practice_for_Highly_Concurrent_Systems.mp4
│ │
│ ├─Code repository & environment variables & local domain configuration instructions
│ │ Code Repository & Environment Variables & Local Domain Configuration Instructions.pdf
│ │
│ └─Chapter 9: the strongest ever: billion flow architecture theory + 10WQPS real knife practice
│ Billion Dollar Architecture Core 1: Architecture Decoupling Functional Separation, System Hierarchy, Unitization .pdf
│ Billion Architecture Core 2: Traffic Architecture from 10W to Billion Users .pdf
│ Billion Architecture Core 3: Data Architecture from Billions to Tens of Billions of Records .pdf
│ Hands-on Billion User Architecture: Business Architecture, Traffic Architecture, and Data Architecture for Billion Seconds System .pdf
│ Hands-on Billion User Architecture: Highly Available, Highly Concurrent Access Layer for Billion Seconds Systems .pdf
│ Hands-on Billion User Architecture: Service Layer for High Availability and Concurrency of Billion Seconds System .pdf
│ Billion Seconds Hands-on Service Layer: How mysql hot data improves the performance of updates (I) .pdf
│ Billion Seconds Hands-On Service Layer: One-Click Fix for Cumbersome Distributed Development Environments .pdf
│ Billion Seconds Hands-on Service Layer: Distributed Snowflake Algorithm for ID Generation .pdf
│ Service Layer: Inventory Service for Billions of Seconds Practice .pdf
│ Billions of seconds of practical operation of the service layer: registration center practice .pdf
│ Service Layer of Billion Seconds Practice: Seconds Service .pdf
│ Service Layer: Configuration Center for Billions of Seconds Hands-on .pdf
│ Billions of seconds of hands-on: one click to fix the Nginx + Lua development environment .pdf
│
“Chapter 10: 10W QPS for Real___ and Handwritten Distributed Testing Tools Based on ZK+Netty
│ │ 105.How to carry out high concurrency practice: 10WQPS real knife points.mp4
│ │ 106.10 Logical and physical architecture between hosts of WQPS real knife.mp4
│ │ 107.The Essentials of Buying AliCloud Hosting and ___Available Zones.mp4
│ │ 108.Ultra-High Concurrency Scenario_Setting the Number of Local File Handles and the Number of Global File Handles.mp4
│ │ 109. Installation of basic components with the help of shell scripts __ Extreme.mp4
│ │ 110.Service Tier Deployment__ and High Concurrency Configuration of Nginx for Access Tier.mp4
│ │ 111.High Concurrency Scenarios__SLB Usage Practices.mp4
│ │ 112. ZK+Netty-based stress test practice, breaking 10WQPS.mp4
│ │ 113.Handwritten Distributed Testing Tool Based on ZOOKeeper+Netty: System Architecture Design.mp4
│ │ 114.Handwritten Distributed Testing Tool Based on ZOOKeeper+Netty: Design and Implementation of Work Nodes.mp4
│ │ 115.Handwritten Distributed Testing Tool Based on ZOOKeeper+Netty: Design and Implementation of Master Node.mp4
│ │ Chapter 10: 10W QPS real knife practice __ and handwritten distributed test tool based on ZK + Netty .pdf
│ │
│ └─【Lecture Notes】Chapter 10: 10W QPS real knife practice
│ Chapter 10: 10W QPS Real Knife_and_Handwritten_Distributed_Testing_Tool_Based_on_ZK+Netty.pdf
│
‘Chapter 11: 5 Minutes to Make Your Resume Shine, Be Loved and Turned Around 100%
│ Lesson 116. Making Your Resume Shine ___ How to Make Professional Skills ___ Charming? .mp4
│ Lesson 117.Make Your Resume ___Shine___ of ___How to Make Project Experience ___Highly Compelling? .mp4
│ Lesson 118.Make Your Resume Shine ____ 10 Million Distributed IM Messaging Middleware__How to reflect it on your resume.mp4
│ Lesson 119.Make your resume shine ____10W_QPS Ultra-High Concurrency Spike Hands-On Project, how to reflect it on your resume? .mp4
│
“Chapter 12: Beating the Interviewer: Thoroughly Understanding the Principles of Distributed Transactions, as well as seata's AT, TCC Principles and Practical Exercises
│ 120.Distributed Transaction Theory: Scenarios for Using Distributed Transactions.mp4
│ 121. Distributed Transaction Theory: Sorting Out ___ Distributed Transaction's Myriad Classifications in One Chart.mp4
│ 122.Distributed Transaction Theory: Mastering the __XA Model and 2PC Protocol in 2 Minutes.mp4
│ 123. Distributed Transaction Theory: Mastering the __TCC Protocol in 2 Minutes.mp4
│ 124. Distributed Transaction Theory: 2 Minutes to Understand the __SeataAT Pattern.mp4
│ 125.Distributed Transaction Hands-on: 10WQPS Seconds of Hands-on AT Distributed Transaction Architecture.mp4
│ 126.Distributed Transaction Hands-on: Seata_TC Configuration and Startup.mp4
│ 127.Distributed Transaction Hands-on: TM Inventory Service Development and Distributed Transaction Configuration.mp4
│ 128.Distributed Transaction Hands-on: TM Order Service Development and Distributed Transaction Configuration.mp4
│ 129.Distributed Transaction Hands-on: Development of RM Seconds Service, and Phase 2 Commit and Rollback Testing.mp4
│ 130.seata schematic diagrams: using three diagrams to thoroughly explain the __AT model distributed transaction execution process.mp4
│ 131.seata schema illustration: AT Branch Transaction__Stage 1 execution flow.mp4
│ 132. breakpoint view of seata process: breakpoint view of environment preparation and microservice preparation before Seata_AT execution process.mp4
│ 133. breakpoint observation of seata process: view TC global session data after TM opens global transaction.mp4
│ 134. Breakpoint observation of the seata process: viewing the undo_log rollback log after RM opens a branch transaction.mp4
│ 135. Breakpoints in the seata process: viewing the commit process for a phase 2 RM branch transaction.mp4
│ 136. Breakpoint observation of the seata process: Viewing the rollback process of a phase 2 RM branch transaction.mp4
│ 137.TCC Distributed Transaction Hands-on: TCC Distributed Transaction Architecture for 10WQPS Seconds.mp4
│ 138.TCC Distributed Transaction Hands-on: TCC Interface Development and Configuration for Inventory Services.mp4
│ 139.TCC Distributed Transaction Hands-on: TCC Interface Development and Configuration for Order Services.mp4
│ 140.TCC Distributed Transaction Hands-on: TCC Transaction Opening for Seconds Service, and Second Stage Commit and Rollback Testing.mp4
│ 141.TCC Distributed Transactions in Practice: Idempotency Issues, Empty Rollback Issues, and Anti-Suspension Issues for TCC Distributed Transactions.mp4
│ 142. Resume optimization: 10WQPS real knife hands-on projects, plus TCC distributed transactions hands-on content.mp4
│ nacos_config_export_Configuration_for_distributed_transaction_video_please_import_nacos .zip
│
Chapter 13: The Best Ever: Starting Netty IM from 0, a 40-year-old architect explains it in detail, and the principles and essence are everywhere in the real world.
│ Chapter 13: 0 Best Ever: How to go from 0 to 1 for an IM Hands-On? .mp4
│ Chapter 13:1 How to do IM hands-on? What are the dependencies that need to be addressed to handcraft an IM from 0 to 1? .mp4
│ Chapter 13: 2 How to Architect and Design IM, using IM as a sample, video demystifying the basic set of architecture.mp4
│ Chapter 13: 3 Software Architecture Hands-on 1: Experiencing the Principle of High Cohesion + Low Coupling, and Rationally Designing the Modules of an IM System.mp4
│ Chapter 13:4 Software Architecture Practice 2: Experiencing the Separation of Variation and Invariance Principle, and Rationally Designing the Class Structure of an IM System.mp4
│ Chapter 13: 5-Handed IM Client 1: Design, Implementation, and Verification of Login Command Collector.mp4
│ Chapter 13: 6-handed IM Client 2: Design, Implementation, and Verification of Menu Collector + Command Control Classes.mp4
│ Chapter 13: 7 Hand Jerking IM Clients 3: The Most Detailed Explanation Ever, Session Class Design, Implementation, and Validation for Clients.mp4
│ Chapter 13: 8-Handed IM Client 4: Design, Development, and Verification of a Decoding Process Based on the protobuf+headcontent Protocol.mp4
│ Chapter 13: 9 Software Architecture Hands-On 3: Experiencing the Separation of Change and Invariance Principle Again, IM System Converter Message Conversion Module Architecture, Design, Development, and Validation.mp4
│ Chapter 13: 10 Hand Jerking IM Server 1: Design, Implementation, and Verification of Server-Side Session Management.mp4
│ Chapter 13: 11 hand-jerking IM server-side 2: based on springboot + netty, the implementation of the server-side of the high-performance communication framework.mp4
│ Chapter 13: 12 Hands-On IM Server 3: Design, Development, and Verification of Login Response Processing Flow.mp4
│ Chapter 13: 13 Hand Jerking IM Client 5: Based on springboot+netty, realizing a high-performance running framework for the client.mp4
│ Chapter 13: 14 Hand Jerking IM Client 6: Asynchronous Callback Flow for Successful Connection, Design, Implementation, and Validation of Login Requests in the Client's Communication Framework.mp4
│ Chapter 13: 15 Hands-On IM Client 7: Design, Implementation, and Validation of the Client's Login Response.mp4
│ Chapter 13: 16 Netty Exception Handling Hands-On: Principles of Exception Propagation Flow in Pipelines, Design, and Verification of Exception Handlers.mp4
│ Chapter 13: 17 Hand Jerking IM Server 4: Design, Implementation of Chat Message Forwarding on the Server Side.mp4
│ Chapter 13: 18 Hand Jerking IM Clients 8: Designing and Implementing the Client's Chat Message Processor.mp4
│ Chapter 13: 19 Hand Jerking IM Client 9: Designing and Implementing the Entire Process of Collecting, Converting, and Sending Chat Messages on the Client.mp4
│ Chapter 13: 20 Hand Jerking IM Server 5: Designing, Implementing Heartbeat Detection on the Server Side.mp4
│ Chapter 13: 21 Hand Jerking IM Clients 10: Client Heartbeat Send Design, Implementation.mp4
│
Chapter 14: Sweeping the entire network, elasticsearch underlying principles and high availability architecture practice, 40-year-old architect detailed interpretation, everywhere through the principles and essence of the
│ │ Chapter 14: 1. High Availability Deployment Hands-On 1: How is the Goal of High Availability Measured? elasticsearch How to Architect for High Availability? .mp4
│ │ Chapter 14: 2. High Availability Deployment Hands-on 2: Introducing the Core Concepts of ES with a 30-node cluster as an example.mp4
│ │ Chapter 14: 3. High Availability Deployment Hands-on 3: Introducing ES cluster roles with a 30-node cluster as an example.mp4
│ │ Chapter 14: 4. High Availability Deployment Hands-on 4: How to Configure Node Roles for ES with a 30-Node Cluster.mp4
│ │ Chapter 14: 5. High Availability Deployment Hands-on 5: Deployment Architecture for Small ES Clusters, Medium ES Clusters, Large ES Clusters, and Very Large ES Clusters.mp4
│ │ Chapter 14: 6. High Availability Deployment Hands-on 6: Preparing a Virtual Machine Environment for High Availability Hands-on, a docker Environment, and Understanding the Underlying Principles of docker.mp4
│ │ Chapter 14: 7. Highly Available Deployment Practices 7: Deployment Practices for a Small Highly Available es Cluster (3 master+datanode, 2 coordinate, 1 haproxy).mp4
│ │ Chapter 14: 8. High Availability Deployment Hands-on 8: Checking the Health, Memory Status, and CPU Load Status of Cluster Node node, Cluster Index Index via kibana.mp4
│ │ Chapter 14: 9. ES Industrial Use #1: Use of the IK Segmenter and Why Separate Segmenters are Used: Minimum Segmentation for Indexing, Maximum Segmentation for Searching.mp4
│ │ Chapter 14: 10. ES Industrial Usage 2: How to Create Indexes, Modify Indexes, and Use Indexes in Industrial Scenarios.mp4
│ │ Chapter 14: 11. ES Industrial Usage 3: CRUD Operations on Documents, and Major Combinations of Query Conditions.mp4
│ │ Chapter 14: 12. ES Industrial Use No. 4: Principles of ES Dynamic Templates, and How to Use Dynamic Templates in the ELK Logging Platform? .mp4
│ │ Chapter 14: 13. ES Industrial Use #5: Configuration Options for Index Fields, ES Data Types, and Naming Convention for ES Indexes and Fields.mp4
│ │ Chapter 14: 14. ES Industrial Grade Usage 6: SpringBoot Project Access to ES via the Official elasticsearch-Rest-Client Client.mp4
│ │ Chapter 14: 15. ES Industrial Use 7: Explaining the Highly Available Configuration of masternode in Industrial Scenarios.mp4
│ │ Chapter 14: 16. ES Industrial Usage 8: Explaining the Highly Available Configuration of datanode in Industrial Scenarios.mp4
│ │ Chapter 14: 17. ES Industrial Usage 9: Explaining the Highly Available Configuration of the coodinatenode in Industrial Scenarios.mp4
│ │ Chapter 14: 18. ES Industrial Use 10: Explaining the Overall Configuration of a Small Highly Available ES Cluster.mp4
│ │ Chapter 14: 19. ES industrial use of 11: the underlying max_map_count principle, and deployment process vm.max_map_count number is not enough problem solution.mp4
│ │ Chapter 14: 20. ES High-Performance Principles #1: Storage Architecture for Elasticsearch and Lucene.mp4
│ │ Chapter 14: 21. ES High-Performance Principles 2: Why Elasticsearch's Inverted Tables Are Faster Than myql's B+Tree Queries 1: Getting to the Bottom of mysql's B+Tree Principles.mp4
│ │ Chapter 14: 22. ES High Performance Principles #2: Why Elasticsearch's Inverted Tables Are Faster Than myql's B+Tree Queries #2: Getting to the Bottom of TermIndex's Core Advantages.mp4
│ │ Chapter 14: 23. ES High Performance Principles No. 2: Why Elasticsearch's Inverted Tables are Faster than myql's B+ Tree Queries No. 3: Trie Trees, FST Directed acyclic graphs.mp4
│ │ Chapter 14: 24. ES High Availability Principle 1: ES Cluster Registration Discovery, Master Election, Fault Detection Mechanism.mp4
│ │ Chapter 14: 25. ES High Availability Principle No. 2: Consistency Assurance Scheme for ES Cluster Metadata Updates.mp4
│ │ Chapter 14: 26. ES High Availability Principles of 3: ES, ZK Brainsplit (brainsplit) principles and solutions.mp4
│ │ Chapter 14: 27. ES High Availability Principle No. 4: Master has too many PendingTasks. .mp4
│ │ Chapter 14: 28. ES High Availability Principle No. 5: In-depth Explanation, Two Stages of an ES Search query+fetch.mp4
│ │ Chapter 14: 29. ES High Availability Principle No. 6: ES Guarantees High Availability of Data Writes via Translog to Avoid Loss of Writes in the Event of Power Down.mp4
│ │ Chapter 14: 30. ES High Availability Principle No. 7: If the refresh parameter is adjusted to avoid overloading the datanode when massively scrubbing data to build an index.mp4
│ │ Chapter 14: 31. ES High Availability Principle No. 8: Principles of the flush operation, and how to recover index data after a failure restart.mp4
│ │ Chapter 14: 32. ES High Availability Principle No. 9: Why Industrial Scenarios Require Regular Forcemerge and How to Regularly Forcemerge.mp4
│ │ Chapter 14: 33.ES High Availability Principle No. 10: How does a DataNode safeguard against data loss when switching between primary and secondary? .mp4
│ │ Chapter 14: 34. ES High Availability Principle No. 11: How to Avoid Concurrent Modification of Documents, Resulting in Data Consistency Problems? .mp4
│ │ Chapter 14: 35. ES High Availability Principles No. 12: Rapid Recovery Scenario for DataNode Memory Overflow No. 1: Thoroughly Understanding the Caching Architecture of elasticsearch (lucene).mp4
│ │ Chapter 14: 36.ES Principles of High Availability 12: Rapid Recovery Scenario for DataNode Memory Overflow 2: Thoroughly Understanding the Underlying Principles of the Docvalues Positive Row Structure.mp4
│ │ Chapter 14: 37.ES Principles of High Availability 12: Rapid Recovery Scenarios for DataNode Memory Overflow 3: Thoroughly Understanding the Underlying Principles of the fielddata Positive Row Structure.mp4
│ │ Chapter 14: 38. ES High Availability Principles No. 12: Fast Recovery Scenarios for DataNode Memory Overflows No. 4: The Essentials of Elasticsearch Memory Configuration.mp4
│ │ Chapter 14: 39. ES High Availability Principle No. 12: Fast Recovery Scenario for DataNode Memory Overflow No. 5: How to Recover Quickly from an OOM in Elasticsearch? .mp4
│ │ Chapter 14: 40. ES High Availability Principle No. 13: Illustrating the DataNode Failover Process for ES.mp4
│ │ Chapter 14: Overview: Sweeping the entire network elasticsearch underlying principles and high-availability architecture practice: 40-year-old architects detailed interpretation, everywhere through the principles and essence.mp4
│ │ 横扫全网ES配套讲义1：高可用elasticsearch搭建和使用手册v3-1v2.pdf
│ │ Sweeping the entire network ES supporting handouts 2: elasticsearch underlying principles and principles of high-availability architecture v2.pdf
│ │
│ └─3G-middleware
│ elasticsearch-with-ik-icu.tar
│ haproxy.tar
│ kibana.tar
│ elasticsearch7.zip
│
—Chapter 15: Companion Video to Springcloudnginx High Concurrency Core Programming
│ │ Chapter 15: 1. SpringCloud Nginx High Concurrency Core Programming __ Purpose of Recording the Companion Video __ Main Content __ Core Values.mp4
│ │ Chapter 15: 2. Seconds Hands-on __ and __ springcloud Nginx High Concurrency Hands-on for __ Environment Variables __hosts Preparation.mp4
│ │ Chapter 15: Middleware Involved in 3.crazy-SpringCloud Scaffolding Development.mp4
│ │ Chapter 15: 4. Example Demo: RestTemplate Remote Call and Feign Remote Call.mp4
│ │ Chapter 15: 5. Example Demonstration: Packaging and Deployment of springboot Applications in Scaffolding with Eureka.mp4
│ │
│ ├─Code repository & environment variables & local domain configuration instructions
│ │ Code Repository & Environment Variables & Local Domain Configuration Instructions.pdf
│ │
│ └─Supplementary books (Volume 3)
│ Companion Book (Volume 3): Springcloud Nginx High Concurrency Core Programming - Crazy Creators Circle Java Architecture Class - Special eBook v4.pdf
│
Chapter 16: Sunflower_Precious_Dictionary (High-Performance Secrets)
│ │ Chapter 16: 01. Sunflower Book (High Performance Secrets): Thoroughly Uncovering Zero-Copy, mmap Memory Mapping, PageCache, MMU, FileCache Refresh, Kernel-State, User-State, Kernel-Space, User-Space.mp4
│ │ Chapter 16: 02. Illustration of Zero Copy: 4 Data Copies, 4 Mode Switches during IO of a Traditional C Program.mp4
│ │ Chapter 16: 03. Illustrating Zero Copy: 6 Data Copies, 4 Mode Switches During IO of a Traditional JAVA Program_v2.mp4
│ │ Chapter 16: 04. Illustrating Zero-Copy: A Meticulous Explanation of the _Core Process of Zero-Copying with DirectBuffer_v2.mp4
│ │ Chapter 16: 05. Illustrating Zero Copy: a detailed explanation of the core process of _zero copying using mmap+write_v2.mp4
│ │ Chapter 16: 06. Illustrating Zero Copy: a detailed explanation of the core process of _zero copying with sendfile_v2.mp4
│ │ Chapter 16: 07. Core Hands-on 1: A Crucial NIO File Transfer Basic Hands-on: Background, Critical Importance, Source Code Repository, Dependent Knowledge_v2.mp4
│ │ Chapter 16: 08. Core Hands-on 1: Schema Design, Half-Packet Problem Analysis, Message Decoding Process Analysis for NIO File Transfer Basic Hands-on_v2.mp4
│ │ Chapter 16: 09. Core Practical 1: Requirements Analysis, Process Analysis of NIO File Transfer Basic Practical_v2.mp4
│ │ Chapter 16: 10. Core Practical 1: NIO File Transfer Basic Practical - Client_File_Send_Function_Code_Implementation_v2.mp4
│ │ Chapter 16: 11. Core Practical 1: NIO File Transfer Basic Practical - Server_File_Receive_Function_Code_Implementation_v2.mp4
│ │ Chapter 16: 12. Hardcore Knowledge: An Overview of Operating Systems from a Java Architect's Perspective - Perspectives, Characteristics, Content_v2.mp4
│ │ Chapter 16: 13. CPU from the Java Architect's Perspective: User and Kernel States of the CPU, User and Kernel Modes of Processes_v2.mp4
│ │ Chapter 16: 14. Explained from a Java Architect's Perspective: Operating System Instruction Classification_v2.mp4
│ │ Chapter 16: 15. Explained from a Java Architect's Perspective: Linux's Virtual Address Space for Processes, task_struct(PCB Process Control Block)_v2.mp4
│ │ Chapter 16: 16. Interpretation from the perspective of a Java architect: the user state & kernel state and the user space, kernel space of the subtle relationship between_v2.mp4
│ │ Chapter 16: 17. Explained from a Java Architect's Perspective: The Processing Flow of System Calls_v2.mp4
│ │ Chapter 16: 18. Explained from the Kernel Engineer's Perspective: Interrupt Handling Flow for Linux System Calls_v2.mp4
│ │ Chapter 16: 19. Architect's Perspective Explained: The Root Cause of Time Consuming Java System Calls_v2.mp4
│ │ Chapter 16: 20. Architect's Perspective Explained: The Relationship Between Java Threads and Operating System Threads_v2.mp4
│ │ Chapter 16: 21. Architect's Perspective Explained: Memory Layout in User Space and Kernel Space in VMM_v2.mp4
│ │ Chapter 16: 22. Architect's Perspective Explained: Core Principles of VMM Memory Paging Management_v2.mp4
│ │ Chapter 16: 23. Explained from the Architect's Perspective: Core Principles of VMM Multi-Level Memory Paging Management, Linux's 3-Level Paging Mechanism_v2.mp4
│ │ Chapter 16: 24. Architect's Perspective Explained: MMU Responsibilities, Virtual to Physical Address Translation Process_v2.mp4
│ │ Chapter 16: 25. Explained from the Architect's Perspective: Origins of Segmentation, Real Patterns, and Protected Patterns_v2.mp4
│ │ Chapter 16: 26. Architect's Perspective Explained: Address Translation Principles for IA32_v2.mp4
│ │ Chapter 16: 27. Architect's Perspective Explained: Mapping Relationships Between Physical and Virtual Addresses_v2.mp4
│ │ Chapter 16: 28. Explained from the Architect's Perspective: Illustrating Physical Memory Allocation kmalloc and vmalloc Kernel Functions_v2.mp4
│ │ Chapter 16: 29. Explained from an Architect's Perspective: The Core Process of Java Calling the malloc Function to Allocate Direct Memory_v2.mp4
│ │ Chapter 16: 30. Architect's Perspective: Uncovering Data Consistency of the "Kernel Page Table" Copies in the Process Page Table (Copy-on-Read)_v2.mp4
│ │ Chapter 16: 31. Architect's Perspective Explained: MVCC Multi-Version Concurrency Control Protocol_v2.mp4
│ │ Chapter 16: 32. openJdk Source Code Interpretation: 6 CPU Copy Processes for socket-IO using Java-NIO Heap Memory_v2.mp4
│ │ Chapter 16: 33. openJdk Source Code Interpretation: Source Code Analysis of 4 CPU Copies of socket-IO using Java-NIO Direct Memory_v2.mp4
│ │ Chapter 16: 34. openJdk Source Code Interpretation: Source Code Analysis of DirectByteBuffer Creation and Use_v2.mp4
│ │ Chapter 16: 35. openJdk Source Code Interpretation: Active Recycling Mechanism for DirectByteBuffer Memory Recycling_v2.mp4
│ │ Chapter 16: 36. openJdk Source Code Interpretation: Passive Recycling Mechanism for DirectByteBuffer Memory Recycling_v2.mp4
│ │ Chapter 16: 37. Java Core Knowledge: The Four Reference Types in Java, Use Cases, Usage Scenarios, and Memory Leaks That Can Result_v2.mp4
│ │ Chapter 16: 38. Unraveling the Historical Conundrum: A Bizarre Memory Leak Due to the Use of DirectBuffer_v2.mp4
│ │ Chapter 16: 39. JVM core knowledge: analogous to a chef making cassoulet, image the whole process of YGC and FullGC (core interview questions)_v2.mp4
│ │ Chapter 16: 40. JVM Core Knowledge: The Three JVM GC Algorithms_Marker Copy_Marker Clear_Marker Compression (Core Interview Questions)_v2.mp4
│ │ Chapter 16: 41. JVM Core Knowledge: Illustrating the JVM's Three-Color Marking Algorithm (Core Interview Questions)_v2.mp4
│ │ Chapter 16: 42. JVM Core Knowledge: Classification and Comparison of Common JVM Garbage Collectors, Introduction to CMS, G1_v2.mp4
│ │ Chapter 16: 43. JVM Core Knowledge: JAVA8's Three Major Garbage Collector Configurations (Core Interview Questions)_v2.mp4
│ │ Chapter 16: 44. JVM Core Knowledge: Frequency and Timing of MinorGC and FullGC (Core Interview Questions)_v2.mp4
│ │ Chapter 16: 45. Answering the Historical Conundrum: The Root Cause and Solution to DirectBuffer's Bizarre Memory Leak_v2.mp4
│ │ Chapter 16: 46. Java Core Knowledge: Common Configurations, Usage Scenarios, and Common Problems with DirectBuffer_v2.mp4
│ │ Chapter 16: 47. Java Core Knowledge: Illustrating the Principle of Mmap and the Process of Sending Files with Zero Copies of Mmap+write_v2.mp4
│ │ Chapter 16: 48. Java Basics: Explaining the Three Mapping Methods of Mmap and Using Practical_v2.mp4
│ │ Chapter 16: 49. openJdk Source Code Interpretation: mmap Memory Sharing Practical_and_Source_Analysis_of_MappedByteBuffer_Creation_and_Cleaning_v2.mp4
│ │ Chapter 16: 50. Core Hands-on 2: mmap+write File Sending Requirements Analysis, Process Analysis, Code Implementation_v2.mp4
│ │ Chapter 16: 51. Core Hands-on 2: mmap+write File Receiving Requirements Analysis, Process Analysis, Code Implementation_v2.mp4
│ │ Chapter 16: 52. Architect's Perspective: Interpreting the VFS Virtual File System Starting Point, Perspective, and General Content_v2.mp4
│ │ Chapter 16: 53. Architect's Perspective: file descriptors, the kernel's three main file-related data structures, and file system i-node_v2.mp4
│ │ Chapter 16: 54. Architect's Perspective: filesystem file storage structure for ext disks_v2.mp4
│ │ Chapter 16: 55. Architect's Perspective: Adapter Architecture for Linux Kernel VFS (Virtual File System)_v2.mp4
│ │ Chapter 16: 56. Architect's Perspective: VFS Process for Creating a New File, VFS Process for Reading a File Blocks_v2.mp4
│ │ Chapter 16: 57. Architect's Perspective: IO Performance Comparison of Mechanical Hard Disks, Solid State Disks, and Memory__High Performance Caching Architecture for VFS_v2.mp4
│ │ Chapter 16: 58. Architect's Perspective: VFS Core Structure - AddressSpace and Its Relationship to inode and structpage_v2.mp4
│ │ Chapter 16: 59. Architect's Perspective: Underlying Principles of Reading and Writing Files Based on Pagecache_v2.mp4
│ │ Chapter 16: 60. Architect's Perspective: PageCache and File Persistence Consistency & Reliability_v2.mp4
│ │ Chapter 16: 61. Architect's Perspective: Underlying Principles of Asynchronous Refresh of PageCache and Configuration of OS Refresh Cycle_v2.mp4
│ │ Chapter 16: 62. Architect's Perspective: Demystifying the Three Core Concepts: Page, PageCache, Buffercache_v2.mp4
│ │ Chapter 16: 63. Kernel-level underpinnings: the nature of mmap's vma structure and the kernel page_fault flow_v2.mp4
│ │ Chapter 16: 64. Kernel-Level Underpinnings: Kernel-Level Differences between mmap File Mapping and Regular READ and WRITE File Operations_v2.mp4
│ │ Chapter 16: 65. OpenJdk Source Code Interpretation: mmap Space Recovery Process_v2.mp4
│ │ Chapter 16: 66. Architect's Perspective: Linux Swap Principles, Database Systems, Why does ES dislike swap?_v2.mp4
│ │ Chapter 16: 67. Architect's Perspective: Core Processes for SWAP Operations on Linux_v2.mp4
│ │ Chapter 16: 68. Architect's Perspective: When is Swap triggered? when does kswapd perform a swap operation? _v2.mp4
│ │ Chapter 16: 69. Architect's Perspective: Meaning of the swappiness parameter_v2.mp4
│ │ Chapter 16: 70. Architect's Perspective: How Does Linux Reclaim Memory? What is the Page Frame Reclaim Algorithm (PFRA)? _v2.mp4
│ │ Chapter 16: 71. Core Hands-on 3: What is the LRU Memory Elimination Algorithm? Handwriting two versions of the LRU implementation_v2.mp4
│ │ Chapter 16: 72. Core Practical 4: PageCache pre-reading, mlock memory locking practical_v2.mp4
│ │ Chapter 16: 73. Core Practical 5: sendfile Zero Replication Source Code Analysis, High Performance File Passing Practical via sendfile_v2.mp4
│ │
│ └─ Chapter 16: Sunflower_Precious_Dictionary (High-Performance Secret)
│ Sunflower Magic: A Thorough Reveal: Zero Copy, mmap Memory Mapping, PageCache, MMU, FileCache Refresh, Kernel State, User State, Kernel Space, User Space v2.pdf
│
Chapter 17: Sweeping the Web Series: Industrial Rocketmq High Availability Underlying Principles and Practices
│ │ Chapter 17: 1. rocketmq industrial-grade, highly available knowledge graph, learning context, learning value.mp4
│ │ Chapter 17: Quantitative Goals for 2.rocketmq (HA) Industrial Grade High Availability.mp4
│ │ Chapter 17: 3. The evolution of rocketmq, the relationship between rocketmq and kafka.mp4
│ │ Chapter 17: 4. Architect's Perspective Explained: Introducing kafka's Business Architecture from 0 to 1.mp4
│ │ Chapter 17: 5. kafka development hands-on: test environment setup, validation.mp4
│ │ Chapter 17: 6. kafka development hands-on: consumer client, producer producer development and validation.mp4
│ │ Chapter 17: 7. Explained from an architect's perspective: how kafka is used in offline computing scenarios (including data middleware).mp4
│ │ Chapter 17: 8. Architect's Perspective Explained: Why kafka is not suitable for online computing (real-time computing) scenarios? .mp4
│ │ Chapter 17: 9. Explained from an architect's perspective: the use of kafka in nearline computing scenarios, with reference to e-commerce scenarios, streaming computing scenarios.mp4
│ │ Chapter 17: 10. kafka storage architecture: principles of topic, partition, and segment, and the relationship between the three.mp4
│ │ Chapter 17: 11. kafka storage architecture: structure and underlying principles of index location index files.mp4
│ │ Chapter 17: 12. kafka storage architecture: how to find messages in log files via offset?.mp4
│ │ Chapter 17: 13. kafka storage architecture: the principle of timeindex file, and how to find message by timestamp?.mp4
│ │ Chapter 17: 14. kafka storage architecture: how long do kafka's messages are kept for at most? what are the cleanup strategies for segment? .mp4
│ │ Chapter 17: 15. kafka source code analysis: kafka producer load balancing architecture.mp4
│ │ Chapter 17: 16. kafka source code analysis: kafka consumer load balancing architecture.mp4
│ │ Chapter 17: 17. kafak architecture analysis: fatal performance problems of the kafka storage architecture, and the improvement solutions of each major vendor.mp4
│ │ Chapter 17: 18. Architect's Perspective Explained: Introducing Rocketmq's Business Architecture from 0 to 1, and the Love-Hate Entanglement with Zookeep.mp4
│ │ Chapter 17: 19. Explained from an architect's perspective: four major scenarios for rocketmq usage: peak shaving, asynchronous decoupling, transactional messaging, and more.mp4
│ │ Chapter 17: 20. Architect's Perspective Explained: Three Deployment Modes for rocketMQ Clusters.mp4
│ │ Chapter 17: 21. rocketmq Deployment: Deploying a Highly Available Rocketmq Cluster with One Click.mp4
│ │ Chapter 17: 22. rocketmq deployment: detailing the configuration files for each component in a rocketmq cluster.mp4
│ │ Chapter 17: 23. rocketmq Principles and Practices: Message Consumption, Synchronous Messaging, Asynchronous Messaging, One-Way Messaging.mp4
│ │ Chapter 17: 24. rocketmq Principles and Practices: Sequential Messages, Global Ordering, Partition Ordering, and Three Key Points of Message Ordering.mp4
│ │ Chapter 17: 25. rocketmq Principles and Practices: Delayed Messages, RocketMQ Delay Levels.mp4
│ │ Chapter 17: 26. rocketmq Principles and Practices: Bulk Messages, Labeled Messages.mp4
│ │ Chapter 17: 27. rocketmq principles and practices: transactional messages, the core principles of the semi-messaging mechanism, the use of scenarios.mp4
│ │ Chapter 17: 28. rocketmq application development hands-on: the use of rocketmq-spring-boot-starter.mp4
│ │ Chapter 17: 29. rocketmq Application Development Fundamentals: RocketMQ Message Structure, Return Values, and Considerations for Sending Messages.mp4
│ │ Chapter 17: 30. rockemq Storage Architecture: Principles of CommitLog, and Comparison with kafka's Log Files.mp4
│ │ Chapter 17: 31. rockemq Storage Architecture: Principles of ConsumeQueue, and Comparison with kafka's Log Files.mp4
│ │ Chapter 17: 32. rockemq storage architecture: principles of indexfile, and comparison with kafka's index file.mp4
│ │ Chapter 17: 33. rockemq storage architecture: unveiling the broker's message writing process.mp4
│ │ Chapter 17: 34. rockemq storage architecture: unveiling the message read process for brokers.mp4
│ │ Chapter 17: 35. Starting, Strangling Answers: Why kafka is not as stable as rocketmq (world's first).mp4
│ │ Chapter 17: 36. Starting and Hanging Answer: How does RocketMQ maximize message non-loss? (Core Interview Questions).mp4
│ │ Chapter 17: 37. rocketmq high availability hands-on: nameserver high availability principles and experiments.mp4
│ │ Chapter 17: 38. rocketmq high availability hands-on: brokerserver high availability principles and experiments.mp4
│ │ Chapter 17: 39. rocketmq high availability hands-on: producer, consumer high availability principles and experiments.mp4
│ │ Chapter 17: 40. rocketmq Highly Reliable Delivery: Three Highly Reliable Delivery Options for Producer.mp4
│ │ Chapter 17: 41. rocketmq Highly Reliable Delivery: synchronous swipe, asynchronous swipe, synchronous replication, asynchronous replication for brokers.mp4
│ │ Chapter 17: 42. rocketmq Highly Reliable Delivery: retry strategy for consumer, retry queue, dead letter queue.mp4
│ │ Chapter 17: 43. rocketmq highly reliable delivery: how does the consumer guarantee message idempotency? .mp4
│ │ Chapter 17: 44. rocketmq High Availability Hands-on: Process Monitoring, Backlog Monitoring, and Online Scaling (1).mp4
│ │ Chapter 17: 44. rocketmq High Availability Hands-on: Process Monitoring, Backlog Monitoring, and Online Scaling.mp4
│ │ Chapter 17: 45. Architect's Perspective Revealed: How to make a technology selection between kafka and rocketmq? Who to marry? .mp4
│ │
│ └─Chapter 17: Sweeping the entire network series: industrial rocketmq high availability underlying principles and practices
│ rocketmq-deployment-package.7z
│ Sweep across the net: rocketmq industrial-grade highly available architecture principles and practices v2.pdf
│
“Chapter 18: The Architect's Super Inner Strengths Chapter: rocketmq Source Code Study and 3 High Architecture Patterns Explained
│ │ Chapter 18: 01. Rocketmq source code analysis as well as the three high architectural patterns explained: why, this version of the video to do the inner work of the architect? .mp4
│ │ Chapter 18: 02. Rocketmq Source Code Analysis and Explanation of the Three High Architecture Patterns: Preparation for Learning this Version of the Video.mp4
│ │ Chapter 18: 03. Building the RocketMQ Source Debugging Environment for NB (1): Downloading, Importing, and Installing the Source Code Locally.mp4
│ │ Chapter 18: 04. Building the RocketMQ Source Debugging Environment for NB (2): Configuring and Starting NameServer.mp4
│ │ Chapter 18: 05. Building the RocketMQ Source Debugging Environment for NB (3): Configuring and Starting BrokerMasterA.mp4
│ │ Chapter 18: 06. Building the RocketMQ Source Debugging Environment for NB (4): Configuring and Starting BrokerMasterB.mp4
│ │ Chapter 18: 07. Building the RocketMQ Source Debugging Environment for NB (5): Configuring and Starting the rocketmq-console.mp4
│ │ Chapter 18: 08. Building the NB RocketMQ Source Debugging Environment (6): consumer, producer configuration and startup.mp4
│ │ Chapter 18: 09. NameServer Metadata Architecture and Source Code Analysis (1): NameServer Startup Process Source Code Analysis.mp4
│ │ Chapter 18: 10. NameServer Metadata Architecture and Source Code Analysis (2): Two Major Scenarios and Core Processes for Metadata Registration Source Code Analysis.mp4
│ │ Chapter 18: 11. NameServer Metadata Architecture and Source Code Analysis (3): Asynchronous Concurrent RPC Request Pattern Interpretation.mp4
│ │ Chapter 18: 12. NameServer Metadata Architecture and Source Code Analysis (4): NameServer's Metadata Receiving Process.mp4
│ │ Chapter 18: 13. NameServer Metadata Architecture and Source Code Analysis (5): Single-Step Pattern Insight into the RouteInfoManager Metadata Management Class.mp4
│ │ Chapter 18: 14. NameServer Metadata Architecture and Source Code Analysis (6): Broker Active Reject Routing Scenario and Core Source Code Analysis.mp4
│ │ Chapter 18: 15. NameServer Metadata Architecture and Source Code Analysis (7): NamerServer Passive Cull Routing Scenario and Core Source Code Analysis.mp4
│ │ Chapter 18: 16. NameServer Metadata Architecture and Source Code Analysis (8): Functional Architecture, Technical Architecture, and Source Code Analysis for Producer and Consumer Metadata Discovery.mp4
│ │ Chapter 18: 17. NameServer Metadata Architecture and Source Code Analysis (9): NameServer Selection Policy Source Code Analysis.mp4
│ │ Chapter 18: 18. Architect's Perspective Explained: CAP Characterization of NameServer.mp4
│ │ Chapter 18: 19. Explained from the Architect's Perspective: An Elegant Way for RocketMQ to Use the ReentrantReadWriteLock Read/Write Lock.mp4
│ │ Chapter 18: 20. Architect's Perspective Explained: From Metadata Management, Analyzing the Module Architecture of RocketMQ's Source Code.mp4
│ │ Chapter 18: 21. Producer Architecture and Source Code Analysis (1): The Four Major Steps in Producer's Message Sending.mp4
│ │ Chapter 18: 22. Producer Architecture and Source Code Analysis (2): the 2nd major step of message sending in producer, the principle of getting routing metadata and source code.mp4
│ │ Chapter 18: 23. Producer Architecture and Source Code Analysis (3): Load Balancing Mechanism for Highly Available Producers.mp4
│ │ Chapter 18: 24. Producer Architecture and Source Code Analysis (4): The 4th major step of message sending in producer, RPC remote call.mp4
│ │ Chapter 18: 25. Producer Architecture and Source Code Analysis (5): Fault Isolation Strategy MQFaultStrategy Principles and Source Code.mp4
│ │ Chapter 18: 26. Producer Architecture and Source Code Analysis (6): Retry Mechanism, High Reliability Mechanism, and Dynamic Isolation Mechanism for Message Delivery.mp4
│ │ Chapter 18: 27. Producer Architecture and Source Code Analysis (7): How Does Ordered Messages Guarantee Reliability? .mp4
│ │ Chapter 18: 28. Architect's Perspective Explained: How to Perfectly Use Semaphore for Flow Control in RPC Frameworks.mp4
│ │ Chapter 18: 29. Architect Perspective Explained: Thoroughly Explain the Broker Storage Architecture in rocketmq (the strongest ever, sweeping the entire network).mp4
│ │ Chapter 18: 30. Explained from the Architect's Perspective: Process Analysis and Source Code Learning for the Request Processing Layer of the Broker Storage Architecture.mp4
│ │ Chapter 18: 31. Architect's Perspective Explained: Architectural Analysis and Source Code Learning for the Business Logic Layer of the Broker Storage Architecture.mp4
│ │ Chapter 18: 32. Explained from the Architect's Perspective: Architectural Analysis and Source Code Learning for the Broker Storage Architecture File Mapping Layer.mp4
│ │ Chapter 18: 33. Explained from the Architect's Perspective: Architectural Analysis of the File Storage Layer of the Broker Storage Architecture and Principles of the File Refresh Mechanism.mp4
│ │ Chapter 18: 34. Overall Explanation of the Three Major Logical Stores: the CommitLog Class, the ConsumeQueue Class, and the IndexFile Class.mp4
│ │ Chapter 18: 35. CommitLog Explained: swipe threads, commit threads, other core members, and CommitLog's L2 cache pattern architecture.mp4
│ │ Chapter 18: 36.CommitLog Explained: core principles and source code for putMessage message writing.mp4
│ │ Chapter 18: 38.CommitLog Explained: Synchronous vs. Asynchronous Swiping, Core Principles and Source Code for Synchronous Swiping.mp4
│ │ Chapter 18: 39. Explained from the Architect's Perspective: Principles and Source Code of the High-Performance Foundation Class ServiceThread.mp4
│ │ Chapter 18: 40. Ultra-Super Inner Workings Explained: JUC's AQS, CountdownLatch Principles and Source Code, and Why Rocketmq Customizes Closures? .mp4
│ │ Chapter 18: 41. Explained from the Architect's Perspective: The MPSC Lock-Free Programming Model.mp4
│ │ Chapter 18: 42.CommitLog Explained: Synchronous vs. Asynchronous Replication, Core Principles and Source Code for Synchronous Replication.mp4
│ │ Chapter 18: 43.CommitLog Explained: synchronous vs. asynchronous swiping, core principles and source code for asynchronous swiping.mp4
│ │ Chapter 18: 44. CommitLog Explained: Source Code Analysis of How Rocketmq Uses File Preheating + Memory Locking to Improve Performance? .mp4
│ │ Chapter 18: 45.CommitLog Explained: Principles, Allocation, Claiming, and Returning of the WriteBuffer, a Second-Level Dedicated Write Cache.mp4
│ │ Chapter 18: 46.CommitLog Interpretation: second-level dedicated write cache WriteBuffer writes.mp4
│ │ Chapter 18: 47.CommitLog Interpretation: committing and swiping the contents of the secondary dedicated write cache WriteBuffer.mp4
│ │ Chapter 18: 48. Explained from an Architect's Perspective: How RocketMq Uses Read/Write Separation to Improve Performance.mp4
│ │ Chapter 18: 49. Explained from an Architect's Perspective: How RocketMq Uses SpinLock SpinLock to Improve Performance.mp4
│ │ Chapter 18: 50.CommitLog Explained: the complete process of message reading, and performance optimization during message reading.mp4
│ │ Chapter 18: 51. consumequeue Explained: structure of a consume partition index entry, structure of a consume partition index file.mp4
│ │ Chapter 18: 52. consumptionqueue explained: principles and source code for consumption partition index writes.mp4
│ │ Chapter 18: 53. consumptionqueue explained: principles and source code for consumption partition index reads.mp4
│ │ Chapter 18: 54. indexFile Explained: one of the most complex parts of rocketmq, the file structure of hash indexes.mp4
│ │ Chapter 18: 55.indexFile Explained: Principles and Source Code of the Hash Index Write Process.mp4
│ │ Chapter 18: 56. indexFile Explained: the complete process of querying an index index based on msgkey and time range.mp4
│ │ Chapter 18: 57. File Mapping Layer Explained: A High-Performance L2 Cache Architecture.mp4
│ │ Chapter 18: 58. File Mapping Layer Explained: Principles and Source Code for MappedFile High Performance Writes.mp4
│ │ Chapter 18: 59. File Mapping Layer Explained: Principles and Source Code for MappedFile High-Performance Reads.mp4
│ │ Chapter 18: 60. File Mapping Layer Explained: Principles and Source Code for File Periodic (10S) Scanning and Cleaning Policy.mp4
│ │ Chapter 18: 61. High-Performance RPC: Macro Architecture and Usage of the RPC Framework in RocketMQ.mp4
│ │ Chapter 18: 62. High Performance RPC: Protocol Design and Encoding and Decoding of Messages.mp4
│ │ Chapter 18: 63. High-Performance RPC: Communication Processing Flow for Asynchronous Messages Core Principles and Source Code Analysis.mp4
│ │ Chapter 18: 64. High-Performance RPC: Communication Processing Flow for Synchronized Messages Core Principles and Source Code Analysis.mp4
│ │ Chapter 18: 65. High-Performance RPC: Communication Processing Flow for One-Way Messages Core Principles and Source Code Analysis.mp4
│ │ Chapter 18: 66. High-Performance RPC: Designing a Multi-Threaded Reactor Model Architecture for Oxfam 1+N+M1+M2.mp4
│ │ Chapter 18: 67. Architect's Perspective Explained: Referring to Rocketmq to Unlock Important Positions for Using JUC Thread Pools.mp4
│ │ Chapter 18: 68. Architect's Perspective Explained: The Points and Drawbacks of the Two Major Transport Modes, Pull Mode and Push Mode.mp4
│ │ Chapter 18: 69. Comsumer Architecture and Source Code Analysis: Introducing the Functionality of the RocketMQ Long Polling Push Mode.mp4
│ │ Chapter 18: 70. Consumer Architecture and Source Code Analysis: Client-Side Source Code Analysis of RocketMQ Long Polling Push Mode.mp4
│ │ Chapter 18: 71. Consumer Architecture and Source Code Analysis: RocketMQ Long Polling Push Mode for Broker Side Source Code Analysis.mp4
│ │ Chapter 18: 72. Rocketmq Zero-Copy Technology: How to Use FileRegion Zero-Copy to Improve Performance.mp4
│ │ Chapter 18: 73.Broker Architecture and Source Code Analysis: Shortcomings of Fixed-Frequency Push Patterns, and Advantages of Long-Rotation Pushes.mp4
│ │ Chapter 18: 74. Consumer Architecture and Source Code Analysis: Principles and Uses of the Pull Pull Pattern.mp4
│ │ Chapter 18: 75. Consumer Architecture and Source Code Analysis: The Core Process of Consumer Execution, Two Major Services and Two Major Thread Pools.mp4
│ │ Chapter 18: 76. Consumer Architecture and Source Code Analysis: Principles and Source Code of Consumer Flow Control Mechanism.mp4
│ │ Chapter 18: 77. Consumer Architecture and Source Code Analysis: Principles and Source Code of the Client Rebalancing Mechanism.mp4
│ │ Chapter 18: 78. Consumer Architecture and Source Code Analysis: Principles and Source Code for Client Load Balancing Architecture.mp4
│ │ Chapter 18: 79. Consumer architecture and source code analysis: average allocation strategy, polling allocation strategy.mp4
│ │ Chapter 18: 80.Consumer Architecture and Source Code Analysis: Nearby Server Room Allocation Policy, Consistent Hash Allocation Policy.mp4
│ │
│ └─Chapter 18: Rocketmq Source Code Analysis and 3 High Architecture Patterns Explained Handout
│ Sweeping the entire network of architects within the chapter: RocketMQ high-availability, high-performance architecture underlying principles, source code analysis v2.pdf
│
“Chapter 19: 10Wqps Push Center Hands-On
│ Data Storage Architecture for Message Push Middleware v2.pdf
│ Chapter 19.1: 01. Learning Route, Learning Context, and Precautions for Billion-Dollar Sub-Repository and Sub-Table Practices.mp4
│ Chapter 19.1: 02. Doing Architecture from 0 to 1: A Sample Push Middleware as a Sample of the Opening Posture of System Architecture in Real Projects.mp4
│ Chapter 19.1: 03. Doing Architecture from 0 to 1: A sample of how to architect a business from 0 to 1, using Push Center as a sample.mp4
│ Chapter 19.1: 04. Doing architecture from 0 to 1: A sample of how to do module architecture from 0 to 1, using the push middleware as a sample.mp4
│ Chapter 19.1: 05. Doing architecture from 0 to 1: A sample of how to do storage architecture from 0 to 1, using Push Center as a sample.mp4
│ Chapter 19.1: 06. Doing Architecture from 0 to 1: How to Architect Traffic from 0 to 1, using Push Center as a sample.mp4
│ Chapter 19.1: 07. Doing Architecture from 0 to 1: How to Deploy Architecture from 0 to 1 Using Push Center as a Sample.mp4
│ Chapter 19.1: 08. Doing architecture from 0 to 1: How do frontline architects make technology selections for data storage? .mp4
│ Chapter 19.1: 09. Doing Architecture from 0 to 1: Starting from 0 to 10 billion repository tables Architecture design, how to plan for scaling? .mp4
│ Chapter 19.1: 10. Learning Planning for shardingjdbc, Background on Splitting Library and Table.mp4
│ Chapter 19.1: 11. Deep Dive: Why is the capacity bottleneck for a single meter roughly 500w-1000w?.mp4
│ Chapter 19.1: 12. Deep Dive: Why is it officially recommended to use growing primary keys for indexes? Why can't you use UUIDs as index values? .mp4
│ Chapter 19.1: 13. Architect's perspective: the two main jobs of data slicing in a partitioned model.mp4
│ Chapter 19.1: 14. Explained from an architect's point of view: what is range slicing, fetch mode slicing, hash slicing, and virtual slot slicing? .mp4
│ Chapter 19.1: 15. Architect's Perspective Explained: two major jobs of data sharding for elasticsearch.mp4
│ Chapter 19.1: 16. Architect's Perspective Explained: two major jobs of data sharding for rediscluster.mp4
│ Chapter 19.1: 17. Architect's Perspective Explained: shardingjdbc's two main jobs for data sharding.mp4
│ Chapter 19.1: 18. shardingjdbc Hands-on: Using the Inline Split Library and Split Table Strategy via JavaAPI.mp4
│ Chapter 19.1: 19. shardingjdbc hands-on: using the Inline split-library-split-table strategy via the properties configuration file.mp4
│ Chapter 19.1: 20. shardingjdbc hands-on: using StandardShardingStrategy via JavaAPI.mp4
│ Chapter 19.1: 21. shardingjdbc hands-on: JavaAPI using RangeShardingAlgorithm hands-on 1.mp4
│ Chapter 19.1: 22. shardingjdbc hands-on: configuring the StandardShardingStrategy split library and split table strategy via proteins.mp4
│ Chapter 19.1: 23. shardingjdbc hands-on: ComplexShardingStrategy hands-on.mp4
│ Chapter 19.1: 24. shardingjdbc Hands-on: HintShardingStrategy Source and Practice.mp4
│ Chapter 19.1: 25. shardingjdbc hands-on: NoneShardingStrategyConfiguration source and practice.mp4
│ Chapter 19.1: 26. shardingjdbc hands-on: broadcast table principles and practices.mp4
│ Chapter 19.1: 27. shardingjdbc hands-on: binding table principles and practices, and introduces the significance of vertically splitting tables from a B+ tree.mp4
│ Chapter 19.1: 28. shardingjdbc principle: execution flow of sql after splitting library and table.mp4
│ Chapter 19.1: 29. shardingjdbc principles: shardingjdbc's SQL routing principles.mp4
│ Chapter 19.1: 30. shardingjdbc principles: how to choose a sharding key when splitting a library and table.mp4
│ Chapter 19.1: 31. shardingjdbc principles: principles and practices of the gene method.mp4
│ Chapter 19.1: 32. Difficult interview question: how to do join operation after splitting library and table? .mp4
│ Chapter 19.1: 33. Difficult interview questions: How to solve cross-library associations after splitting libraries and tables? How to deal with fuzzy conditional queries? .mp4
│ Chapter 19.1: 34. shardingjdbc principles: snowflake algorithm source code and solution to the clock back problem.mp4
│ Chapter 19.1: 35. shardingjdbc extensions: principles and practices of Java's spi mechanism.mp4
│ Chapter 19.1: 36. shardingjdbc extensions: typebasedSpi mechanism principles and source code analysis, and how to extend the custom ID generator? .mp4
│ Chapter 19.1: 37. ShardingJdbc Data Sharding Development Summary.mp4
│ Chapter 19.1: 38. Master-Slave Replication and Read-Write Separation: Mysql Master-Slave Cluster Built with One Click.mp4
│ Chapter 19.1: 39. Master-Slave Replication and Read-Write Separation: Configuration Related to the Master and Slave of a Mysql Master-Slave Cluster.mp4
│ Chapter 19.1: 40. Master-Slave Replication and Read-Write Separation: Principles of Binlog, Usage Scenarios, and Persistence Strategies.mp4
│ Chapter 19.1: 41. Master-Slave Replication and Read-Write Separation: redo log Principles, Usage Scenarios, Persistence Strategies.mp4
│ Chapter 19.1: 42. Master-Slave Replication and Read-Write Separation: the Principle of the Two-Phase Commit of the redo log, and the High-Performance Nature of WAL.mp4
│ Chapter 19.1: 43. Master-Slave Replication and Read-Write Separation: undolog Principles, Usage Scenarios.mp4
│ Chapter 19.1: 44. Master-Slave Replication and Read-Write Separation: The Generation Process of the Three Major Logs of redo, undo, and binlog and Crash Crash Recovery.mp4
│ Chapter 19.1: 45. Master-Slave Replication and Read-Write Separation: Principles of Binlog Master-Slave Replication, How to Solve the Problem of Large Latency between Master-Slave Services.mp4
│ Chapter 19.1: 46. Master-Slave Replication and Read-Write Separation: sharingjdbc Read-Write Separation Hands-on.mp4
│ Chapter 19.1: 47. Data Consistency with canal: Principles and usage scenarios for canal-based data consistency.mp4
│ Chapter 19.1: 48. Using canal data consistency: environment setup for canal-based data consistency.mp4
│ Chapter 19.1: 49. Data consistency with canal: hands-on data consistency based on canal+rocketmq.mp4
│ Chapter 19.1: 50. Distributed ID high-performance transformation: selection of split-bias keys for push middleware, selection of ID algorithms.mp4
│ Chapter 19.1: 51. Distributed ID High Performance Retrofit: Algorithm Design and Implementation of ID Fetching and Slicing for Push Middleware.mp4
│ Chapter 19.1: 52. Distributed ID high-performance transformation: two major scenarios for clock back, analyzing shardingjdbc solutions from source code.mp4
│ Chapter 19.1: 53. Distributed ID high-performance transformation: analyzing SnowFlake's clock-back solution from baidu's uid source code.mp4
│ Chapter 19.1: 54. Distributed ID High Performance Transformation: the SnowFlake data skew problem.mp4
│ Chapter 19.1: 55. Distributed ID High-Performance Retrofit: Design and Implementation of Distributed Lock-Free Self-Incrementing and Self-Incrementing IDs Based on SnowFlake Algorithm.mp4
│ Chapter 19.1: 56. Distributed ID High Performance Transformation: Combining ZK's DistributedAtomicLong Strong Consistency for Sequence Part Persistence.mp4
│ Chapter 19.1: 57. Distributed ID High-Performance Transformation: Taking High-Performance Design Ideas from rocketmq for High-Performance Asynchronous Persistence of ID Serial Number Parts.mp4
│ Chapter 19.1: 58. Distributed ID high-performance transformation: solving the zookeeper node workerid non-recovery problem.mp4
│ Chapter 19.1: 59. sharding-jdbc dynamic scaling: the main process of dynamic scaling, dynamic scaling technology selection.mp4
│ Chapter 19.1: 60. sharding-jdbc dynamic scaling: springboot-based dynamic data sources.mp4
│ Chapter 19.1: 61. sharding-jdbc dynamic scaling: design and implementation of a publish-subscribe mechanism for dynamic scaling of data sources based on zookeeper.mp4
│ Chapter 19:63: Brief introduction: springsecurity case demo, and the environment needed to execute the demo case.mp4
│ Chapter 19: 64: Systematizing with Architecture Diagrams: What is Authentication and Authentication?Scenarios for Using SpringSecurity? .mp4
│ Chapter 19:65: Illustration: springsecurity fundamentals, and the basic process of authenticating a user at a time.mp4
│ Chapter 19: 66: Old Architecture Explained in Super Detail: springsecurity's Data Source-Based User Authentication Process.mp4
│ Chapter 19: 67: Chain of Responsibility Patterns Explained, Old Architecture Sacrifices Its Own Source Code Analysis Method: The Method of Following the Vine.mp4
│ Chapter 19:68: SpringSecurity Source Code Analysis: Its Internal Chain of Responsibility, How is it Assembled? .mp4
│ Chapter 19: 69: Old Architecture Explained in Super Detail: Principles, Practices, and Security of JWT Tokens.mp4
│ Chapter 19:70: First Steps in Token Authentication: Introducing the JWT Token Issuance Process in the Context of UAA Services.mp4
│ Chapter 19:71: Step 2 of Token Authentication: Introducing the JWT Token Authentication Process Based on SpringSecurity in Conjunction with Zuul Services.mp4
│ Chapter 19: 72: First Steps in RSA Forensics: RSA Usage Scenarios, RSA Encryption and Decryption Principles, and Public and Private Key Generation.mp4
│ Chapter 19:73: Step 2 of RSA Authentication: The JWT+RSA Token Issuance Process.mp4
│ Chapter 19:74: Step 3 of RSA Authentication: SpringSecurity for JWT+RSA Token Authentication Process.mp4
│ Chapter 19:75: Architect's Perspective Explained: architecting a highly reliable solution for message push from 0.mp4
│ Chapter 19: 76: Explained from the Architect's Perspective: Architecting an Ultra-High Concurrency Solution for Message Push from 0.mp4
│ Chapter 19: 77: An Architect's Perspective Explained: Hands-on Hands-on before the Module Architecture of the Message Push Middleware.mp4
│ Chapter 19: 78: Interview Super Highlight: Writing a SpringCloudgateway Filter to Complete JWT+RSA Token Verification.mp4
│ Chapter 19: 79: Interview Super Highlight: Writing a SpringCloudgateway Filter to accomplish Body interception, extraction, and relay forwarding.mp4
│ Chapter 19: 80: Interview Super Highlight: Blocking Queues + Bulk Messages for High Performance rocketmq Bulk Message Assembly and Push.mp4
│ Chapter 19: 81: Diving into the rocketmq source code: Implementing a multi-threaded + multi-producer ultra-high concurrency push model.mp4
│ Chapter 19: 82: Introduction to Core Functionality: Demonstration and Interpretation of the End-to-End Process Based on Websocket Push.mp4
│ Chapter 19: 83: The Jewel in the Crown: An Important, High-Value Introduction to Netty-Based Websocket Push Hands-On.mp4
│ Chapter 19: 84: High Concurrency Push Hands-on: Introduction to the Functional Flow of Websocket Push.mp4
│ Chapter 19: 85: High Concurrency Push Hands-On: Ultra-High Concurrency Architecture for Technology Selection and Communication Processes.mp4
│ Chapter 19: 86: High Concurrency Push Hands-on: netty-based WebServer, WebsocketServer Basic Development.mp4
│ Chapter 19: 87: High Concurrency Push Hands-on: Analyzing and Learning the websocket protocol in depth through packet capture.mp4
│ Chapter 19: 88: Netty Source Code Explained: websocket's event mechanism, and handshake event processing flow.mp4
│ Chapter 19: 89: Highly Concurrent Push Hands-on: The Functionality of the websocket business handler in a message push scenario, and pipeline assembly.mp4
│ Chapter 19:90: Server-side performance optimization: complete token authentication before the handshake, not after.mp4
│ Chapter 19: 91: High-Concurrency Push Hands-on: How the Client gets the gateway address of the websocket service, and pushes the token.mp4
│ Chapter 19: 92: High Concurrency Push Hands-on: Local Session Creation, ID Setting, Session Management.mp4
│ Chapter 19: 93: Highly Concurrent Push Hands-on: Message Subscription and Push.mp4
│ Chapter 19: 94: Diving into the Rocketmq Source Code: Living and Learning, Referring to the Rocketmq Source Code for Netty Thread Pool Configuration.mp4
│ Chapter 19: 95: Diving into the Rocketmq Source Code: Living and Learning, Referring to Rocketmq's Use of the epoll Instead of the select System Call.mp4
│ Chapter 19: 96: Diving into the Linux Kernel: An In-Depth Look at the Underlying Principles of SELECT, Performance Issues with SELECT.mp4
│ Chapter 19: 97: Deeper into the Linux Kernel: An In-Depth Explanation of the Underlying Principles of epoll, Performance Advantages of epoll.mp4
│ Chapter 19: 98: websocket high scaling: nginx-based static scaling for websocket push, load balancing.mp4
│
“Chapter 20: Sweeping the Net Series: Thoroughly Penetrating the Principles of Netty and Practical Exercises
│ Chapter 20: 01. The Highly Concurrent Three Musketeers: The Importance of Netty's High-Performance Communication Components and Learning Materials.mp4
│ Chapter 20: 02. High Concurrency Three Musketeers: The Importance of the Redis Distributed Cache Component and Learning Materials.mp4
│ Chapter 20: 03. The Highly Concurrent Three Musketeers: The Importance of the Zookeeper Distributed Orchestration Component and Learning Materials.mp4
│ Chapter 20: 04. Introducing Netty: How to Use Netty in Highly Concurrent Web Applications.mp4
│ Chapter 20: 05. Introduction to Using Netty: How to Use Netty in Non-Web Applications.mp4
│ Chapter 20: 06. Underlying Principles of Highly Concurrent IO: User Space vs. Kernel Space.mp4
│ Chapter 20: 07. Underlying Principles of Highly Concurrent IO: Execution Flow of Typical IO System Calls sys_read & sys_write.mp4
│ Chapter 20: 08. Interview Essential Fundamentals: What is Synchronous Blocking IO?.mp4
│ Chapter 20: 09. Interview Essential Fundamentals: What is Synchronous Non-Blocking IO?.mp4
│ Chapter 20: 10. Interview Essential Fundamentals: What is Multiplexed IO?.mp4
│ Chapter 20: 11. Interview Essential Fundamentals: What is Signal Driven IO?.mp4
│ Chapter 20: 12. Interview Essential Fundamentals: What is Asynchronous IO (Asynchronous IO) model? .mp4
│ Chapter 20: 13. Basic Hands-On: How to Support 1 Million Concurrency with Proper Configuration? .mp4
│
Companion book (Volume 1)
│ Extreme Classics (Volume 1): Java High Concurrency Core Programming (Volume 1) - Nien Java Hardcore Architecture Class- Special v8.pdf
│ Extreme Classics (Volume 1): Java High Concurrency Core Programming (Volume 1) - Nien Java Hardcore Architecture Class- Special v9.pdf
│
└─Supplementary books (Volume 2)
Extreme Classics (Volume 2): Java High Concurrency Core Programming (Volume 2) - Nien Java Hardcore Architecture Class- Special v11.pdf
Comments (0)