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...
- Part Bibliography on Threads and Multithreading www
Part of the Computer Science Bibliography Collection. Bibliography on Threads and Multithreading.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- Bil comp.programming.threads FAQ www
Bil Lewis's collection of frequently asked questions. comp.programming.threads FAQ.
- 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.
- 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.
- 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.
- 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.
- Frequently comp.programming.threads FAQ www
Frequently asked questions (by Bryan O'Sullivan). comp.programming.threads FAQ.
- 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.
- 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?.
- 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.
- 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.
- 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.
- Looks Practical Lock-Free Buffers www
Looks at how lock-free programming avoids system failure by tolerating individual process failures. Practical Lock-Free Buffers.
- 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++.
- 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.
- Describes Real-world Concurrency www
Describes some key principles that will help mastering the "black art" of writing multithreaded code. Real-world Concurrency.
- 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.
- 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.
- 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.
- 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 Fundamental Concepts of Parallel Programming www
Explains fundamental concepts for moving from a linear to a parallel programming model Fundamental Concepts of Parallel Programming.
- 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.
- Describes Multi-threaded Debugging Techniques www
Describes a number of general purpose debugging techniques for multi-threaded applications. Multi-threaded Debugging Techniques.
- 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.
- 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.
- So Multithreaded File I/O www
Multithreaded File I/O.
- 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".
- 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.
- 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.
- Compares A Thread Performance Comparison www
Compares Windows NT and Solaris on a symmetric multiprocessor machine. A Thread Performance Comparison.
- 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.
- 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.
- 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.
- 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.
- 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.
- This Foundations of Multithreaded, Parallel, and Distributed Programming www
This book teaches the fundamental concepts of multithreaded, Multithreaded, Parallel, and Distributed Programming, parallel and distributed computing. Emphasizes how to solve problems, with correctness the primary concern and performance an important, but secondary, concern. (Gregory R. Andrews) Foundations of Multithreaded, Parallel, and Distributed Programming.
- 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.
- Higher RT++ www
Higher order threads for C++; tutorial and reference manual. RT++. RT++.
- 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.
- 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?.
- 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.
- 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.
- 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.
- An Await && Locks www
An expressive C++ thread synchronization library. Await && Locks.
- The C++ Threads www
The aim of this library is to provide the programmer with an easy to use class, Threads, that can be further inherited to provide a rich set of threaded functionality rarely seen in a Linux environment. C++ Threads.
- Papers The Alef Concurrent Programming Language www
Papers describing Plan 9's Alef programming language by Phil Winterbottom. The Alef Concurrent Programming Language.
- Concurrent, ChucK www
Concurrent, ChucK, time-based, on-the-fly, audio programming language, supports precise, fundamental level of expressiveness, multiple, simultaneous, dynamic control rates, ability to add, remove, modify code as programs run. ChucK.
- Suggests A Proposal for Fixing the Java Programming Language's Threading Problems www
Suggests that the Java threading model is possibly the weakest part of the language. Proposal for Fixing the Java Programming Language's Threading Problems. This article proposes significant changes and additions to the Java language. A Proposal for Fixing the Java Programming Language's Threading Problems.
- Gives Achieve Strong Performance With Threads, Part 1 www
Gives an introduction to threads and explores the Thread class and runnables. Achieve Strong Performance With Threads, Part 1.
- An Agnix www
An open source project, Agnix, which has been founded to provide an educational, network operating system kernel. Agnix.
- By The Basic Kernel Source Code Secrets www
By William Jolitz and Lynne Jolitz (authors of 386BSD OS). Basic Kernel Source Code Secrets. Good book to learn the kernel internals of 386 architecture operating systems. The Basic Kernel Source Code Secrets.
- Frequently LinuxThreads FAQ www
Frequently asked questions about the kernel-level multi-threading library for Linux. LinuxThreads FAQ.
- Dives Multithreaded Programming (pthreads Tutorial) www
Dives into the world of threads with a little bit of "theory" first. Programming (pthreads Tutorial). Examine thread synchronization primitives and how to use POSIX pthreads. Finally, it finishes off with thread performance and a brief overview of multiprocess programming. Multithreaded Programming (pthreads Tutorial).
- Discusses Pushing the Limits of Windows: Processes and Threads www
Discusses the limits on the maximum number of threads and processes supported on Windows. the Limits of Windows: Processes and Threads. Describes the difference between a thread and a process, surveys thread limits and then investigates process limits Pushing the Limits of Windows: Processes and Threads.
- Presents Scalable Multithreaded Programming with Thread Pools www
Presents some of the concepts of multithreaded programming and shows some simple ways to introduce threaded execution with OpenMP and thread pools. Multithreaded Programming with Thread Pools. Also demonstrates how to use Visual Studio 2010 to measure the improvement in performance gained from these techniques. Scalable Multithreaded Programming with Thread Pools.
- 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