Non-Blocking Doubly-Linked Lists with Good Amortized Complexity

Author Niloufar Shafiei

Thumbnail PDF


  • Filesize: 0.6 MB
  • 17 pages

Document Identifiers

Author Details

Niloufar Shafiei

Cite AsGet BibTex

Niloufar Shafiei. Non-Blocking Doubly-Linked Lists with Good Amortized Complexity. In 19th International Conference on Principles of Distributed Systems (OPODIS 2015). Leibniz International Proceedings in Informatics (LIPIcs), Volume 46, pp. 35:1-35:17, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)


We present a new non-blocking doubly-linked list implementation for an asynchronous shared-memory system. It is the first such implementation for which an upper bound on amortized time complexity has been proved. In our implementation, operations access the list via cursors. Each cursor is located at an item in the list and is local to a process. In our implementation, cursors can be used to traverse and update the list, even as concurrent operations modify the list. The implementation supports two update operations, insertBefore and delete, and two move operations, moveRight and moveLeft. An insertBefore(c, x) operation inserts an item x into the list immediately before the cursor c's location. A delete(c) operation removes the item at the cursor c's location and sets the cursor to the next item in the list. The move operations move the cursor one position to the right or left. Update operations use single-word Compare&Swap instructions. Move operations only read shared memory and never change the state of the data structure. If all update operations modify different parts of the list, they run completely concurrently. A cursor is active if it is initialized, but not yet removed from the process's set of cursors. Let c.(op) be the maximum number of active cursors at any one time during the operation op. The amortized step complexity is O(c.(op)) for each update op and O(1) for each move. We provide a detailed correctness proof and amortized analysis of our implementation.
  • non-blocking data structure
  • doubly-linked list
  • shared memory
  • amortized complexity
  • cursor


  • Access Statistics
  • Total Accesses (updated on a weekly basis)
    PDF Downloads


  1. Hagit Attiya and Eshcar Hillel. Built-in coloring for highly-concurrent doubly-linked lists. Theory of Computing Systems, 52(4):729-762, 2013. Google Scholar
  2. Greg Barnes. A method for implementing lock-free shared-data structures. In Proceedings of the 5th ACM Symposium on Parallel Algorithms and Architectures, SPAA'93, pages 261-270, 1993. Google Scholar
  3. Trevor Brown, Faith Ellen, and Eric Ruppert. Pragmatic primitives for non-blocking data structures. In Proceedings of the 32nd ACM Symposium on Principles of Distributed Computing, PODC'13, pages 13-22, 2013. Google Scholar
  4. Trevor Brown, Faith Ellen, and Eric Ruppert. A general technique for non-blocking trees. In Proceedings of the 19th ACM Symposium on Principles and Practice of Parallel Programming, PPOPP'14, pages 329-342, 2014. Google Scholar
  5. Trevor Brown and Joanna Helga. Non-blocking k-ary search trees. In Proceedings International Conference on Principles of Distributed Systems, OPODIS'11, pages 207-221, 2011. Google Scholar
  6. Faith Ellen, Panagiota Fatourou, Joanna Helga, and Eric Ruppert. The amortized complexity of non-blocking binary search trees. In Proceedings of the 33rd ACM Symposium on Principles of Distributed Computing, PODC'14, pages 332-340, 2014. Google Scholar
  7. Faith Ellen, Panagiota Fatourou, Eleftherios Kosmas, Alessia Milani, and Corentin Travers. Universal constructions that ensure disjoint-access parallelism and wait-freedom. In Proceedings of the 31st ACM Symposium on Principles of Distributed Computing, PODC'12, pages 115-124, 2012. Google Scholar
  8. Faith Ellen, Panagiota Fatourou, Eric Ruppert, and Franck van Breugel. Non-blocking binary search trees. In Proceedings of the 29th ACM Symposium on Principles of Distributed Computing, PODC'10, pages 131-140, 2010. Google Scholar
  9. Zhixi Fang, Peiyi Tang, Pen-Chung Yew, and Chuan-Qi Zhu. Dynamic processor self-scheduling for general parallel nested loops. IEEE Transactions on Computers, 39(7):919-929, July 1990. Google Scholar
  10. Michael Greenwald. Two-handed emulation: how to build non-blocking implementations of complex data-structures using dcas. In Proceedings of the 21st Symposium on Principles of Distributed Computing, PODC'02, pages 260-269, 2002. Google Scholar
  11. Tim Harris, James Larus, and Ravi Rajwar. Transactional Memory, 2nd Edition. 2010. Google Scholar
  12. Timothy L. Harris, Keir Fraser, and Ian A. Pratt. A practical multi-word compare-and-swap operation. In Proceedings of the 16th International Conference on Distributed Computing, DISC'02, pages 265-279, 2002. Google Scholar
  13. Klaus Havelund and Thomas Pressburger. Model checking Java programs using Java PathFinder. Software Tools for Technology Transfer, 2(4):366-381, 2000. See URL:
  14. Maurice P. Herlihy and Jeannette M. Wing. Linearizability: a correctness condition for concurrent objects. ACM Transactions on Programming Languages and Systems, 12(3):463-492, July 1990. Google Scholar
  15. Jikuan Hu and Weiqing Wang. Algorithm research for vector-linked list sparse matrix multiplication. In Proceedings of the 2010 Asia-Pacific Conference on Wearable Computing Systems, APWCS'10, pages 118-121, 2010. Google Scholar
  16. Victor Luchangco, Mark Moir, and Nir Shavit. Nonblocking k-compare-single-swap. In Proceedings of the 15th ACM Symposium on Parallel Algorithms and Architectures, SPAA'03, pages 314-323, 2003. Google Scholar
  17. Matthias Pfeffer, Theo Ungerer, Stephan Fuhrmann, Jochen Kreuzinger, and Uwe Brinkschulte. Real-time garbage collection for a multithreaded Java microcontroller. Real-Time Systems, 26(1):89-106, January 2004. Google Scholar
  18. Niloufar Shafiei. Non-blocking Patricia tries with replace operations. In Proceedings of the 33rd International Conference on Distributed Computing Systems, ICDCS'13, pages 216-225, 2013. Google Scholar
  19. Niloufar Shafiei. Non-blocking data structures handling multiple changes atomically. PhD thesis, Department of Electrical Engineering and Computer Science, York University, Toronto, Canada, August 2015. Google Scholar
  20. Håkan Sundell. Wait-free multi-word compare-and-swap using greedy helping and grabbing. International Journal of Parallel Programming, 39(6):694-716, 2011. Google Scholar
  21. Håkan Sundell and Philippas Tsigas. Lock-free deques and doubly linked lists. Journal of Parallel and Distributed Computing, 68(7):1008-1020, 2008. Google Scholar
  22. John Turek, Dennis Shasha, and Sundeep Prakash. Locking without blocking: Making lock based concurrent data structure algorithms nonblocking. In Proceedings of the 11th ACM Symposium on Principles of Database Systems, PODS'92, pages 212-222, 1992. Google Scholar
  23. John D. Valois. Lock-free linked lists using compare-and-swap. In Proceedings of the 14th ACM Symposium on Principles of Distributed Computing, PODC'95, pages 214-222, 1995. Google Scholar