A thread is a context of execution within a program. Multithreaded programming deals with designing a program to have parts of it execute concurrently.

Media publications

  • Application-Level Abstractions for Lock-Free Data Sharing Describes lock-free data sharing, otherwise known as "wait-free data sharing" as an alternative to the use of locks. (Published 2007-12-21 00:00:00)
  • Apply Critical Sections Consistently Critical sections are the One True Tool for guaranteeing mutual exclusion on shared variables. Like most tools, these must be applied consistently, and with the intended meanings. (Published 2007-10-10 00:00:00)
  • Avoiding the Perils of C++0x Data Races Find out what dangers race conditions in general and C++0x data races in particular pose to concurrent code, as well as the strategies for avoiding them. (Published 2009-09-10 00:00:00)
  • Break Up and Interleave Work to Keep Threads Responsive Breaking up is hard to do, but interleaving can be even subtler. (Published 2009-06-15 00:00:00)
  • Concurrency in the D Programming Language Andrei Alexandrescu explains recent hardware changes allowing concurrency and how the D programming languages addresses these possibilities. (Published 2010-07-06 00:00:00)
  • Deadlock: The Problem and a Solution This article explains what deadlocks are and describes ways of circumventing deadlocks. (Published 2008-09-18 00:00:00)
  • Design for Manycore Systems This column is about why it's time right now to think about systems with lots of cores. In short: Software is the (only) gating factor; as that gate falls, hardware parallelism is coming more and sooner than many people yet believe. (Published 2009-08-11 00:00:00)
  • Fundamental Concepts of Parallel Programming Explains fundamental concepts for moving from a linear to a parallel programming model (Published 2008-11-13 00:00:00)
  • Fundamentals of Multithreading Technical article, covering Amdahl's Law, latencies and bandwidth, on-chip multiprocessing, Jackson technology, and simultaneous multithreading. (SystemLogic.net) (Published 2001-06-15 00:00:00)
  • It's (Not) All Been Done Every decade or so there is a major revolution in the way software is developed. But, unlike the object and web revolutions, the concurrency revolution can be seen coming. (Published 2006-09-01 00:00:00)
  • It's Not Always Nice To Share It isn't just languages that have poor support for thread local storage, but operating systems too (Published 2009-05-21 00:00:00)
  • Lock Options 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. It can be applied to programs in which the number of locks is fixed and known up front. (Published 2008-12-03 00:00:00)
  • Lock-Free Code: A False Sense of Security Writing lock-free code can confound anyone-even expert programmers, as Herb shows in this article. (Published 2008-08-05 00:00:00)
  • Lock-free Interprocess Communication Interprocess communication is an essential component of modern software engineering. 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. (Published 2006-06-15 00:00:00)
  • Maximize Locality, Minimize Contention Explains why in the concurrent world, 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. (Published 2008-05-23 00:00:00)
  • Measuring Parallel Performance: Optimizing a Concurrent Queue Shows different ways of how to write a fast, internally synchronized queue, one that callers can use without any explicit external locking or other synchronization, and compares the performance. (Published 2008-12-01 00:00:00)
  • Multi-threaded Algorithm Implementations 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. (Published 2009-06-18 00:00:00)
  • Multi-threaded Debugging Techniques Describes a number of general purpose debugging techniques for multi-threaded applications. (Published 2007-04-23 00:00:00)
  • Multithreaded File I/O So far multithreaded file I/O is a under-researched field. Although its simple to measure, there is not much common knowledge about it. The measurements presented here show that multithreading can improve performance of file access directly, as well as indirectly by utilizing available cores to process the data read. (Published 2009-09-28 00:00:00)
  • Practical Lock-Free Buffers Looks at how lock-free programming avoids system failure by tolerating individual process failures. (Published 2009-08-26 00:00:00)
  • Prefer Futures to Baked-In "Async APIs" Explains that it's important to separate "what" from "how" when designing concurrent APIs. (Published 2010-01-15 00:00:00)
  • Prefer Structured Lifetimes: Local, Nested, Bounded, Deterministic What's good for the function and the object is also good for the thread, the task, and the lock. (Published 2009-11-11 00:00:00)
  • Real-world Concurrency Describes some key principles that will help mastering the "black art" of writing multithreaded code. (Published 2008-09-01 00:00:00)
  • Sharing Is the Root of All Contention Sharing requires waiting and overhead, 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. (Published 2009-02-13 00:00:00)
  • The Free Lunch Is Over: A Fundamental Turn Toward Concurrency in Software The biggest sea change in software development since the OO revolution is knocking at the door, and its name is Concurrency. (Published 2005-03-01 00:00:00)
  • The Many Faces of Deadlock Explains that deadlock can happen whenever there is a blocking (or waiting) cycle among concurrent tasks. (Published 2008-07-31 00:00:00)
  • The Pillars of Concurrency This article makes the case that a consistent mental model is needed to talk about concurrency. (Published 2007-07-02 00:00:00)
  • The Problem with Threads Argues that for concurrent programming to become mainstream, threads must be discarded as a programming model. Nondeterminism should be judiciously and carefully introduced where needed, and it should be explicit in programs. (Published 2006-05-01 00:00:00)
  • Understanding Parallel Performance Explains how to accurately analyze the real performance of parallel code and lists some basic considerations and common costs. (Published 2008-10-31 00:00:00)
  • Use Lock Hierarchies to Avoid Deadlock Explains how to use lock hierarchies to avoid deadlock by assigning each shared resource a level that corresponds to its architectural layer. (Published 2007-12-11 00:00:00)
  • Use Thread Pools Correctly: Keep Tasks Short and Nonblocking A thread pool hides a lot of details, 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. (Published 2009-04-13 00:00:00)
  • Use Threads Correctly = Isolation + Asynchronous Messages Motivates and illustrate best practices for using threads - techniques that will make concurrent code easier to write correctly and to reason about with confidence. (Published 2009-03-16 00:00:00)
  • volatile - Multithreaded Programmer's Best Friend Discusses the usage of the volatile keyword in multithreaded C++ programs. (Published 2001-02-01 00:00:00)
  • Welcome to the Jungle Herb Sutter is looking at how mainstream hardware is becoming permanently parallel, heterogeneous, and distributed. (Published 2011-12-29 00:00:00)
  • What's New in Boost Threads? The Boost.Thread library, which enables the use of multiple threads of execution with shared data in portable C++ code, has undergone some major changes. (Published 2008-10-24 00:00:00)
  • Writing Lock-Free Code: A Corrected Queue Explores lock-free code by focusing on creating a lock-free queue. (Published 2008-09-29 00:00:00)

