Producer/Consumer CSCI 201 Principles of Software Development
|
|
- Warren Daniel
- 6 years ago
- Views:
Transcription
1 Producer/Consumer CSCI 201 Principles of Software Development Jeffrey Miller, Ph.D.
2 Outline Producer/Consumer Program USC CSCI 201L
3 Producer/Consumer Overview The producer/consumer problem is a famous problem for concurrent programming Assume you have a soda machine with a number of delivery people (producers) and a number of people wanting to buy sodas (consumers) Each producer can insert as many sodas as he has, up to the capacity of the soda machine Each consumer can purchase as many sodas as he wants, up to the current number in the soda machine If there are not enough sodas for a consumer to buy, he needs to wait until there are If there is not enough room for the producer to insert the number of sodas he has, he needs to wait until there is This problem can produce a situation called deadlock Download the ProducerConsumerWithMonitors.java from the course web site and execute it What line(s) of code produce the potential deadlock? USC CSCI 201L 3/10
4 Producer/Consumer Example Put this one soda in the soda machine! Is there a soda in Yay! Yes! Thanks No? the I m machine Thanks There s I guess thirsty! for the I ll for a for soda soda! have the now! soda! to me wait to buy? Hey, Is No? there I there s need space to space in now! the wait soda for I ll there put machine the to soda for be space! a soda? in. USC CSCI 201L 4/10
5 Producer/Consumer Example with Monitors 1 import java.util.linkedlist; 2 import java.util.concurrent.executorservice; 3 import java.util.concurrent.executors; 4 5 public class ProducerConsumerWithMonitors { 6 private static Buffer buffer = new Buffer(); 7 8 public static void main(string [] args) { 9 ExecutorService executor = Executors.newFixedThreadPool(2); 10 executor.execute(new ProducerTask()); 11 executor.execute(new ConsumerTask()); 12 executor.shutdown(); 13 } private static class ProducerTask implements Runnable { 16 public void run() { 17 try { 18 int i = 1; 19 while (true) { 20 System.out.println("Producer writes: " + i); 21 buffer.write(i++); 22 Thread.sleep((int)(Math.random() * 1000)); 23 } 24 } catch (InterruptedException ie) { 25 System.out.println("Producer IE: " + ie.getmessage()); 26 } 27 } 28 } private static class ConsumerTask implements Runnable { 31 public void run() { 32 try { 33 while (true) { 34 System.out.println("\t\tConsumer reads: " + buffer.read()); 35 Thread.sleep((int)(Math.random() * 1000)); 36 } 37 } catch (InterruptedException ie) { 38 System.out.println("Consumer IE: " + ie.getmessage()); 39 } 40 } 41 } 42 private static class Buffer { 43 private static final int CAPACITY = 1; 44 private LinkedList<Integer> queue = new LinkedList<Integer>(); 45 private static Object notempty = new Object(); 46 private static Object notfull = new Object(); 47 public void write(int value) { 48 synchronized(notfull) { 49 synchronized(notempty) { 50 try { 51 while (queue.size() == CAPACITY) { 52 System.out.println("Wait for notfull condition " + value); 53 notfull.wait(); 54 } 55 queue.offer(value); 56 notempty.notify(); 57 } catch (InterruptedException ie) { 58 System.out.println("Buffer.write IE: " + ie.getmessage()); 59 } 60 } 61 } 62 } 63 public int read() { 64 int value = 0; 65 synchronized(notfull) { 66 synchronized(notempty) { 67 try { 68 while (queue.isempty()) { 69 System.out.println("\t\tWait for notempty condition"); 70 notempty.wait(); 71 } 72 value = queue.remove(); 73 notfull.notify(); 74 } catch (InterruptedException ie) { 75 System.out.println("Buffer.read IE: " + ie.getmessage()); 76 } 77 } 78 } 79 return value; 80 } 81 } // ends class Buffer 82 } // ends class ProducerConsumerWithMonitors USC CSCI 201L 5/10
6 Producer/Consumer Example with Monitors Even if we reduce this to only having one monitor, there is a possible race condition. Assume the following execution The Consumer checks to see if the queue is empty (line 64) and enters the loop. The Consumer is switched out of the CPU in the middle of line 66, specifically after giving up the lock but before moving to the waiting state. The Producer executes and adds a soda into the queue on line 53, then notifies any thread waiting on the sodamachine (which is no one currently). The Consumer then runs again and gets moved into the waiting state, waiting on the sodamachine on line 66. The Producer then runs again and finds that the queue is at capacity (line 49), so it waits (line 51). We now have a deadlock state. 42 private static class Buffer { 43 private static final int CAPACITY = 1; 44 private LinkedList<Integer> queue = new LinkedList<Integer>(); 45 private static Object sodamachine = new Object(); 46 public void write(int value) { 47 synchronized(sodamachine) { 48 try { 49 while (queue.size() == CAPACITY) { 50 System.out.println("Wait for notfull condition " + value); 51 sodamachine.wait(); 52 } 53 queue.offer(value); 54 sodamachine.notify(); 55 } catch (InterruptedException ie) { 56 System.out.println("Buffer.write IE: " + ie.getmessage()); 57 } 58 } 59 } 60 public int read() { 61 int value = 0; 62 synchronized(sodamachine) { 63 try { 64 while (queue.isempty()) { 65 System.out.println("\t\tWait for notempty condition"); 66 sodamachine.wait(); 67 } 68 value = queue.remove(); 69 sodamachine.notify(); 70 } catch (InterruptedException ie) { 71 System.out.println("Buffer.read IE: " + ie.getmessage()); 72 } 73 } 74 return value; 75 } 76 } // ends class Buffer 77 } // ends class ProducerConsumerWithMonitors USC CSCI 201L 6/10
7 Producer/Consumer Example with Locks/Conditions 1 import java.util.linkedlist; 2 import java.util.concurrent.executorservice; 3 import java.util.concurrent.executors; 4 import java.util.concurrent.locks.condition; 5 import java.util.concurrent.locks.lock; 6 import java.util.concurrent.locks.reentrantlock; 7 8 public class ProducerConsumerWithLocks { 9 private static Buffer buffer = new Buffer(); 10 public static void main(string [] args) { 11 ExecutorService executor = Executors.newFixedThreadPool(2); 12 executor.execute(new ProducerTask()); 13 executor.execute(new ConsumerTask()); 14 executor.shutdown(); 15 } 16 private static class ProducerTask implements Runnable { 17 public void run() { 18 try { 19 int i = 1; 20 while (true) { 21 System.out.println("Producer tries to write: " + i); 22 buffer.write(i++); 23 Thread.sleep((int)(Math.random() * 1000)); 24 } 25 } catch (InterruptedException ie) { 26 System.out.println("Producer IE: " + ie.getmessage()); 27 } 28 } 29 } 30 private static class ConsumerTask implements Runnable { 31 public void run() { 32 try { 33 while (true) { 34 System.out.println("\t\tConsumer reads: " + buffer.read()); 35 Thread.sleep((int)(Math.random() * 1000)); 36 } 37 } catch (InterruptedException ie) { 38 System.out.println("Consumer IE: " + ie.getmessage()); 39 } 40 } 41 } 42 private static class Buffer { 43 private static final int CAPACITY = 1; 44 private LinkedList<Integer> queue = new LinkedList<Integer>(); 45 private static Lock lock = new ReentrantLock(); 46 private static Condition notempty = lock.newcondition(); 47 private static Condition notfull = lock.newcondition(); 48 public void write(int value) { 49 lock.lock(); 50 try { 51 while (queue.size() == CAPACITY) { 52 System.out.println("Wait for notfull condition " + value); 53 notfull.await(); 54 } 55 queue.offer(value); 56 notempty.signal(); 57 } catch (InterruptedException ie) { 58 System.out.println("Buffer.write IE: " + ie.getmessage()); 59 } finally { 60 lock.unlock(); 61 } 62 } 63 public int read() { 64 int value = 0; 65 lock.lock(); 66 try { 67 while (queue.isempty()) { 68 System.out.println("\t\tWait for notempty condition"); 69 notempty.await(); 71 } 70 value = queue.remove(); 71 notfull.signal(); 72 } catch (InterruptedException ie) { 73 System.out.println("Buffer.read IE: " + ie.getmessage()); 74 } finally { 75 lock.unlock(); 76 return value; 77 } 78 } 79 } // ends class Buffer 80 } // ends class ProducerConsumerWithLocks USC CSCI 201L 7/10
8 Producer/Consumer Output with Locks/Conditions USC CSCI 201L 8/10
9 Outline Producer/Consumer Program USC CSCI 201L
10 Program Modify the Producer/Consumer program with locks so that a Producer will never write two lines in a row. Also provide an output line when a Producer or Consumer is notified or signaled. USC CSCI 201L 10/10
Multi-Threaded Programming Design CSCI 201 Principles of Software Development
Multi-Threaded Programming Design CSCI 201 Principles of Software Development Jeffrey Miller, Ph.D. jeffrey.miller@usc.edu Blocking Queues Outline Multi-Threaded Programming Design USC CSCI 201L Thread
More informationConcurrency CSCI 201 Principles of Software Development
Concurrency CSCI 201 Principles of Software Development Jeffrey Miller, Ph.D. jeffrey.miller@usc.edu Synchronization Outline USC CSCI 201L Motivation for Synchronization Thread synchronization is used
More informationMonitors CSCI 201 Principles of Software Development
Monitors CSCI 201 Principles of Software Development Jeffrey Miller, Ph.D. jeffrey.miller@usc.edu Outline Monitors Program USC CSCI 201L Monitor Overview A monitor is an object with mutual exclusion and
More informationCOMP 322: Fundamentals of Parallel Programming
COMP 322: Fundamentals of Parallel Programming https://wiki.rice.edu/confluence/display/parprog/comp322 Lecture 30: Advanced locking in Java Vivek Sarkar Department of Computer Science Rice University
More informationBuch gefunden? Im Blackboard eingetragen? Abgabe 1. Übung: , 23:59
Buch gefunden? Im Blackboard eingetragen? Abgabe 1. Übung: 09.04., 23:59 1 www.msproteomics.org Ver teil tes Rechnen und Parallelprogrammierung: Introduction to Multi-Threading in Java Based on the book
More informationConcurrent Programming Benoît Garbinato
Concurrent Programming Benoît Garbinato 1 Processes & threads A process is a unit of execution managed at the level of the operating system Each process has its own address space, i.e., no other process
More informationCPIT 305 Advanced Programming Multithreading
CPIT 305 Advanced Programming Multithreading Dr. M. G. Abbas Malik Assistant Professor Faculty of Computing and IT (North Jeddah Branch) King Abdulaziz University, Jeddah, KSA mgmalik@kau.edu.sa www.sanlp.org/malik/cpit305/ap.html
More informationConcurrent Computing CSCI 201 Principles of Software Development
Concurrent Computing CSCI 201 Principles of Software Development Jeffrey Miller, Ph.D. jeffrey.miller@usc.edu Outline Threads Multi-Threaded Code CPU Scheduling Program USC CSCI 201L Thread Overview Looking
More informationJava Monitors. Parallel and Distributed Computing. Department of Computer Science and Engineering (DEI) Instituto Superior Técnico.
Java Monitors Parallel and Distributed Computing Department of Computer Science and Engineering (DEI) Instituto Superior Técnico October 19, 2010 Monteiro, Costa (DEI / IST) Parallel and Distributed Computing
More informationTeaching predicates and invariants on shared data structures in concurrent programming
Teaching predicates and invariants on shared data structures in concurrent programming Stein Gjessing Department of informatics, University of Oslo steing@ifi.uio.no Arne Maus Department of informatics,
More informationMultithreading. Dr. Jens Bennedsen, Aarhus University, School of Engineering Aarhus, Denmark
Multithreading Dr. Jens Bennedsen, Aarhus University, School of Engineering Aarhus, Denmark jbb@stll.au..dk Submission & Peer feedback peergrade.io/join AJJ452 What is going on here? Multithreading Threads
More informationFinal Score ID Extra Credit. 15% of course grade
Name Final Score ID Extra Credit Section (circle one): TTh 8:00-9:20 TTh 9:30-10:50 TTh 11:00-12:20 15% of course grade 1. Inheritance When Java was developed, it was scrutinized since it only has single
More informationBlockingArrayQueue.java. Page 1
1 //BlockingArrayQueue.java 2 //Template blocking queue class, implemented with emulated circular array. 3 //Programmer: Randy Miller 4 //Last modification: April 13, 2015 5 6 7 8 import java.util.arraylist;
More informationCMSC 433 Programming Language Technologies and Paradigms Fall Locks & Conditions
CMSC 433 Programming Language Technologies and Paradigms Fall 2011 Locks & Conditions Intrinsic Lock Example public class RWDictionaryIntrinsicLock { Map m = new TreeMap();
More informationCondition Synchronization
Condition Synchronization 1 Synchronization! Now that you have seen locks, is that all there is?! No, but what is the right way to build a parallel program. People are still trying to figure that out.!
More informationAbstract Classes Interfaces CSCI 201 Principles of Software Development
Abstract Classes Interfaces CSCI 201 Principles of Software Development Jeffrey Miller, Ph.D. jeffrey.miller@usc.edu Abstract Classes Outline USC CSCI 201L Abstract Classes An abstract class is a way for
More informationAbstract Classes Interfaces CSCI 201 Principles of Software Development
Abstract Classes Interfaces CSCI 201 Principles of Software Development Jeffrey Miller, Ph.D. jeffrey.miller@usc.edu Abstract Classes Outline USC CSCI 201L Abstract Classes An abstract class is a way for
More informationCMSC 132: Object-Oriented Programming II. Threads in Java
CMSC 132: Object-Oriented Programming II Threads in Java 1 Problem Multiple tasks for computer Draw & display images on screen Check keyboard & mouse input Send & receive data on network Read & write files
More informationCMSC 330: Organization of Programming Languages. Threads Classic Concurrency Problems
: Organization of Programming Languages Threads Classic Concurrency Problems The Dining Philosophers Problem Philosophers either eat or think They must have two forks to eat Can only use forks on either
More informationChapter 32 Multithreading and Parallel Programming
Chapter 32 Multithreading and Parallel Programming 1 Objectives To get an overview of multithreading ( 32.2). To develop task classes by implementing the Runnable interface ( 32.3). To create threads to
More informationCMSC 330: Organization of Programming Languages. The Dining Philosophers Problem
CMSC 330: Organization of Programming Languages Threads Classic Concurrency Problems The Dining Philosophers Problem Philosophers either eat or think They must have two forks to eat Can only use forks
More informationMore Synchronization; Concurrency in Java. CS 475, Spring 2018 Concurrent & Distributed Systems
More Synchronization; Concurrency in Java CS 475, Spring 2018 Concurrent & Distributed Systems Review: Semaphores Synchronization tool that provides more sophisticated ways (than Mutex locks) for process
More informationConcurrency Utilities: JSR-166
Concurrency Concurrency Utilities: JSR-166 Enables development of simple yet powerful multi-threaded applications > Like Collection provides rich data structure handling capability Beat C performance in
More informationSemaphores. A semaphore is an object that consists of a. methods (e.g., functions): signal and wait. semaphore. method signal. counter.
Semaphores 1 Semaphores A semaphore is an object that consists of a counter, a waiting list of processes, and two methods (e.g., functions): signal and wait. method signal method wait counter waiting list
More informationModule - 4 Multi-Threaded Programming
Terminologies Module - 4 Multi-Threaded Programming Process: A program under execution is called as process. Thread: A smallest component of a process that can be executed independently. OR A thread is
More informationDr.-Ing. Michael Eichberg
Dr.-Ing. Michael Eichberg Concurrent Programming (Overview of the Java concurrency model and its relationship to other models...) (some slides are based on slides by Andy Wellings) 2 Processes vs. Threads
More informationThreads and Locks, Part 2. CSCI 5828: Foundations of Software Engineering Lecture 08 09/18/2014
Threads and Locks, Part 2 CSCI 5828: Foundations of Software Engineering Lecture 08 09/18/2014 1 Goals Cover the material presented in Chapter 2 of our concurrency textbook In particular, selected material
More informationFinal Score Name SOLUTION ID Extra Credit. 15% of course grade
Final Score Name SOLUTION ID Extra Credit Section (circle one): TTh 8:00-9:20 TTh 9:30-10:50 TTh 11:00-12:20 15% of course grade 1. Inheritance When Java was developed, it was scrutinized since it only
More informationCOMP 213. Advanced Object-oriented Programming. Lecture 23. Shared Variables and Synchronization
COMP 213 Advanced Object-oriented Programming Lecture 23 Shared Variables and Synchronization Communicating Threads In the previous lecture, we saw an example of a multi-threaded program where three threads
More informationSynchronized Methods of Old Versions of Java
Administrivia Assignment #4 is out Due Thursday April 8, 10:00pm no late assignments will be accepted Sign up in labs next week for a demo time In case you hadn t noticed Classes end Thursday April 15
More informationDr.-Ing. Michael Eichberg
Dr.-Ing. Michael Eichberg Concurrent Programming (Overview of the Java concurrency model and its relationship to other models...) (some slides are based on slides by Andy Wellings) Processes vs. Threads
More informationCMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Multithreading Multiprocessors Description Multiple processing units (multiprocessor) From single microprocessor to large compute clusters Can perform multiple
More informationCS 351 Design of Large Programs Threads and Concurrency
CS 351 Design of Large Programs Threads and Concurrency Brooke Chenoweth University of New Mexico Spring 2018 Concurrency in Java Java has basic concurrency support built into the language. Also has high-level
More informationSleeping Barber CSCI 201 Principles of Software Development
Sleeping Barber CSCI 201 Principles of Software Development Jeffrey Miller, Ph.D. jeffrey.miller@usc.edu Sleeping Barber Outline USC CSCI 201L Sleeping Barber Overview The Sleeping Barber problem contains
More information7.1 Processes and Threads
Chapter 7 Thread Programming 7.1 Processes and Threads Processes are fundamental in any computing system. A process is a program in execution, plus the data, the stack, registers, and all the resources
More informationUser Space Multithreading. Computer Science, University of Warwick
User Space Multithreading 1 Threads Thread short for thread of execution/control B efore create Global During create Global Data Data Executing Code Code Stack Stack Stack A fter create Global Data Executing
More informationCS510 Operating System Foundations. Jonathan Walpole
CS510 Operating System Foundations Jonathan Walpole Monitors 2 Programming Complexity There are many ways to introduce bugs using locks and semaphores - forget to lock somewhere in the program - forget
More informationSummary Semaphores. Passing the Baton any await statement. Synchronisation code not linked to the data
Lecture 4 Monitors Summary Semaphores Good news Simple, efficient, expressive Passing the Baton any await statement Bad news Low level, unstructured omit a V: deadlock omit a P: failure of mutex Synchronisation
More informationSimpler, Faster, Better: Concurrency Utilities in JDK Software Version 5.0
Simpler, Faster, Better: Concurrency Utilities in JDK Software Version 5.0 Brian Goetz Principal Consultant, Quiotix Corp David Holmes Staff Engineer, Sun Microsystems, Inc. TS-4915 2006 JavaOne SM Conference
More informationReading from URL. Intent - open URL get an input stream on the connection, and read from the input stream.
Simple Networking Loading applets from the network. Applets are referenced in a HTML file. Java programs can use URLs to connect to and retrieve information over the network. Uniform Resource Locator (URL)
More informationThe Dining Philosophers Problem CMSC 330: Organization of Programming Languages
The Dining Philosophers Problem CMSC 0: Organization of Programming Languages Threads Classic Concurrency Problems Philosophers either eat or think They must have two forks to eat Can only use forks on
More informationJava Threads. 02/05/2007 CSCI 315 Operating Systems Design 1
Java Threads Notice: The slides for this lecture have been largely based on those accompanying the textbook Operating Systems Concepts with Java, by Silberschatz, Galvin, and Gagne (2007). Many, if not
More informationNetworking Code CSCI 201 Principles of Software Development
Networking Code CSCI 201 Principles of Software Development Jeffrey Miller, Ph.D. jeffrey.miller@usc.edu Server Networking Client Networking Program Outline USC CSCI 201L Server Software A server application
More informationPrinciples of Software Construction: Concurrency, Part 2
Principles of Software Construction: Concurrency, Part 2 Josh Bloch Charlie Garrod School of Computer Science 1 Administrivia Homework 5a due now Homework 5 framework goals: Functionally correct Well documented
More informationCOMPSCI 230 Threading Week8. Figure 1 Thread status diagram [http://www.programcreek.com/2009/03/thread-status/]
COMPSCI 230 Threading Week8 Figure 1 Thread status diagram [http://www.programcreek.com/2009/03/thread-status/] Synchronization Lock DeadLock Why do we need Synchronization in Java? If your code is executing
More informationCSCI 201L Final Written Spring % of course grade
Name SOLUTION Final Score ID Extra Credit Section (circle one): MW 8:30-9:50 TTh 9:30-10:50 TTh 11:00-12:20 12% of course grade 1. Servlets Explain the difference between a GET and POST form submission.
More informationMultithreaded Programming Part II. CSE 219 Stony Brook University, Department of Computer Science
Multithreaded Programming Part II CSE 219 Stony Brook University, Thread Scheduling In a Java application, main is a thread on its own Once multiple threads are made Runnable the thread scheduler of the
More informationChapter 32. Multi-threading
Chapter 32 Multi-threading 1 Objectives To explain multithreading ( 29.2). To develop task classes by implementing the Runnable interface ( 29.3). To create threads to run tasks using the Thread class
More informationSynchronization in Concurrent Programming. Amit Gupta
Synchronization in Concurrent Programming Amit Gupta Announcements Project 1 grades are out on blackboard. Detailed Grade sheets to be distributed after class. Project 2 grades should be out by next Thursday.
More informationSystems Fundamentals. SWE 622, Spring 2017 Distributed Software Engineering
Systems Fundamentals SWE 622, Spring 2017 Distributed Software Engineering Review Why deal with distributed systems? Scalability Performance Latency Availability Fault Tolerance 2 Review More machines,
More informationF. Tip and M. Weintraub CONCURRENCY
F. Tip and M. Weintraub CONCURRENCY SHARED-MEMORY CONCURRENCY threads execute concurrently threads communicate values via shared memory synchronization using locks 2 PITFALLS data races atomicity violations
More informationParallel Computing CSCI 201 Principles of Software Development
Parallel Computing CSCI 201 Principles of Software Development Jeffrey Miller, Ph.D. jeffrey.miller@usc.edu Program Outline USC CSCI 201L Parallel Computing Parallel computing studies software systems
More informationCSCD 330 Network Programming
CSCD 330 Network Programming Lecture 12 More Client-Server Programming Winter 2019 Reading: References at end of Lecture 1 Introduction So far, Looked at client-server programs with Java Sockets TCP and
More informationWeek 7. Concurrent Programming: Thread Synchronization. CS 180 Sunil Prabhakar Department of Computer Science Purdue University
Week 7 Concurrent Programming: Thread Synchronization CS 180 Sunil Prabhakar Department of Computer Science Purdue University Announcements Exam 1 tonight 6:30 pm - 7:30 pm MTHW 210 2 Outcomes Understand
More informationCISC 4700 L01 Network & Client-Server Programming Spring Cowell Chapter 15: Writing Threaded Applications
CISC 4700 L01 Network & Client-Server Programming Spring 2016 Cowell Chapter 15: Writing Threaded Applications Idea: application does simultaneous activities. Example: web browsers download text and graphics
More information4.10 Tracing and Replay for Monitors
4.10 Tracing and Replay for Monitors Outline: simple M-sequences of monitor-based programs tracing and replaying simple M-sequences during debugging modifying the SC and SU monitor toolboxes to support
More informationLecture 10 Multithreading
Lecture 10 Multithreading Introduction to Threads Threads in Java public class TaskThreadDemo public static void main(string[] args) // Create tasks Runnable printa = new PrintChar('a', 100); Runnable
More informationJava Threads Vs Processes. CS Concurrent Programming. Java Threads. What can a thread do? Java Concurrency
Java Threads Vs Processes CS6868 - Concurrent Programming Java Concurrency V. Krishna Nandivada Typically each instance of JVM creates a single process. Each process creates one or more threads. Main thread
More informationSynchronization. CS 475, Spring 2018 Concurrent & Distributed Systems
Synchronization CS 475, Spring 2018 Concurrent & Distributed Systems Review: Threads: Memory View code heap data files code heap data files stack stack stack stack m1 m1 a1 b1 m2 m2 a2 b2 m3 m3 a3 m4 m4
More informationCS 31: Intro to Systems Misc. Threading. Kevin Webb Swarthmore College December 6, 2018
CS 31: Intro to Systems Misc. Threading Kevin Webb Swarthmore College December 6, 2018 Classic thread patterns Agenda Pthreads primitives and examples of other forms of synchronization: Condition variables
More informationClassic Problems of Synchronization
Classic Problems of Synchronization Bounded-Buffer Problem s-s Problem Dining Philosophers Problem Monitors 2/21/12 CSE325 - Synchronization 1 s-s Problem s s 2/21/12 CSE325 - Synchronization 2 Problem
More informationInformatica 3. Marcello Restelli. Laurea in Ingegneria Informatica Politecnico di Milano 9/15/07 10/29/07
Informatica 3 Marcello Restelli 9/15/07 10/29/07 Laurea in Ingegneria Informatica Politecnico di Milano Structuring the Computation Control flow can be obtained through control structure at instruction
More informationLet M be a monitor that is implemented using one of the monitor toolboxes.
4.10 Tracing and Replay for Monitors Outline: simple M-sequences of monitor-based programs tracing and replaying simple M-sequences during debugging modifying the SC and SU monitor toolboxes to support
More informationFinal Score ID Extra Credit. 15% of course grade
Name Final Score ID Extra Credit Section (circle one): TTh 8:00-9:20 TTh 9:30-10:50 TTh 11:00-12:20 15% of course grade 1. Exception Handling What is the difference between a checked exception and an unchecked
More informationChair of Software Engineering. Java and C# in depth. Carlo A. Furia, Marco Piccioni, Bertrand Meyer. Java: concurrency
Chair of Software Engineering Carlo A. Furia, Marco Piccioni, Bertrand Meyer Java: concurrency Outline Java threads thread implementation sleep, interrupt, and join threads that return values Thread synchronization
More informationParallel Computing. Prof. Marco Bertini
Parallel Computing Prof. Marco Bertini Shared memory: Java threads Introduction Java provides built-in multithreading Low level primitives: Class Thread / Interface Runnable High level framework: Java
More informationThreads in JDK Bruce Eckel MindView, Inc. Training & Project Reviews
Threads in JDK 5 2004 Bruce Eckel MindView, Inc. www.mindview.net Training & Project Reviews Bruce@EckelObjects.com I ll put these slides on the site: http://mindview.net/etc/ebig Bruce Eckel Understanding
More informationMultiThreading 07/01/2013. Session objectives. Introduction. Introduction. Advanced Java Programming Course
Advanced Java Programming Course MultiThreading By Võ Văn Hải Faculty of Information Technologies Industrial University of Ho Chi Minh City Session objectives Introduction Creating thread Thread class
More informationAdvanced Java Programming Course. MultiThreading. By Võ Văn Hải Faculty of Information Technologies Industrial University of Ho Chi Minh City
Advanced Java Programming Course MultiThreading By Võ Văn Hải Faculty of Information Technologies Industrial University of Ho Chi Minh City Session objectives Introduction Creating thread Thread class
More informationSo far, we've seen situations in which locking can improve reliability of access to critical sections.
Locks Page 1 Using locks Monday, October 6, 2014 9:49 AM So far, we've seen situations in which locking can improve reliability of access to critical sections. In general, how can one use locks? Locks
More informationECE 587 Hardware/Software Co-Design Lecture 07 Concurrency in Practice Shared Memory I
ECE 587 Hardware/Software Co-Design Spring 2018 1/15 ECE 587 Hardware/Software Co-Design Lecture 07 Concurrency in Practice Shared Memory I Professor Jia Wang Department of Electrical and Computer Engineering
More information-Aditya Bhave CSCI-5448 Graduate Presentation
-Aditya Bhave CSCI-5448 Graduate Presentation 04-01-2011 MSEE at CU finishing up in Summer 11 Work full time at Alticast Inc Background in Embedded Systems Media Processing Middleware Cable TV industry
More informationProblems with Concurrency. February 19, 2014
with Concurrency February 19, 2014 s with concurrency interleavings race conditions dead GUI source of s non-determinism deterministic execution model 2 / 30 General ideas Shared variable Access interleavings
More informationCOMP346 Winter Tutorial 4 Synchronization Semaphores
COMP346 Winter 2015 Tutorial 4 Synchronization Semaphores 1 Topics Synchronization in Details Semaphores Introducing Semaphore.java 2 Synchronization What is it? An act of communication between unrelated
More informationRace Conditions & Synchronization
Race Conditions & Synchronization Lecture 25 Spring 2017 Gries office hours 2 A number of students have asked for time to talk over how to study for the prelim. Gries will hold office hours at the times
More informationJava Threads. Introduction to Java Threads
Java Threads Resources Java Threads by Scott Oaks & Henry Wong (O Reilly) API docs http://download.oracle.com/javase/6/docs/api/ java.lang.thread, java.lang.runnable java.lang.object, java.util.concurrent
More informationSynchronization in Java
Synchronization in Java Nelson Padua-Perez Bill Pugh Department of Computer Science University of Maryland, College Park Synchronization Overview Unsufficient atomicity Data races Locks Deadlock Wait /
More informationConcurrency Quiz: Java Threads
Concurrency Quiz: Java Threads First name, last name:................................................................. Background information In this part of the quiz, we would like to collect some information
More informationExam Concurrent and Real-Time Programming
LUNDS TEKNISKA HÖGSKOLA 1(12) Institutionen för datavetenskap Exam Concurrent and Real-Time Programming 2014 01 07, 08.00 13.00 You are allowed to use the Java quick reference and a calculator. Also dictionaries
More informationNortheastern University - Seattle CS5510 Professor Ian Gorton
Northeastern University - Seattle CS5510 Professor Ian Gorton Northeastern University 1 Week 10 CONCURRENCY II Northeastern University 2 http://jcip.net/ 3 Overview Loops/recursion and threads Readers
More informationConcurrency. Fundamentals of Computer Science
Concurrency http://csunplugged.org/routing-and-deadlock Fundamentals of Computer Science Outline Multi-threaded programs Multiple simultaneous paths of execution Seemingly at once (single core) Actually
More informationParallel & Concurrent Programming
Program Parallel & Concurrent Programming CSCI 334 Stephen Freund Memory Count Words A.html Count cow: cow:28 moo: moo:3 the: the:35 wombat: wombat:16 purple: purple:3
More informationDefinition: A thread is a single sequential flow of control within a program.
What Is a Thread? All programmers are familiar with writing sequential programs. You've probably written a program that displays "Hello World!" or sorts a list of names or computes a list of prime numbers.
More informationCollec&ons & Concurrency
Collec&ons & Concurrency CON3531 Mike Duigou @mjduigou Core Libraries Contributor Safe Harbour Statement & Recogni&on Mike is a former an Oracle employee Mike was a member of Java PlaQorm Core Libraries
More informationCSCI 201L Written Exam #2. 10% of course grade
Name Final Score ID Extra Credit Section (circle one): MW 3:30-6:30 CSCI 201L Written Exam #2 10% of course grade 1. Anonymous Inner Classes In lecture we walked through the following: 1. Having two classes
More informationConcurrency & Parallelism. Threads, Concurrency, and Parallelism. Multicore Processors 11/7/17
Concurrency & Parallelism So far, our programs have been sequential: they do one thing after another, one thing at a. Let s start writing programs that do more than one thing at at a. Threads, Concurrency,
More informationThreads Chate Patanothai
Threads Chate Patanothai Objectives Knowing thread: 3W1H Create separate threads Control the execution of a thread Communicate between threads Protect shared data C. Patanothai Threads 2 What are threads?
More informationQuestion Points Score Total 100
Midterm Exam #1 CMSC 433 Programming Language Technologies and Paradigms Spring 2011 March 3, 2011 Guidelines Put your name on each page before starting the exam. Write your answers directly on the exam
More informationCS 3430/5430 Homework 3 Solution Due: Saturday, Feb. 25 (11:59 PM)
From the on-line textbook, pp. 147-154 do: Ch 4 Exercises (pencil-and-paper): 4.6 Programming Project: 4.8 and 4.11 Exploration Projects: 4.2 Extra Credit: Programming Project: 4.9 or 4.10 Exercises: 4.6
More informationThreads, Concurrency, and Parallelism
Threads, Concurrency, and Parallelism Lecture 24 CS2110 Spring 2017 Concurrency & Parallelism So far, our programs have been sequential: they do one thing after another, one thing at a time. Let s start
More informationSingle processor CPU. Memory I/O
Lec 17 Threads Single processor CPU Memory I/O Multi processes Eclipse PPT iclicker Multi processor CPU CPU Memory I/O Multi-core Core Core Core Core Processor Memory I/O Logical Cores Multi-threaded
More informationJava Concurrency. Towards a better life By - -
Java Concurrency Towards a better life By - Srinivasan.raghavan@oracle.com - Vaibhav.x.choudhary@oracle.com Java Releases J2SE 6: - Collection Framework enhancement -Drag and Drop -Improve IO support J2SE
More informationOverview. CMSC 330: Organization of Programming Languages. Concurrency. Multiprocessors. Processes vs. Threads. Computation Abstractions
CMSC 330: Organization of Programming Languages Multithreaded Programming Patterns in Java CMSC 330 2 Multiprocessors Description Multiple processing units (multiprocessor) From single microprocessor to
More informationCSCD 330 Network Programming
CSCD 330 Network Programming Lecture 12 More Client-Server Programming Winter 2016 Reading: References at end of Lecture 1 Introduction So far, Looked at client-server programs with Java Sockets TCP and
More informationConcurrency in Object Oriented Programs 3. Object-Oriented Software Development COMP4001 CSE UNSW Sydney Lecturer: John Potter
Concurrency in Object Oriented Programs 3 Object-Oriented Software Development COMP4001 CSE UNSW Sydney Lecturer: John Potter Outline Explicit Locks in Java Techniques for Concurrent Reading State Dependent
More informationMore Shared Memory Programming
More Shared Memory Programming Shared data structures We want to make data structures that can be shared by threads. For example, our program to copy a file from one disk to another used a shared FIFO
More informationMonitors; Software Transactional Memory
Monitors; Software Transactional Memory Parallel and Distributed Computing Department of Computer Science and Engineering (DEI) Instituto Superior Técnico October 18, 2012 CPD (DEI / IST) Parallel and
More informationOutline of lecture. i219 Software Design Methodology 10. Multithreaded programming. Kazuhiro Ogata (JAIST)
i219 Software Design Methodology 10. Multithreaded programming Kazuhiro Ogata (JAIST) Outline of lecture 2 Thread Race condition Synchronization Deadlock Bounded buffer problem Thread (1) 3 Units of execution.
More informationpublic class MyThread extends Thread { try { private Shared theshared; threada.join(); threadb.join();
Race Conditions Consider the following Java code int localdata = theshared.getdata(); localdata++; theshared.setdata(localdata); After executing this code what value is stored in Shared.data? public class
More informationConcurrency. CSCI 136: Fundamentals of Computer Science II Keith Vertanen
Concurrency http://csunplugged.org/routing-and-deadlock CSCI 136: Fundamentals of Computer Science II Keith Vertanen Overview Multi-threaded programs Multiple simultaneous paths of execution Seemingly
More information