MODERN MULTITHREADING

Size: px

Start display at page:

Download "MODERN MULTITHREADING"

Regina Campbell
5 years ago
Views:

1 MODERN MULTITHREADING Implementing, Testing, and Debugging Multithreaded Java and C++/Pthreads/Win32 Programs RICHARD H. CARVER KUO-CHUNG TAI A JOHN WILEY & SONS, INC., PUBLICATION

3 MODERN MULTITHREADING

5 MODERN MULTITHREADING Implementing, Testing, and Debugging Multithreaded Java and C++/Pthreads/Win32 Programs RICHARD H. CARVER KUO-CHUNG TAI A JOHN WILEY & SONS, INC., PUBLICATION

6 Copyright 2006 by John Wiley & Sons, Inc. All rights reserved. Published by John Wiley & Sons, Inc., Hoboken, New Jersey. Published simultaneously in Canada. No part of this publication may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, electronic, mechanical, photocopying, recording, scanning, or otherwise, except as permitted under Section 107 or 108 of the 1976 United States Copyright Act, without either the prior written permission of the Publisher, or authorization through payment of the appropriate per-copy fee to the Copyright Clearance Center, Inc., 222 Rosewood Drive, Danvers, MA 01923, (978) , fax (978) , or on the web at Requests to the Publisher for permission should be addressed to the Permissions Department, John Wiley & Sons, Inc., 111 River Street, Hoboken, NJ 07030, (201) , fax (201) , or online at Limit of Liability/Disclaimer of Warranty: While the publisher and author have used their best efforts in preparing this book, they make no representations or warranties with respect to the accuracy or completeness of the contents of this book and specifically disclaim any implied warranties of merchantability or fitness for a particular purpose. No warranty may be created or extended by sales representatives or written sales materials. The advice and strategies contained herein may not be suitable for your situation. You should consult with a professional where appropriate. Neither the publisher nor author shall be liable for any loss of profit or any other commercial damages, including but not limited to special, incidental, consequential, or other damages. For general information on our other products and services or for technical support, please contact our Customer Care Department within the United States at (800) , outside the United States at (317) or fax (317) Wiley also publishes its books in a variety of electronic formats. Some content that appears in print may not be available in electronic formats. For more information about Wiley products, visit our web site at Library of Congress Cataloging-in-Publication Data: Carver, Richard H., 1960 Modern multithreading: implementing, testing, and debugging multithreaded Java and C++/Pthreads/Win32 programs / by Richard H. Carver and Kuo-Chung Tai. p. cm. Includes bibliographical references and index. ISBN (paper) ISBN (paper) 1. Parallel programming (Computer science) 2. Threads (Computer programs) I. Tai, Kuo-Chung. II. Title. QA C dc Printed in the United States of America

7 CONTENTS Preface xi 1 Introduction to Concurrent Programming Processes and Threads: An Operating System s View, Advantages of Multithreading, Threads in Java, Threads in Win32, Pthreads, C++ Thread Class, C++ Class Thread for Win32, C++ Class Thread for Pthreads, Thread Communication, Nondeterministic Execution Behavior, Atomic Actions, Testing and Debugging Multithreaded Programs, Problems and Issues, Class TDThread for Testing and Debugging, Tracing and Replaying Executions with Class Template sharedvariable<>, Thread Synchronization, 38 Further Reading, 38 References, 39 Exercises, 41 v

