• Review the first multithreading example from this past Wednesday's lecture, highlighting similarities between multprocessing and multithreading, pointing out differences.
• Work through two versions of a multithreaded program where the main thread of execution shares data with each of the baby threads it creates.
  • Version 1 is intentionally broken to illustrate the most obvious of race conditions.
  • Version 2 provides a very simple fix so that the race condition is no longer present.
• Motivate my decision to move from C to C++ for its more robust and error-resistant treatment of threads.
• Work through two or three C++ threading examples.

• You're reading all of Section 12.1 and Sections 12.3 through Sections 12.8 right now, skipping those subsections that refer to networking and servers.
  • Chapter 12 is actually the fourth chapter of the reader.
  • Code examples are in C, but the concepts are largely the same regardless of language.
• Once we learn networking, we'll come back and hit on some of these excluded sections.

• Assignment 3 is due tonight, just before midnight.
• Assignment 4 is out as well, due a week from tomorrow (Tuesday) night.
• Midterm is on Friday, November 3^rd during normal class time in CEMEX Auditorium.

• Here's the introverts example we've seen before—this time in C++! (Full version of this program is online here).

#include <iostream>       // for cout, endl
#include <thread>         // for C++ thread support
#include "ostreamlock.h"  // for CS110 iomanipulators (oslock, osunlock) used to lock down streams
using namespace std;

static void recharge() {
  cout << oslock << "I recharge by spending time alone." << endl << osunlock;
}

static const size_t kNumIntroverts = 6;
int main(int argc, char *argv[]) {
  cout << "Let's hear from " << kNumIntroverts << " introverts." << endl      
  thread introverts[kNumIntroverts]; // declare array of empty thread handles
  for (thread& introvert: introverts)
    introvert = thread(recharge);    // move anonymous threads into empty handles
  for (thread& introvert: introverts)
    introvert.join();    
  cout << "Everyone's recharged!" << endl;
  return 0;
}    

• Features:
  • We declare an array of empty (e.g. non-joinable) thread handles as we did in the C version. (The thread is a class relatively new to C++, and the holy grail of thread documentation pages sits right here.)
  • We install the recharge function into temporary threads that are then moved (via operator=(thread&& other)) into an until-then empty thread handle.
    • This is a new form of operator= that fully transplants the contents of the thread on the right-hand side into the thread on the left-hand side, leaving the thread on the right side as fully gutted, as if it were zero-argument constructed (e.g. an empty, non-joinable thread handle).
    • This is an important clarification, because a traditional operator= would produce a second working copy of the same thread, and we don't want that. We instead want to initialize one of the threads within the original array to be one that now runs code. This is how we do that.
  • The join method, not surprisingly, is equivalent to the pthread_join function we've already learned about.
  • The prototype of the thread routine—in this case, recharge—can be anything (although the return type is always ignored, so it should be void unless the same function is being used in a non-threaded context, and a return value is useful there).
  • Big point: operator<<, unlike printf, is not thread-safe.
    • Even worse: a series of daisy-chained calls to operator<< is certainly not guaranteed to be executed as one, phatty atomic transaction.
      
    • Simple solution: I've constructed stream manipulators oslock and osunlock to lock down and subsequently release access to an ostream so that two independent threads are never trying to simultaneulously insert character data into a stream at the same time. In essence, oslock and osunlock are bookending our first critical region, which is a block of code that must be executed in full before any other thread can enter the same region, lest we see evidence of synchronization issues.

• Variable argument lists—the equivalent of the ellipsis in C—are supported via a new C++ feature called variadic templates.
• That means we have a good amount of flexibility in how we prototype our thread routines
  • There's no question this is better than the unsafe void * funkiness that pthreads provides.
• Here's a slightly more involed example where greet threads are configured to say hello a variable number of times. (Online version of the following program can be found right here).

static void greet(size_t id) {
  for (size_t i = 0; i < id; i++) {
    cout << oslock << "Greeter #" << id << " says 'Hello!'" << endl << osunlock;
    struct timespec ts = {
      0, random() % 1000000000
    };
    nanosleep(&ts, NULL);
  }    
  cout << oslock << "Greeter #" << id << " has issued all of his hellos, "
       << "so he goes home!" << endl << osunlock;
}

static const size_t kNumGreeters = 6;
int main(int argc, char *argv[]) {
  srandom(time(NULL));
  cout << "Welcome to Greetland!" << endl;    
  thread greeters[kNumGreeters];
  for (size_t i = 0; i < kNumGreeters; i++)
    greeters[i] = thread(greet, i + 1);
  for (thread& greeter: greeters)
    greeter.join();
  cout << "Everyone's all greeted out!" << endl;
  return 0;
}

• Consider the case where 10 ticket agents answer telephones at United Airlines to jointly sell 1000 airline tickets (looking for full program? click here):

static const unsigned int kBaseIDNumber = 101;
static const unsigned int kNumAgents = 10;
static const unsigned int kNumTickets = 1000;
static mutex ticketsLock;
static unsigned int remainingTickets = kNumTickets;

static void ticketAgent(size_t id) {
  while (true) {
    ticketsLock.lock();
    if (remainingTickets == 0) break;
    remainingTickets--;
    cout << oslock << "Agent #" << id << " sold a ticket! (" << remainingTickets 
         << " more to be sold)." << endl << osunlock;
    ticketsLock.unlock();
    if (shouldTakeBreak()) 
      takeBreak();
  }
  ticketsLock.unlock();
  cout << oslock << "Agent #" << id << " notices all tickets are sold, and goes home!" 
       << endl << osunlock;
}

int main(int argc, const char *argv[]) {
  thread agents[kNumAgents];
  for (size_t i = 0; i < kNumAgents; i++)
    agents[i] = thread(ticketAgent, kBaseIDNumber + i);
  for (thread& agent: agents)
    agent.join();
  cout << "End of Business Day!" << endl;
}

• Yes, we use global variables, but our defense here is that multiple threads all need access to a shared resource. static global variables are not at all uncommon in multithreaded programs (although larger programs would probably package them in a dedicated library or module).
• There's a significant critical region in this program, and we use a mutex object to mark the beginning and end of it.
  • We'll first write this program without the mutex to illustrate what the problems are.
  • We'll then insert the mutex to understand exactly how it solves it.