Lecture 13: Threads

• A computer program in execution.
• A process contains the memory and state of the program being run on a computer.
• Threads (of execution) are different than processes such that:
  • A program unit that is executed independently of other parts of your program.
  • A process may create many threads
    • An OS manages threads similar to a process, BUT
      • threads shares the memory space of the main process.
  • A C++ application starts with a single main thread.

So, a process is a unit of isolation: it is isolated from other processes in terms of resource control (accessing memory, doing I/O, etc.). A thread is a unit of scheduling: The OS schedules one thread to execute on a processor at a time.Terms and conditions may apply So,

• a process is an instance of a program that the OS may run, suspend, etc.
• a thread is a stream of execution within a process.

• For multi-core processors, you can design your program such that several parts of it work concurrently.
• Each processor (core) runs instructions in parallel.
  • For single-core architectures, it provides the illusion that something is working concurrently, but the processor is shared among all programs.
  • A a single thread can only be executed on a single core at any given time.

• Concurrency is important in computer science.
  • For example, working on "parts of a problem" concurrently can improve performance if the parts can be done independently.
  • Many applications use concurrency for performance reasons, for example:
    • Web servers process requests concurrently
    • We browsers fetch / render images concurrently
  • Embarrassingly Parallel problems are usually a good fit for concurrent computing
    • Monte-carlo simulations are embarrassingly parallel – the result is the average (expected) scenario based on independent executions.
• It is important to distinguish concurrency from parallelism: Concurrency is when the execution of two threads/pieces of computation can interleave, and parallelism is when they happen in parallel. You can have concurrency without parallelism: a web server can serve thousands of requests concurrently on a computer with only 8 processor cores.

# Makefile
bank:
    g++ -o main -std=c++17 main.cpp bank.cpp

// Bank.h

class Bank {
public:
    Bank();
    void deposit(double amount);
    double getBalance();
private:
    double totalBalance;
};

// Bank.cpp

#include "Bank.h"

Bank::Bank() {
    totalBalance = 0;
}

void Bank::deposit(double amount) {
    totalBalance += amount;
}

double Bank::getBalance() {
    return totalBalance;
}

#include <iostream>
#include <thread>
#include "Bank.h"

using namespace std;

void run(Bank* b) {
    for (int i = 0; i < 10000; i++) { b->deposit(10); }
}

int main() {
    Bank* bank = new Bank();
    thread t1(run, bank);
    thread t2(run, bank);
    t1.join();
    t2.join();
    cout << "---" << endl;
    cout << bank->getBalance() << endl;
    return 0;
}

• Expected balance is $200000 by the end of execution, but generally is not (unless we get lucky…).

• a multi-threaded locking mechanism that only allows a single thread to execute code.
  • Only one thread may acquire the lock at any given time.
  • If a thread obtains a lock on a mutex, no other thread can access the code until the lock is released (unlocked).
    • One way to provide atomic transactions and avoid race conditions between threads.
    • Another common way is to use Semaphores, but we won't cover this construct in this class.
• There are other, equivalent synchronization mechanisms that are more suitable for some problems. You will learn about them in CS 170.

// Bank.h
#include <mutex>

class Bank {
public:
    Bank();
    void deposit(double amount);
    double getBalance();
private:
    double totalBalance;
    std::mutex mutex;
};

// Bank.cpp

#include "Bank.h"

Bank::Bank() {
    totalBalance = 0;
}

void Bank::deposit(double amount) {
    mutex.lock();
    totalBalance += amount;
    mutex.unlock();
}

double Bank::getBalance() {
    return totalBalance;
}

#include <iostream>
#include <thread>
#include "Bank.h"

using namespace std;

void run(Bank* b) {
    for (int i = 0; i < 10000; i++) { b->deposit(10); }
}

int main() {
    Bank* bank = new Bank();
    thread t1(run, bank);
    thread t2(run, bank);
    t1.join();
    t2.join();
    cout << "---" << endl;
    cout << bank->getBalance() << endl;
    return 0;
}

• Using the mutex locking object, we now consistently have an ending balance of $200000.

• A situation where two (or more) threads are waiting on each other to release a resource, where each of the threads have a lock on the dependent resources.
• Execution is halted and cannot move forward in this situation.