Mali oglasi

Dragan 065/884-8890
Iskusni bravari rade hale, garaže, panelima leksanom, kao i kapije, ograde, natkrivanje terasa.

Green Smarthaus +381 65 477 5001
Najpovoljnije i najkvalitetnije montažne kuće u Srbiji, uvoz iz Austrije. Eksluzivni najprodavaniji modeli. Proverite sajt www.smarthaus.rs.

Nikolija +49 176 7884 4021
Minhen i okolina - tražim posao čuvanja deteta, ili dece. Imam jako dobro iskustvo, predana sam i pedantna. Za sve dodatne informacije, možete me kontaktirati. Molim, samo ozbiljne ponude.

Jasmina 060/184-9309
Potrebni preprodavci božićnih ježića od žita. Ručni rad, mali su, simpatični, cena je povoljna i postoji mogućnost pristojne zarade pred Novu godinu.

Edo +385 98 265 705
Selidbe i dostave u Evropsku uniju, i iz Evropske unije, vršim povoljno velikim kombijem.

SZR Limaks Beška +381 022 570 799
Proizvodnja i prodaja - kvarcne peći i kaloriferi. Kvarcne grejalice za brzo zagrevanje, sa i bez daske. www.limaks.co.rs

Inter CAFFE

40 korisnika prisutno: 3 registrovanih, 1 skrivenih i 36 senkica. Ulogovani: cesko, galeksic, niko650 (01:08)

Bolje te vidim kad sklopim oči - Milan Višnjić
Uto 16.12.2014 8:31, micha@Umetnost
Jedan od cudnijih snova
Pon 15.12.2014 15:58, jeka1983@Sanovnik forum
Iz moje svaštare
Pon 15.12.2014 12:48, micha@Umetnost
Sanjam stalno bivseg momka. Da li to ista znaci?
Sre 10.12.2014 7:59, danielarmd@Sanovnik forum
Muzicki kutak - pjesme za prijatelje
Sre 10.12.2014 0:11, apprivoiser@Umetnost
Poezija - najlepsi stihovi
Sub 06.12.2014 10:32, Wind@Umetnost
Filigranska kapija od stihova - Dejan Milenković
Sub 06.12.2014 1:28, tragalac@Umetnost
Recepti, jela od mesa - rostiljijada
Sub 06.12.2014 0:45, niko650@Životni stil

Virtuelne razglednice

za rodjendan, godišnjicu braka, srećnu slavu, ženidbu, udaju, položen vozački, prijem u radni odnos...