A thread is a context of execution within a program. Multithreaded programming deals with designing a program to have parts of it execute concurrently. Threads Programming Computers.
Threads is a 1984 BAFTA award-winning British television drama, produced jointly by the BBC, Nine Network and Western-World Television Inc. (wikipedia)
- Thread (computing) The smallest sequence of programmed instructions that can be managed independently by a scheduler...
- Screw thread A helical structure used to convert between rotational and linear movement or force.
- Threads A 1984 British television drama jointly produced by the BBC, Nine Network and Western-World...
- Thread (yarn) A type of yarn used for sewing.
- Thread (unit of measurement) A cotton yarn measure.
- Thread (film) A 2016 Greek film written and directed by Alexander Voulgaris.
- Conversation threading A feature used by many email clients, bulletin boards, newsgroups, and Internet forums in which...
- Threads (Battlefield Band album) The nineteenth album by Battlefield Band and their thirteenth studio album, released in 1995 on...
- Explains Avoid Exposing Concurrency: Hide It Inside Synchronous Methods www
Explains where to start when trying to add concurrency to a mass of existing code. Avoid Exposing Concurrency: Hide It Inside Synchronous Methods.
- Very Protothreads www
Very lightweight stackless threads; give linear code execution for event-driven systems, Protothreads, designed to use little memory; library is pure C, no platform-specific Assembly; usable with or without OS. Open source, BSD-type license. Protothreads.
- Shows Measuring Parallel Performance: Optimizing a Concurrent Queue www
Shows different ways of how to write a fast, Parallel Performance: Optimizing a Concurrent Queue, internally synchronized queue, one that callers can use without any explicit external locking or other synchronization, and compares the performance. Measuring Parallel Performance: Optimizing a Concurrent Queue.
- Critical Apply Critical Sections Consistently www
Critical sections are the One True Tool for guaranteeing mutual exclusion on shared variables. Critical Sections Consistently. Like most tools, these must be applied consistently, and with the intended meanings. Apply Critical Sections Consistently.
- Explores Writing Lock-Free Code: A Corrected Queue www
Explores lock-free code by focusing on creating a lock-free queue. Writing Lock-Free Code: A Corrected Queue.
- Gives Introduction to Priority Inversion www
Gives an introduction to priority inversion and shows a pair of techniques to avoid them. Introduction to Priority Inversion.
- The What's New in Boost Threads? www
The Boost. New in Boost Threads?.Thread library, which enables the use of multiple threads of execution with shared data in portable C++ code, has undergone some major changes. What's New in Boost Threads?.
- This Concurrent Programming: Principles and Practice www
This book provides an in-depth overview of underlying principles as well as practical techniques that can be used to design concurrent programs. Programming: Principles and Practice. (Greg Andrews) Concurrent Programming: Principles and Practice.
- Higher RT++ www
Higher order threads for C++; tutorial and reference manual. RT++. RT++.
- Bil comp.programming.threads FAQ www
Bil Lewis's collection of frequently asked questions. comp.programming.threads FAQ.
- This Deadlock: The Problem and a Solution www
This article explains what deadlocks are and describes ways of circumventing deadlocks. Deadlock: The Problem and a Solution.
- In-preparation Is Parallel Programming Hard, And, If So, What Can You Do About It? www
In-preparation book about parallel programming. Parallel Programming Hard, And, If So, What Can You Do About It?. Is Parallel Programming Hard, And, If So, What Can You Do About It?.
- Discusses volatile - Multithreaded Programmer's Best Friend www
Discusses the usage of the volatile keyword in multithreaded C++ programs. volatile - Multithreaded Programmer's Best Friend.
- A Use Thread Pools Correctly: Keep Tasks Short and Nonblocking www
A thread pool hides a lot of details, Thread Pools Correctly: Keep Tasks Short and Nonblocking, but to use it effectively some awareness of some things a pool does under the covers is needed to avoid inadvertently hitting performance and correctness pitfalls. Use Thread Pools Correctly: Keep Tasks Short and Nonblocking.
- Writing Lock-Free Code: A False Sense of Security www
Writing lock-free code can confound anyone-even expert programmers, Code: A False Sense of Security, as Herb shows in this article. Lock-Free Code: A False Sense of Security.
- Herb Welcome to the Jungle www
Herb Sutter is looking at how mainstream hardware is becoming permanently parallel, the Jungle, heterogeneous, and distributed. Welcome to the Jungle.
- Explains Prefer Futures to Baked-In "Async APIs" www
Explains that it's important to separate "what" from "how" when designing concurrent APIs. Prefer Futures to Baked-In "Async APIs".
- Sharing Sharing Is the Root of All Contention www
Sharing requires waiting and overhead, the Root of All Contention, and is a natural enemy of scalability. This article focuses on one important case, namely mutable (writable) shared objects in memory, which are an inherent bottleneck to scalability on multicore systems. Sharing Is the Root of All Contention.
- Focuses Software and the Concurrency Revolution www
Focuses on the implications of concurrency for software and its consequences for both programming languages and programmers. and the Concurrency Revolution. (Herb Sutter and James Larus) Software and the Concurrency Revolution.
- Small State Threads Library www
Small application library for writing fast, Threads Library, highly scalable Internet programs on Unix-like platforms. Open source, MPL or GPL. State Threads Library.
- Frequently comp.programming.threads FAQ www
Frequently asked questions (by Bryan O'Sullivan). comp.programming.threads FAQ.
- Andrei Concurrency in the D Programming Language www
Andrei Alexandrescu explains recent hardware changes allowing concurrency and how the D programming languages addresses these possibilities. Concurrency in the D Programming Language.
- Motivates Use Threads Correctly = Isolation + Asynchronous Messages www
Motivates and illustrate best practices for using threads - techniques that will make concurrent code easier to write correctly and to reason about with confidence. Threads Correctly = Isolation + Asynchronous Messages. Use Threads Correctly = Isolation + Asynchronous Messages.
- Explains The Many Faces of Deadlock www
Explains that deadlock can happen whenever there is a blocking (or waiting) cycle among concurrent tasks. The Many Faces of Deadlock.
- Argues The Problem with Threads www
Argues that for concurrent programming to become mainstream, Problem with Threads, threads must be discarded as a programming model. Nondeterminism should be judiciously and carefully introduced where needed, and it should be explicit in programs. The Problem with Threads.
- Most Generic Synchronization Policies in C++ www
Most uses of synchronization code in multi-threaded applications fall into a small number of high-level “usage patterns”, Synchronization Policies in C++, or what can be called generic synchronization policies (GSPs). This paper illustrates how the use of such GSPs simplify the writing of thread-safe classes. In addition, this paper presents a C++ class library that implements commonly-used GSPs. Generic Synchronization Policies in C++.
- Presents Lock Options www
Presents a solution to races and deadlocks based on a well-known deadlock-avoidance protocol and shows how it can be enforced by the compiler. Options. It can be applied to programs in which the number of locks is fixed and known up front. Lock Options.
- Explains Use Lock Hierarchies to Avoid Deadlock www
Explains how to use lock hierarchies to avoid deadlock by assigning each shared resource a level that corresponds to its architectural layer. Use Lock Hierarchies to Avoid Deadlock.
- Compares A Thread Performance Comparison www
Compares Windows NT and Solaris on a symmetric multiprocessor machine. A Thread Performance Comparison.
- The The Free Lunch Is Over: A Fundamental Turn Toward Concurrency in Software www
The biggest sea change in software development since the OO revolution is knocking at the door, Free Lunch Is Over: A Fundamental Turn Toward Concurrency in Software, and its name is Concurrency. The Free Lunch Is Over: A Fundamental Turn Toward Concurrency in Software.
- What's Prefer Structured Lifetimes: Local, Nested, Bounded, Deterministic www
What's good for the function and the object is also good for the thread, Structured Lifetimes: Local, Nested, Bounded, Deterministic, the task, and the lock. Prefer Structured Lifetimes: Local, Nested, Bounded, Deterministic.
- A 1024cores www
A site devoted to lock-free algorithms, 1024cores, scalable architecture, multicore design patterns, parallel computations, threading libraries, tooling support and related topics. 1024cores.
- Describes Multi-threaded Debugging Techniques www
Describes a number of general purpose debugging techniques for multi-threaded applications. Multi-threaded Debugging Techniques.
- Breaking Break Up and Interleave Work to Keep Threads Responsive www
Breaking up is hard to do, and Interleave Work to Keep Threads Responsive, but interleaving can be even subtler. Break Up and Interleave Work to Keep Threads Responsive.
- This The Pillars of Concurrency www
This article makes the case that a consistent mental model is needed to talk about concurrency. The Pillars of Concurrency.
- Interprocess Lock-free Interprocess Communication www
Interprocess communication is an essential component of modern software engineering. Interprocess Communication. Often, lock-free IPC is accomplished via special processor commands. This article propose a communication type that requires only atomic writing of processor word from processor cache into main memory and atomic processor word reading from main memory into the processor register or processor cache. Lock-free Interprocess Communication.
- Explains Understanding Parallel Performance www
Explains how to accurately analyze the real performance of parallel code and lists some basic considerations and common costs. Understanding Parallel Performance.
- Find Avoiding the Perils of C++0x Data Races www
Find out what dangers race conditions in general and C++0x data races in particular pose to concurrent code, the Perils of C++0x Data Races, as well as the strategies for avoiding them. Avoiding the Perils of C++0x Data Races.
- Part Bibliography on Threads and Multithreading www
Part of the Computer Science Bibliography Collection. Bibliography on Threads and Multithreading.
- Technical Fundamentals of Multithreading www
Technical article, Multithreading, covering Amdahl's Law, latencies and bandwidth, on-chip multiprocessing, Jackson technology, and simultaneous multithreading. (SystemLogic.net) Fundamentals of Multithreading.
- This Design for Manycore Systems www
This column is about why it's time right now to think about systems with lots of cores. for Manycore Systems. In short: Software is the (only) gating factor; as that gate falls, hardware parallelism is coming more and sooner than many people yet believe. Design for Manycore Systems.
- Looks Practical Lock-Free Buffers www
Looks at how lock-free programming avoids system failure by tolerating individual process failures. Practical Lock-Free Buffers.
- Describes Application-Level Abstractions for Lock-Free Data Sharing www
Describes lock-free data sharing, Abstractions for Lock-Free Data Sharing, otherwise known as "wait-free data sharing" as an alternative to the use of locks. Application-Level Abstractions for Lock-Free Data Sharing.
- Explores Multi-threaded Algorithm Implementations www
Explores effective uses of threads by looking at a multi-threaded implementation of the QuickSort algorithm and reports on situations where using threads will not help. Multi-threaded Algorithm Implementations.
- It It's Not Always Nice To Share www
It isn't just languages that have poor support for thread local storage, Not Always Nice To Share, but operating systems too It's Not Always Nice To Share.
- Every It's (Not) All Been Done www
Every decade or so there is a major revolution in the way software is developed. (Not) All Been Done. But, unlike the object and web revolutions, the concurrency revolution can be seen coming. It's (Not) All Been Done.
- Explains Maximize Locality, Minimize Contention www
Explains why in the concurrent world, Locality, Minimize Contention, locality is a first-order issue that trumps most other performance considerations. Now locality is no longer just about fitting well into cache and RAM, but to avoid scalability busters by keeping tightly coupled data physically close together and separately used data far, far apart. Maximize Locality, Minimize Contention.
- Explains Fundamental Concepts of Parallel Programming www
Explains fundamental concepts for moving from a linear to a parallel programming model Fundamental Concepts of Parallel Programming.
- So Multithreaded File I/O www
Multithreaded File I/O.
- Describes Real-world Concurrency www
Describes some key principles that will help mastering the "black art" of writing multithreaded code. Real-world Concurrency.
- An Await && Locks www
An expressive C++ thread synchronization library. Await && Locks.
- A Fiber Pool www
A fiber-based multicore synchronization library for Windows XP and Vista. Fiber Pool.
- MC# MC# www
MC# (Multiprocessor C#) is a high-level object-oriented language based on . MC#.NET platform made for developing complex industrial program systems that can use multiprocessors. MC#.
- Fault-tolerant FT Languages Page www
Fault-tolerant projects, Languages Page, goal: enhance language support for distributed programs with FT needs, most high-level languages lack good support for such, more so at system level; 3 projects described, FT-SR, FT-Linda, FTAG. FT Languages Page.
- Explains Going Atomic www
Explains how the new atomic variable classes in JDK 5. Atomic.0 enable the development of highly scalable nonblocking algorithms in the Java language. Going Atomic.
- Discussion Programming Java Threads in the Real World, Part 9 www
Discussion of two more architectural solutions to threading problems: a synchronous dispatcher (or 'reactor') and an asynchronous dispatcher (or 'active object'). Programming Java Threads in the Real World, Part 9.
- An Ace Operating System Project www
An open source operating system for X86 architecture. Operating System Project. It also contains documents, specifications explaining various hardware. Ace Operating System Project.
- Resources KernelNewbies.org www
Resources for programmers new to kernel hacking. KernelNewbies.org. Example code, FAQs, utilities for debugging modules. KernelNewbies.org.
- How POSIX Threads Explained, Part 3 www
How to use condition variables. POSIX Threads Explained, Part 3.
- A Measuring Lock Contention www
A mutex profiler called mutrace that in contrast to valgrind/drd does not virtualize the CPU instruction set, Lock Contention, making it a lot faster. In fact, the hooks mutrace relies on to profile mutex operations should only minimally influence application runtime. mutrace is not useful for finding synchronizations bugs, it is solely useful for profiling locks. Measuring Lock Contention.
- An POSIX Threads (pthreads) for Win32 www
An implementation of POSIX pthreads for Win32. Threads (pthreads) for Win32. [Open source, LGPL]. POSIX Threads (pthreads) for Win32.
- This Multithreaded Programming with Win32 www
This book describes techniques for designing and implementing multithreaded software applications. Multithreaded Programming with Win32.
- Online Wikipedia - Computer Programming www
Online encyclopedia article. Wikipedia - Computer Programming.
- Alexa: Threads Programming
Alexa Directory Top Sites: Threads Programming
- DMOZ: Threads Programming
dmoz.org Directory: Threads Programming