8 vi CONTENTS 2 The Critical Section Problem Software Solutions to the Two-Thread Critical Section Problem, Incorrect Solution 1, Incorrect Solution 2, Incorrect Solution 3, Peterson s Algorithm, Using the volatile Modifier, Ticket-Based Solutions to the n-thread Critical Section Problem, Ticket Algorithm, Bakery Algorithm, Hardware Solutions to the n-thread Critical Section Problem, Partial Solution, Complete Solution, Note on Busy-Waiting, Deadlock, Livelock, and Starvation, Deadlock, Livelock, Starvation, Tracing and Replay for Shared Variables, ReadWrite-Sequences, Alternative Definition of ReadWrite-Sequences, Tracing and Replaying ReadWrite-Sequences, Class Template sharedvariable<>, Putting It All Together, Note on Shared Memory Consistency, 74 Further Reading, 77 References, 78 Exercises, 79 3 Semaphores and Locks Counting Semaphores, Using Semaphores, Resource Allocation, More Semaphore Patterns, Binary Semaphores and Locks, Implementing Semaphores, Implementing P() and V(), VP() Operation, Semaphore-Based Solutions to Concurrent Programming Problems, Event Ordering, 96

9 CONTENTS vii Bounded Buffer, Dining Philosophers, Readers and Writers, Simulating Counting Semaphores, Semaphores and Locks in Java, Class countingsemaphore, Class mutexlock, Class Semaphore, Class ReentrantLock, Example: Java Bounded Buffer, Semaphores and Locks in Win32, CRITICAL SECTION, Mutex, Semaphore, Events, Other Synchronization Functions, Example: C++/Win32 Bounded Buffer, Semaphores and Locks in Pthreads, Mutex, Semaphore, Another Note on Shared Memory Consistency, Tracing, Testing, and Replay for Semaphores and Locks, Nondeterministic Testing with the Lockset Algorithm, Simple SYN-Sequences for Semaphores and Locks, Tracing and Replaying Simple PV-Sequences and LockUnlock-Sequences, Deadlock Detection, Reachability Testing for Semaphores and Locks, Putting It All Together, 160 Further Reading, 163 References, 164 Exercises, Monitors Definition of Monitors, Mutual Exclusion, Condition Variables and SC Signaling, Monitor-Based Solutions to Concurrent Programming Problems, Simulating Counting Semaphores, Simulating Binary Semaphores, Dining Philosophers, Readers and Writers, 187

10 viii CONTENTS 4.3 Monitors in Java, Better countingsemaphore, notify vs. notifyall, Simulating Multiple Condition Variables, Monitors in Pthreads, Pthreads Condition Variables, Condition Variables in J2SE 5.0, Signaling Disciplines, Signal-and-Urgent-Wait, Signal-and-Exit, Urgent-Signal-and-Continue, Comparing SU and SC Signals, Using Semaphores to Implement Monitors, SC Signaling, SU Signaling, Monitor Toolbox for Java, Toolbox for SC Signaling in Java, Toolbox for SU Signaling in Java, Monitor Toolbox for Win32/C++/Pthreads, Toolbox for SC Signaling in C++/Win32/Pthreads, Toolbox for SU Signaling in C++/Win32/Pthreads, Nested Monitor Calls, Tracing and Replay for Monitors, Simple M-Sequences, Tracing and Replaying Simple M-Sequences, Other Approaches to Program Replay, Testing Monitor-Based Programs, M-Sequences, Determining the Feasibility of an M-Sequence, Determining the Feasibility of a Communication-Sequence, Reachability Testing for Monitors, Putting It All Together, 235 Further Reading, 243 References, 243 Exercises, Message Passing Channel Objects, Channel Objects in Java, Channel Objects in C++/Win32, Rendezvous, Selective Wait, 272

11 CONTENTS ix 5.4 Message-Based Solutions to Concurrent Programming Problems, Readers and Writers, Resource Allocation, Simulating Counting Semaphores, Tracing, Testing, and Replay for Message-Passing Programs, SR-Sequences, Simple SR-Sequences, Determining the Feasibility of an SR-Sequence, Deterministic Testing, Reachability Testing for Message-Passing Programs, Putting It All Together, 299 Further Reading, 304 References, 304 Exercises, Message Passing in Distributed Programs TCP Sockets, Channel Reliability, TCP Sockets in Java, Java TCP Channel Classes, Classes TCPSender and TCPMailbox, Classes TCPSynchronousSender and TCPSynchronousMailbox, Class TCPSelectableSynchronousMailbox, Timestamps and Event Ordering, Event-Ordering Problems, Local Real-Time Clocks, Global Real-Time Clocks, Causality, Integer Timestamps, Vector Timestamps, Timestamps for Programs Using Messages and Shared Variables, Message-Based Solutions to Distributed Programming Problems, Distributed Mutual Exclusion, Distributed Readers and Writers, Alternating Bit Protocol, Testing and Debugging Distributed Programs, Object-Based Sequences, Simple Sequences, 362

