🤖 AI Summary
This study addresses the correctness and efficiency of concurrent linked list access under multithreaded workloads by systematically implementing five representative designs: coarse-grained locking, fine-grained locking, lazy synchronization, optimistic synchronization, and lock-free structures. Through empirical evaluation in C++, the work demonstrates a strong correlation between algorithmic performance and workload characteristics—such as read-write ratios and key ranges—as well as thread count. The findings reveal that coarse-grained locking and lazy lists achieve optimal performance in read-heavy scenarios with small key ranges, whereas lock-free lists exhibit significant advantages under high concurrency and large key ranges. Notably, fine-grained locking consistently underperforms due to per-node locking overhead, challenging the common assumption that finer granularity inherently yields better scalability. These results provide empirical guidance for selecting appropriate concurrent data structures in practice.
📝 Abstract
Linked lists are one of the most basic data structures in computer science. But when many threads try to use the same linked list at the same time, things get complicated. In this paper, we look at five different ways to make a linked list work correctly and efficiently with multiple threads running at once. We start with the simplest approach -- one big lock for the whole list -- and step by step improve it, ending with a lock-free design that uses no locks at all. We implemented all five versions in C++ and measured how fast each one is across different workloads (read-heavy, balanced, and write-heavy) and different list sizes. Our results show that the right choice of algorithm depends heavily on how the list is used: the coarse-grain and lazy lists win under read-heavy workloads with small key ranges, while the lock-free list becomes competitive when key ranges are large and more threads are running. Fine-grain locking, despite its theoretical appeal, pays a heavy cost from per-node lock overhead and consistently performs the worst in our tests.