Practical UNIX programming : a guide to concurrency, communication and multithreading / Kay A. Robbins and Steven Robbins.

By: Robbins, Kay A .

Contributor(s): Robbins, Steven, 1947-.

Material type: materialTypeLabel

BookPublisher: Upper Saddle River, N.J. : Prentice Hall, 1996Description: xiv, 658 p. ; 25 cm. + hbk.ISBN: 0134437063.Subject(s): UNIX (Computer file) | Microcomputers -- Programming

DDC classification: 005.42

Contents:

I: Fundamentals -- What is concurrency? -- Programs and Processes -- Files -- Project: The Token Ring -- II: Asynchronous Events -- Signals -- Project: Timers -- Project: Cracking Shells -- III: Concurrency -- Critical Sections and Semaphores -- POSIX Threads -- Thread Synchronization -- Project: The not too parallel virtual machine -- IV: Communication -- Client-Server Communication -- Project: Internet Radio -- Remote Procedure Calls -- Project: Tuple Space.

Holdings
Item type	Current library	Call number	Copy number	Status	Date due	Barcode	Item holds
General Lending	MTU Bishopstown Library Lending	005.42 (Browse shelf(Opens below))	1	Available		00080951
General Lending	MTU Bishopstown Library Lending	005.42 (Browse shelf(Opens below))	1	Available		00071079

Total holds: 0

Browsing MTU Bishopstown Library shelves, Shelving location: Lending Close shelf browser (Hides shelf browser)

Previous								Next
Previous	005.4 Unix/Linux survival guide /	005.42 Managing projects with Make /	005.42 Practical UNIX programming : a guide to concurrency, communication and multithreading /	005.42 Practical UNIX programming : a guide to concurrency, communication and multithreading /	005.42 Formal methods for concurrency /	005.42 About face : the essentials of user interface design /	005.42 Programming with UNIX threads /	Next

Enhanced descriptions from Syndetics:

This book explains complicated topics such as signals and concurrency in an easy-to-understand manner. It covers fundamentals, asynchronous events, concurrency, and communication, and includes two types of programming problems: laboratory exercises that can be implemented in less than 100 lines of code, and more extensive laboratory projects that apply the concepts in semi-practical settings.

Bibliography: (pages 633-639) and index.

Table of contents provided by Syndetics

I Fundamentals
1 What Is Concurrency?
Multiprogramming and Multitasking
Concurrency at the Applications Level
UNIX Standards
Programming in UNIX
Making Functions Safe
Exercise: Argument Arrays
Additional Reading
2 Programs and Processes
Layout of a Program Executable
Static Objects
The Process ID
The Process State
Process Creation and the UNIX fork
The wait System Call
The exec System Call
Background Processes and Daemons
The Process Environment
Process Termination in UNIX
Critical Sections
Exercise: Process Chains
Exercise: Process Fans
Exercise: Simple biff
Exercise: News biff
Additional Reading
3 Files
Directories and Paths
UNIX File Representation
File Handle Representation
Filters and Redirection
Pipes
Reading to and Writing from Files
Nonblocking I/O
The select call
FIFOs
Special FilesThe Audio Device
Exercise: Traversing Directories
Exercise: proc Filesystem
Exercise: Audio
Exercise: Terminal Control
Additional Reading
4 Project: The Token Ring
Forming a Ring
Simple Communication
Mutual Exclusion with Tokens
Mutual Exclusion by Voting
Leader Election on an Anonymous Ring
Token Ring for Communication
A Pipelined Preprocessor
Parallel Ring Algorithms
The Flexible Ring
Additional Reading
II Asynchronous Events
5 Signals
Sending Signals
The Signal Mask and Signal Sets
Catching and Ignoring Signalssigaction
Waiting for Signalspause and sigsuspend
An Examplebiff
System Calls and Signals
Siglongjmp and sigsetjmp
Realtime Signals
Asynchronous I/O
Exercise: Dumping Statistics
Exercise: proc Filesystem II
Exercise: Spooling a Slow Device
Additional Reading
6 Project: Timers
Times in UNIX
Interval Timers
Project Overview
Simple Timers
Setting One of Five Single Timers
Multiple Timers
A Robust Implementation of Multiple Timers. mycron, a Small Cron Facility
POSIX Timer Implementation
Additional Reading
7 Project: Cracking Shells
A Simple Shell
Redirection
Pipelines
Signals
Process Groups, Sessions, and Controlling Terminals
Handling Background Processes in ush
Job Control
Job Control for ush
Additional Reading
III Concurrency
8 Critical Sections and Semaphores
Atomic Operations
Semaphores
Semaphores in POSIX
Semaphores in System V (Spec 1170)
Semaphores and Signals
Exercise: POSIX Unnamed Semaphores
Exercise: POSIX Named Semaphores
Exercise: License Manager
Exercise: System V Shared Memory
Exercise: System V Message Queues
Additional Reading
9 POSIX Threads
A Motivating Problem: Monitoring File Descriptors
POSIX Threads
Basic Thread Management
User versus Kernel Threads
Thread Attributes
Exercise: Parallel File Copy
Additional Reading
10 Thread Synchronization
Mutexes
Semaphores
Condition Variables
Signal Handling and Threads
Exercise: Threaded Print Server
Additional Reading
11 Project: The Not Too Parallel Virtual Machine
The Not Too Parallel Virtual Machine
NTPVM Project Overview
I/O and Testing of Dispatcher
Single Task with No Input
Sequential Tasks
Concurrent Tasks
Broadcast and Barriers
Termination and Signals
Additional Reading
IV Communication
12 Client-Server Communication
Client-Server Strategies
The Universal Internet Communication Interface (UICI)
Network Communication
Socket Implementation of UICI
Transport Layer Interface (TLI). STREAMS
STREAMS implementation of UICI
Thread-Safe UICI
Exercise: Transmission of Audio
Exercise: Ping Server
Additional Reading
13 Project: Internet Radio
Overview of the Multiplexer
One-Way Communication
Two-Way Communication
The Transmit Buffer
Multiplexing the Transmit Buffer