12 x CONTENTS Tracing, Testing, and Replaying CARC-Sequences and CSC-Sequences, Putting It All Together, Other Approaches to Replaying Distributed Programs, 371 Further Reading, 374 References, 375 Exercises, Testing and Debugging Concurrent Programs Synchronization Sequences of Concurrent Programs, Complete Events vs. Simple Events, Total Ordering vs. Partial Ordering, Paths of Concurrent Programs, Defining a Path, Path-Based Testing and Coverage Criteria, Definitions of Correctness and Faults for Concurrent Programs, Defining Correctness for Concurrent Programs, Failures and Faults in Concurrent Programs, Deadlock, Livelock, and Starvation, Approaches to Testing Concurrent Programs, Nondeterministic Testing, Deterministic Testing, Combinations of Deterministic and Nondeterministic Testing, Reachability Testing, Reachability Testing Process, SYN-Sequences for Reachability Testing, Race Analysis of SYN-Sequences, Timestamp Assignment, Computing Race Variants, Reachability Testing Algorithm, Research Directions, 447 Further Reading, 449 References, 449 Exercises, 452 Index 457

13 PREFACE This is a textbook on multithreaded programming. The objective of this book is to teach students about languages and libraries for multithreaded programming, to help students develop problem-solving and programming skills, and to describe and demonstrate various testing and debugging techniques that have been developed for multithreaded programs over the past 20 years. It covers threads, semaphores, locks, monitors, message passing, and the relevant parts of Java, the POSIX Pthreads library, and the Windows Win32 Application Programming Interface (API). The book is unique in that it provides in-depth coverage on testing and debugging multithreaded programs, a topic that typically receives little attention. The title Modern Multithreading reflects the fact that there are effective and relatively new testing and debugging techniques for multithreaded programs. The material in this book was developed in concurrent programming courses that the authors have taught for 20 years. This material includes results from the authors research in concurrent programming, emphasizing tools and techniques that are of practical use. A class library has been implemented to provide working examples of all the material that is covered. Classroom Use In our experience, students have a hard time learning to write concurrent programs. If they manage to get their programs to run, they usually encounter deadlocks and other intermittent failures, and soon discover how difficult it is to reproduce the failures and locate the cause of the problem. Essentially, they have no way to check the correctness of their programs, which interferes with learning. Instructors face the same problem when grading multithreaded programs. It xi

