Kurs i C++ Programmering med Trådar

Kurs i C++ threads programmering baserat på såväl POSIX Threads och nya standarden C++ 11/14/17

Buggar i fler-trådade program anses ofta vara det besvärligaste man kan råka ut för som programmerare. Faktum är att det generella rådet är att inte stoppa in dem från början.

Om man tycker det rådet är aningen orealistiskt, så är det näst bästa att programmera enligt ett antal väl beprövade programmerings-idiom som undviker problemen. I denna kurs, fokuserar vi på just den strategin.

Denna kurs överlappar delvis med vår andra kurs "POSIX & C11 Threads Programming using C", men skiljer sig åt genom att dessutom kapsla in alla C data-typer i bättre C++ klasser, samt givetvis en ordentlig genomgång av threads i C++11/14/17.

Detta får du lära dig
  • Programmera med POSIX Threads direkt i C
  • Programmera med trådar i C++, genom att kapsla in C API:et
  • Programmera med trådar i C++11
  • Förstå och hantera problemområden som critical-sections, race-conditions och deadlocks
  • Använda mutex och conditions både i POSIX och C++11
  • Förstå och använda promises/futures i C++11
Kursinnehåll

Introduction to Threads and Concurrency

  • Concurrent vs. parallel
  • Scheduling
  • Synchronization
  • Virtual adress space organization
  • Overview of how a function-call is performed and why it's relevant to threads

POSIX Threads

  • Overview of the POSIX Threads C API
  • Creating a thread
  • Passing paramaters to a new thread
  • Configuring threads, like setting the stack-size
  • Implementing class Thread

The Critical Section Problem

  • Understanding the problem and its solution
  • Three conditions for the critical-section problem
  • POSIX mutex variables
  • Configuration
  • Handling timeouts
  • Avoiding self-deadlock
  • Implementing class Mutex
  • Implementing class Guard

The Race-Condition Problem

  • Understanding the problem and its solution
  • POSIX condition variables
  • Configuration
  • Handling timeouts
  • Understanding monitor semantics
  • The minimum amount of code to safely transfer data from one thread to another
  • Implementing class Condition
  • Implementing class MailBox

The Deadlock Problem

  • The concept resource
  • Understanding the problem and its solution
  • Four conditions for the deadlock problem
  • Preventing deadlocks
  • Detection of deadlocks

Synchronization and Other Data-Types

  • Read/Write locks
  • Barriers
  • Thread-local storage
  • Implementing classes for read/write locks
  • Implementing class Barrier
  • Implementing class ThreadLocalStorage

Semaphores

  • POSIX semaphores
  • Memory-based vs. file-based semaphores
  • Implementing class Semaphore
  • Implementing class FileSemaphore

Uni-directional Message Passing

  • What is message-passing
  • Handling pointer based messages
  • Understanding the message-queue concept and its synchronization requirements
  • Implementing class MessageQueue
  • Implementing class MessageThread
  • Implementing interface Receivable
  • Implementing a threads pipeline

Bi-directional Message Passing

  • N clients & 1 server
  • 1 client & N servers
  • Understanding Extended Rendezvous
  • Implementation of Extended Rendezvous
  • Understanding Futures
  • Implementation of Futures

Shared Memory

  • What is shared memory
  • Understanding the mmap() system call
  • The POSIX Shared Memory API
  • Implementing class SharedMemory

Threads & Processes

  • Creating processes
  • Waiting for process termination
  • Adapting mutexes and conditions for shared memory
  • Implementation of a message-queue in shared memory
  • Implementation of a threads pipeline between processes and via shared memory

A quick C++11/14/17 Primer

  • Highlights of the new standard relevant for the following chapters

Threads in C++11

  • Overview of the threads support first introduced in C++11
  • Using class thread
  • Usage of lambda expressions when defining threads

C++11 Synchronization

  • Using class mutex
  • Using class condition_variable
  • Usage of lock guards
  • Usage of multi-locking and avoidance of deadlocks
  • Implementation of class MessageQueue<T> using C++11

C++ Futures

  • Understanding C++11 promises & futures
  • Implementing Extended Rendezvous using C++11 futures
  • Spawning asynchronous tasks
SnabbFakta
NamnC++ Programmering med Trådar
Längd3 Dagar
NivåAdvanced
MålgruppErfarna C++ programmerare
FörkunskaperKännedom om Modern C++
Verktyg
  • GCC/G++ compiler, version 8 or later
  • Jetbrains CLion IDE
  • Ubuntu Linux @ VirtualBox or WLS @ Windows-10
KursDatum
DatumPlats Pris
2020-02-17Stockholm 19 000 kr
2020-03-09Stockholm 19 000 kr
2020-03-30Stockholm 19 000 kr
2020-04-14Stockholm 19 000 kr
2020-05-25Stockholm 19 000 kr
2020-06-15Stockholm 19 000 kr

Samma-Företags Rabatt

Vi ger 20% rabatt för tillkommande deltagare från samma företag vid samma kurs-tillfälle. Läs mer här.

Undervisningsspråk

Vårt tryckta kursmaterial är alltid författat på engelska. Den muntliga presentationen i våra klassrum är som regel på svenska, såvida inte samtliga deltagare samtycker till att vi genomför kursen på engelska.

Företagsintern Kurs

Om du beställer en företagsintern kurs kommer vi till er och håller kursen i era lokaler. Priset bestäms av vår prismodell och baseras på antalet kursdagar, antalet deltagare, samt i förekommande fall resa och logi.

Läs mer om vår prismodell och beställningsvillkor här.

Relaterade Kurser
KursDagarNivå
Linux Systemprogrammering i C++3AdvancedVisa
Modern C++ Fördjupning3 IntermediateVisa
C++ 11/14/17 för C++ Programmerare3IntermediateVisa
Modern C++5 BeginnerVisa
Modern C++ för Java Programmerare4 BeginnerVisa
POSIX Threads med C2AdvancedVisa