Comprehensive Guide to Technical Interview Topics: Signals, Process Synchronization, TLS Handshake, Caching Issues, Java Collections, Heap Construction, and Scheduling Algorithms

Interview Context and Salary Overview

China Telecom, China Mobile, and China Unicom are the three major state‑owned telecom operators, each regularly recruiting software development positions. State‑owned enterprises typically offer more stable employment with fewer overtime hours compared to private internet companies. Salary packages for fresh graduates at China Telecom range from 150k CNY in second‑tier cities to 200‑250k CNY in first‑tier cities, inclusive of bonuses and benefits.

China Mobile Interview Process

The interview consists of two rounds, each lasting around 20‑30 minutes. The first round focuses on operating‑system fundamentals, networking, Redis, and Java. The second round expands to operating‑system and data‑structure questions, followed by a brief HR discussion.

Sample Questions

Signal concepts and common Unix signals (SIGINT, SIGTERM, SIGKILL).

Process synchronization mechanisms: semaphores, mutexes, condition variables.

Inter‑process communication methods: pipes, message queues, shared memory, sockets.

Network protocol layers (application, transport, network).

HTTPS/TLS handshake process using RSA key exchange.

Caching Challenges and Solutions

Data inconsistency between cache and database – solved with Canal listening to Binlog for asynchronous updates.

Hot key pressure – split a hot key into multiple sub‑keys (e.g., hot_key:1 , hot_key:2 ).

Large key size – break large values into smaller keys or compress with Gzip.

Cache anomalies (penetration, breakdown, avalanche) – see detailed mitigation strategies below.

Cache Avalanche

When many keys expire simultaneously or Redis crashes, a surge of database requests can cause a cascade failure. Mitigation includes staggered expiration times with random offsets.

Cache Breakdown

If a hot key expires, a flood of requests may hit the database. Using a mutex lock to ensure only one request rebuilds the cache prevents overload.

Cache Penetration

Requests for non‑existent data bypass both cache and database, overwhelming the DB. Solutions: validate request parameters, cache null values, and employ Bloom filters.

Load‑Balancing Scheduling Idea

Round‑Robin: simple but ignores server load.

Weighted Round‑Robin: assigns weights based on server capacity.

Least Connections: selects the server with the fewest active connections.

Weighted Least Connections: combines weight and connection count.

Java Collections Overview

List implementations (ArrayList, LinkedList, Vector, Stack) provide ordered collections with index‑based access.

Map implementations (HashMap, LinkedHashMap, TreeMap, Hashtable, ConcurrentHashMap) store key‑value pairs with varying ordering and concurrency guarantees.

Set implementations (HashSet, LinkedHashSet, TreeSet) store unique elements, with TreeSet offering sorted order.

Java Garbage Collection Mechanisms

Mark‑Sweep: marks reachable objects then sweeps unmarked ones; suffers from fragmentation.

Copying: divides memory into two halves and copies live objects; reduces fragmentation but halves usable space.

Mark‑Compact: moves live objects to one end, eliminating gaps.

Generational Collection: separates young and old generations, promoting long‑living objects.

Heap Construction Algorithm (Java Example)

public class HeapBuilder {
    // Sift‑down for a max‑heap
    private static void siftDown(int[] arr, int i, int n) {
        while (i < n) {
            int left = 2 * i + 1;
            int right = 2 * i + 2;
            int largest = i;
            if (left < n && arr[left] > arr[largest]) {
                largest = left;
            }
            if (right < n && arr[right] > arr[largest]) {
                largest = right;
            }
            if (largest != i) {
                int temp = arr[i];
                arr[i] = arr[largest];
                arr[largest] = temp;
                i = largest; // continue sifting down
            } else {
                break; // heap property restored
            }
        }
    }

    // Build heap in‑place
    public static void buildHeap(int[] arr) {
        int n = arr.length;
        for (int i = n / 2 - 1; i >= 0; i--) {
            siftDown(arr, i, n);
        }
    }

    public static void main(String[] args) {
        int[] arr = {3,5,1,7,2,9,4};
        buildHeap(arr); // Result: [9,7,4,5,3,1,2]
    }
}

Operating‑System Process Scheduling Algorithms

First‑Come‑First‑Served (FCFS): non‑preemptive, simple but can cause long wait for short jobs.

Shortest Job First (SJF): selects the job with the smallest execution time; may starve long jobs.

Highest Response Ratio Next (HRRN): balances waiting time and service time.

Round‑Robin (RR): assigns a time slice (typically 20‑50 ms) to each process.

Priority Scheduling: runs the highest‑priority process; can be preemptive or non‑preemptive.

Multilevel Feedback Queue (MLFQ): combines multiple queues with varying priorities and time slices, promoting fairness for both short and long jobs.

Process, Thread, and Coroutine Definitions

Process : OS resource allocation unit with independent memory space; high isolation but costly context switches.

Thread : Execution unit within a process sharing memory; lower switch overhead but requires synchronization.

Coroutine : User‑level lightweight thread managed by the application; minimal switch cost, but scheduling is manual.

Typical Interview Discussion Topics

Project experience, challenges, and solutions.

Optimization details and future extensions.

Career planning and salary expectations.

Questions to ask the interviewer.