14 xii PREFACE is tedious, time consuming, and often impossible to assess student programs by hand. The class libraries that we have developed, and the testing techniques they support, can be used to assess student programs. When we assign programming problems in our courses, we also provide test cases that the students must use to assess the correctness of their programs. This is very helpful for the students and the instructors. This book is designed for upper-level undergraduates and graduate students in computer science. It can be used as a main text in a concurrent programming course or could be used as a supplementary text for an operating systems course or a software engineering course. Since the text emphasizes practical material, provides working code, and addresses testing and debugging problems that receive little or no attention in many other books, we believe that it will also be helpful to programmers in industry. The text assumes that students have the following background: ž Programming experience as typically gained in CS 1 and CS 2 courses. ž Knowledge of elementary data structures as learned in a CS 2 course. ž An understanding of Java fundamentals. Students should be familiar with object-oriented programming in Java, but no advanced knowledge is necessary. ž An understanding of C++ fundamentals. We use only the basic objectoriented programming features of C++. ž A prior course on operating systems is helpful but not required. We have made an effort to minimize the differences between our Java and C++ programs. We use object-oriented features that are common to both languages, and the class library has been implemented in both languages. Although we don t illustrate every example in both Java and C++, the differences are very minor and it is easy to translate program examples from one language to the other. Content The book has seven chapters. Chapter 1 defines operating systems terms such as process, thread, andcontext switch. It then shows how to create threads, first in Java and then in C++ using both the POSIX Pthreads library and the Win32 API. A C++ Thread class is provided to hide the details of thread creation in Pthreads/Win32. C++ programs that use the Thread class look remarkably similar to multithreaded Java programs. Fundamental concepts, such as atomicity and nondeterminism, are described using simple program examples. Chapter 1 ends by listing the issues and problems that arise when testing and debugging multithreaded programs. To illustrate the interesting things to come, we present a simple multithreaded C++ program that is capable of tracing and replaying its own executions. Chapter 2 introduces concurrent programming by describing various solutions to the critical section problem. This problem is easy to understand but hard

15 PREFACE xiii to solve. The advantage of focusing on this problem is that it can be solved without introducing complicated new programming constructs. Students gain a quick appreciation for the programming skills that they need to acquire. Chapter 2 also demonstrates how to trace and replay Peterson s solution to the critical section problem, which offers a straightforward introduction to several testing and debugging issues. The synchronization library implements the various techniques that are described. Chapters 3, 4, and 5 cover semaphores, monitors and message passing, respectively. Each chapter describes one of these constructs and shows how to use it to solve programming problems. Semaphore and Lock classes for Java and C++/Win32/Pthreads are presented in Chapter 3. Chapter 4 presents monitor classes for Java and C++/Win32/Pthreads. Chapter 5 presents mailbox classes with send/receive methods and a selective wait statement. These chapters also cover the built-in support that Win32 and Pthreads provide for these constructs, as well as the support provided by J2SE 5.0 (Java 2 Platform, Standard Edition 5.0). Each chapter addresses a particular testing or debugging problem and shows how to solve it. The synchronization library implements the testing and debugging techniques so that students can apply them to their own programs. Chapter 6 covers message passing in a distributed environment. It presents several Java mailbox classes that hide the details of TCP message passing and shows how to solve several distributed programming problems in Java. It also shows how to test and debug programs in a distributed environment (e.g., accurately tracing program executions by using vector timestamps). This chapter by no means provides complete coverage of distributed programming. Rather, it is meant to introduce students to the difficulty of distributed programming and to show them that the testing and debugging techniques presented in earlier chapters can be extended to work in a distributed environment. The synchronization library implements the various techniques. Chapter 7 covers concepts that are fundamental to testing and debugging concurrent programs. It defines important terms, presents several test coverage criteria for concurrent programs, and describes the various approaches to testing concurrent programs. This chapter organizes and summarizes the testing and debugging material that is presented in depth in Chapters 2 to 6. This organization provides two paths through the text. Instructors can cover the testing and debugging material in the last sections of Chapters 2 to 6 as they go through those chapters, or they can cover those sections when they cover Chapter 7. Chapter 7 also discusses reachability testing, which offers a bridge between testing and verification, and is implemented in the synchronization library. Each chapter has exercises at the end. Some of the exercises explore the concepts covered in the chapter, whereas others require a program to be written. In our courses we cover all the chapters and give six homework assignments, two in-class exams, and a project. We usually supplement the text with readings on model checking, process algebra, specification languages, and other research topics.

Real-Time Optimization by Extremum-Seeking Control

Real-Time Optimization by Extremum-Seeking Control Real-Time Optimization by Extremum-Seeking Control KARTIK B. ARIYUR MIROSLAV KRSTIĆ A JOHN WILEY & SONS, INC., PUBLICATION Copyright 2003 by John Wiley