Kurs om hur du programmerar fler-trådade (multi-threaded) applikationer med Modern C++
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.
Snabbfakta
Namn
C++ för fler-trådade applikationer
Ämne
C++ och C
URI
cxx/cxx-threads
Längd
3 dagar
Nivå
Advanced
Målgrupp
Rutinerade C++ programmerare
Förkunskaper
Kunna programmera i C++
Programvara & Verktyg
GNU C++ Compiler, version 10 or later
JetBrains CLion
Ubuntu Linux
Kursdatum
Här ser du vilka kursdatum som är tillgängliga. Klicka på en av datumknapparna för att anmäla dig till
ett kurstillfälle. På kursen pratar läraren svenska, medan vårt kursmaterial alltid är författat på
engelska.
Fjärrkurs
Du sitter bekvämt framför datorn och deltar i kursen via internet.
Vi använder programvaran Zoom för alla våra fjärrkurser.
I priset ingår kursmaterial som PDF.
Pris: 15 000 kr + moms
Klassrumskurs
Du sitter bekvämt i ett av våra klassrum, vilka finns centralt placerade
i Stockholms innerstad (Östermalmstorg).
I priset ingår tryckt kursmaterial (och som PDF), samt kaffe/te med smörgås på
förmiddagen och kaffe/te med bulle på eftermiddagen.
Pris: 20 000 kr + moms
Just nu finns det inga datum tillgängligt.
Titta förbi om några dagar eller kontakta oss.
Företagsanpassad Kurs
Om ni är tre eller fler personer från samma företags, kan ni beställa en företagsanpassad
kurs. Då håller vi kursen på ett datum som passar er. Antingen på plats i era lokaler
eller som en fjärrkurs. Vi kan också hålla den muntliga framställningen på engelska.
Klicka på knappen nedan för att be om en offert.
Här är ett sammandrag i punktform av vad du får lära dig på kursen.
Eftersom kursmaterialet är författat på engelska, så återger vi sammandraget
också på engelska.
Program with POSIX Threads directly in C
Program with threads in C++, by encapsulating the C API
Program with threads in C++11
Understand and deal with problem areas such as critical sections, race conditions and deadlocks
Use mutex and conditions in both POSIX and C++11
Understand and use promises/futures in C++11
Kursinnehåll
Eftersom kursmaterialet är författat på engelska, så återger vi innehållet
också på engelska.
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 parameters 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 using C++11
C++ Futures
Understanding C++11 promises & futures
Implementing Extended Rendezvous using C++11 futures