Kuaishou Campus Salary Insights & Java Backend Interview Guide

Author Xiao Lin shares recent Kuaishou 2023 campus recruitment salary data, noting that the mainstream annual package for backend and frontend developers ranges from 400,000 to 500,000 CNY, with additional 2,000 CNY monthly housing subsidies and occasional signing bonuses for senior levels.

Backend Development: 35k × 16 months → 560,000 CNY

Backend Development: 33k × 16 months → 528,000 CNY

Frontend Development: 32k × 16 months → 512,000 CNY

Backend Development: 30k × 16 months → 480,000 CNY

Backend Development: 28k × 16 months → 448,000 CNY

Testing Development: 27k × 16 months → 432,000 CNY

Backend Development: 25.5k × 16 months → 408,000 CNY

The data shows a “budget” line around 255,000 CNY, SP (senior professional) positions around 270‑300 k, and SSP (senior specialist) above 320 k. Compared with the 2022 (25th) batch, offers have risen roughly 2 k per month, especially for SSP roles, with some reaching 350 k+.

Because large tech firms are increasingly competitive, they are raising compensation to attract talent, and the author expects further salary breakthroughs in the next year.

Kuaishou Java Backend Interview

1. JVM Memory Structure

According to the JDK 8 specification, the JVM runtime memory consists of five areas: program counter, Java virtual machine stack, native method stack, heap, and metaspace (method area). Direct memory, managed via NIO, is also available outside the JVM heap.

Program Counter : Stores the bytecode line number of the current thread; null for native methods.

Java Virtual Machine Stack : Per‑thread stack storing frames, local variables, operand stack, dynamic linking, and return addresses; can throw StackOverflowError or OutOfMemoryError.

Native Method Stack : Similar to the JVM stack but for native methods; merged with the JVM stack in HotSpot.

Java Heap : Largest memory region, shared by all threads; divided into young (Eden + Survivor) and old generations; out‑of‑memory triggers OutOfMemoryError.

Method Area (Metaspace) : Stores class metadata, constants, and static variables; uses native memory in JDK 8+; may throw OutOfMemoryError when exhausted.

Runtime Constant Pool : Part of the method area, holds literals and symbolic references; can be expanded at runtime.

Direct Memory : Off‑heap memory accessed via NIO classes; improves I/O performance but is limited by the host’s physical memory.

2. Garbage Collectors

Serial Collector : Single‑threaded, suitable for client‑side or small‑memory scenarios; pauses all user threads during collection.

ParNew Collector : Multithreaded version of Serial, typically paired with CMS for young‑generation collection.

Parallel Scavenge (Throughput‑First) Collector : Uses multiple threads to achieve high throughput; ideal for background‑heavy workloads.

Parallel Old Collector : Multithreaded collector for the old generation, employing a mark‑compact algorithm.

CMS (Concurrent Mark‑Sweep) Collector : Targets low pause times with concurrent marking and sweeping; may cause memory fragmentation.

G1 Collector : Introduced in JDK 7, default since JDK 9; divides the heap into equal‑sized regions and provides predictable pause times for large‑memory applications.

ZGC and Shenandoah : Modern low‑latency collectors; ZGC (JDK 11) aims for pauses under 10 ms and supports multi‑TB heaps, while Shenandoah uses concurrent compaction.

3. CMS Garbage‑Collection Process

Initial Mark : Stop‑the‑world phase that quickly marks objects directly reachable from GC roots.

Concurrent Mark : Runs concurrently with application threads, traversing the object graph from the initially marked set.

Remark (Final Mark) : Another stop‑the‑world phase that corrects marks changed during the concurrent phase.

Concurrent Sweep : Concurrently clears dead objects without moving live ones, freeing memory while the application continues.

Only the initial and final marks cause short pauses; the concurrent phases handle the bulk of the work, which is why CMS achieves low pause times but may leave fragmentation.

4. Concurrency Primitives

ThreadLocal : Provides thread‑isolated variables; each thread holds its own copy, preventing data leakage between threads. Must call remove() after use to avoid memory leaks in thread pools.

synchronized : Intrinsic lock that ensures mutual exclusion for a block or method; implemented via monitorenter/monitorexit bytecodes. Modern JVMs optimize it with biased, lightweight, and heavyweight locks.

volatile : Guarantees visibility and ordering; writes flush to main memory, reads load from main memory. Does not ensure atomicity for compound actions like i++.

CAS (Compare‑And‑Swap) : Optimistic lock that atomically updates a memory location if it matches an expected value; foundation of AtomicInteger and other lock‑free structures. Vulnerable to the ABA problem and high CPU usage under contention.

5. SQL Join Differences

INNER JOIN (often just “JOIN”) returns only rows where matching records exist in both tables. LEFT JOIN (left outer join) returns all rows from the left table and fills missing right‑table columns with NULL. RIGHT JOIN is the mirror of LEFT JOIN.

6. Other Common Interview Topics

Discuss personal competition achievements listed on the résumé.

Explain master‑degree research direction and personal contributions.