Concurrency in Object Oriented Programs 1. Object-Oriented Software Development COMP4001 CSE UNSW Sydney Lecturer: John Potter
|
|
- Belinda Reeves
- 5 years ago
- Views:
Transcription
1 Concurrency in Object Oriented Programs 1 Object-Oriented Software Development COMP4001 CSE UNSW Sydney Lecturer: John Potter
2 Outline Concurrency: the Future of Computing Java Concurrency Thread Safety Synchronization 2
3 Why Don t We Have 20GHz CPU? Intel CPU Introductions 3
4 What s Happening? Traditional processor architecture has reached hard limits The clock speed race is over (at least for now) Multicore processors become mainstream Most new computers are currently dual/quad cores Sun s Niagara 2, 8-core and run 64 threads Tilera s TILE64, 64-core Teraflops Research Chip (Polaris), a 3.16 GHz, 80- core processor prototype Myths and Realities: 2 x 3GHz = 6 GHz? 4
5 Where Do We Go from Here? The transition to multicore processors is inevitable a fundamental shift in computer design and software development The Free Lunch Is Over: A Fundamental Turn Toward Concurrency in Software, by Herb Sutter Until now: increasing clock speeds All programs (even sequential programs) run faster From now: increasing number of cores Only concurrent programs will run faster! Concurrency is the next major revolution in how we write software 5
6 Benefits of Concurrency Exploit multicore processors Programs need to use more cores to maximize performance Hide latency from slow I/O (disk, network, etc.) CPUs are much faster than I/O Works even with single core Keep GUIs more responsive Event dispatch thread (EDT) in Java AWT and Swing 6
7 Threads vs Processes OS Processes heavyweight separate address space interact with simple read/write streams synchronization is simpler Threads lightweight shared memory space directly share variables (more efficient) synchronization is more difficult Most modern operating systems treat threads as the basic unit of scheduling 7
8 Concurrency is Hard Automatic approaches are not sufficient Instruction level parallelism is limited Explicit concurrency is needed! Allow programmers to take full advantage of their program-specific knowledge Concurrent programming can be difficult Programmers must be aware of thread safety issues Concurrency programming introduce new kinds of bugs Concurrency bugs are counterintuitive Old bugs become worse harder to detect 8
9 Concurrency is Hard Concurrency bugs the memory bugs of the 21 st century Most languages provide support for explicit multithread programming However, no programming model or language construct invented yet to make the problem go away! still an active research area 9
10 Outline Concurrency: the Future of Computing Java Concurrency Thread Safety Synchronization 10
11 Reading Materials Java Concurrency Tutorial Reference books Java Concurrency in Practice. by Brian Goetz, Tim Peierls, Joshua Bloch, Joseph Bowbeer, David Holmes, and Doug Lea. Addison-Wesley. See Concurrent Programming in Java: Design Principles and Patterns, Second Edition, by Doug Lea. Addison-Wesley. 11
12 Java Threads Java provides direct support for multi-threaded applications JVM provides a native multi-threaded model JVM keeps track of all the threads JVM schedules threads to get CPU time Each Java thread has its own stack executes statements and make calls Java threads share objects in the heap Threads communicate via objects on the heap This is a shared memory model 12
13 Java Threads Threads are regular Java objects A Thread object represents a thread of control in the JVM with thread data (e.g. priority) methods to control thread execution Programmers can send messages (i.e. make method calls) to control the Thread object JVM interprets messages Executes the appropriate operations on the underlying thread of control in the JVM 13
14 The main Thread A Java program begins with a thread executing main() In a sequential Java program, the main thread executes the whole program The program exits when the main thread reaches the end of main() The JVM will often run extra threads outside of programmer control e.g. garbage collection In a concurrent Java program, new threads are created and run concurrently The program may keep running on the other threads even if the main thread exits 14
15 The Current Running Thread There is always a current running thread at any time during computation Thread.currentThread() A static method which returns a reference to the current thread of control Thread current = Thread.currentThread(); current is the Thread object that represents the current thread of control 15
16 Thread Names getname() on a Thread object By default, the method returns something like Thread-0, Thread-1, Thread-2,... for each thread created by the program A convenient method for debugging. Alternatively, the Thread constructor can take a String that is used for the name. 16
17 Thread Creation in Java Construct runtime Thread objects directly subclassing with the Thread class, or delegation with the Runnable interface Thread initialisation is done via new not the same as thread execution Threads must be started by explicitly calling start() after it has been constructed thread cannot be started more than once 17
18 Approach 1: The Thread Class 1. Define a subclass of Thread 2. Override the run() method 3. Construct your own Thread object 4. Start the thread separately from another thread by calling start() This will cause the JVM to start-up a new thread and execute the run() method of the thread The start method will return and the calling thread continues and run concurrently with the new thread 18
19 Thread Class Example public class HelloThread extends Thread { public void run() { System.out.println("Hello from a thread!"); } public static void main(string args[]) { hellothread = new HelloThread(); hellothread.start(); } } 19
20 Approach 2: The Runnable Interface 1. Implement the Runnable interface in a separate (non-thread) class 2. Implement the run() method 3. Construct the Runnable and hand it to a new Thread object 4. Then start this thread at your leisure by calling start() Delegation with Runnable interface is preferred subclassing Thread implies that we cannot inherit other code 20
21 Runnable Interface Example public class HelloRunnable implements Runnable { public void run() { System.out.println("Hello from a thread!"); } public static void main(string args[]) { hellothread = new Thread(new HelloRunnable()); hellothread.start(); } } 21
22 Self-starting Thread Example We can make threads self-starting... public class SelfStarter implements Runnable { public SelfStarter() { (new Thread(this)).start(); } public void run() { System.out.println("Hello from a thread!"); } public static void main(string args[]) { new SelfStarter(); } } 22
23 Thread Communication Threads communicate via shared objects Access to these objects is initiated when the thread is constructed The creating thread passes a reference to one or more objects to a created thread via constructor of the Runnable object Both threads may then communicate via those objects and other objects they both gain access to Runnables are directly shareable then the Runnable should be made thread-safe 23
24 Outline Concurrency: the Future of Computing Java Concurrency Thread Safety Synchronization 24
25 Thread Safety public class UnsafeCount { private int value; } /** Counts the number of calls. */ public void count() { value++; } Is the result of counting correct? 25
26 Thread Safety Two threads could call count(), but sometimes only one call is counted, WHY? 26
27 Thread Safety Two threads could call count(), but sometimes only one call is counted, WHY? value++ involves three separate operations: read the integer stored in value add one to the integer write the result to value 27
28 Thread Safety Two threads could call count(), but sometimes only one call is counted, WHY? value++ involves three separate operations: 28
29 Race Conditions Definition: A race condition occurs when the same memory location may be accessed by different threads simultaneously, and at least one access is a write. Also called data races This occurs when different threads access the same data field of an object (or class) In Java, local variables are not shared across threads, so race conditions never occur for locals 29
30 Race Conditions The correctness of a program relies on luck i.e. how threads interleave their execution Locating concurrency bugs is hard They exhibit themselves sporadically Many of the bugs seen in software products are concurrency bugs They were not tracked down during testing most Java programs are so rife with concurrency bugs that they work only by accident. Brian Goetz et al., Java Concurrency in Practice, Addison-Wesley 30
31 Questions on Thread Safety How can we ensure that objects can be safely used by more than one thread? What does safely mean? Should we allow arbitrary concurrent access? How can we restrict access? Lead to concurrency control synchronisation and locking strategies With concurrent updates who sees which changes, when? constraints on ordering defined by the Java memory model JMM JMM specifies that fields of objects shared by threads may be read and written independently unless specific synchronisation techniques are used 31
32 Achieving Thread Safety Immutability If objects are immutable then arbitrary concurrent access is safe Don t share mutable objects across threads ThreadLocal objects Synchronization dynamically controlling access of different threads to shared objects 32
33 Outline Concurrency: the Future of Computing Java Concurrency Thread Safety Synchronization 33
34 Critical Section A section of code that manipulates shared memory, and so must NOT be run by multiple threads at the same time. public class UnsafeCount { private int value; } /** Counts the number of calls. */ public void count() { } value++; 34
35 Mutual Exclusion mutex Scheduling threads so that only one thread at a time executes a critical section of code Essentially, keeping the threads from interfering with each other Avoid conflicts on shared memory between threads Java ensures mutual exclusion with intrinsic locks 35
36 Intrinsic Locks Every object has an intrinsic lock or monitor associated with it A method may be annotated with a key word synchronized Synchronized instance methods acquire the lock for the receiver of the call (the self object this) Synchronized static methods acquire the lock of the Class object for the defining class There is one such object per class in the Java runtime 36
37 Synchronized Methods A synchronized method respects the lock of the receiver object Before a thread executes a synchronized method, it first obtains the lock of the receiver The lock is released when the method exits If the lock is already held by another thread, it will block until the lock is released, i.e. the thread with the lock exits the method Mutual exclusion is ensured in this way 37
38 Synchronized Methods public class SafeCount { private int value; } /** Counts the number of calls. */ synchronized public void count() { } value++; Methods may be declared synchronized No two calls by different threads on the same object may be executed simultaneously Calls may be blocked Exit of a synchronized method happens before (officially) subsequent synchronized calls 38
39 Synchronized Methods and Class Extension Synchronized declaration is not inherited by subclasses when a class is extended, must re-declare all synchronized behaviours as necessary in effect, achieve little code reuse for concurrent objects This general principle is called the inheritance anomaly (ref Matsuoka) for concurrent OO If a method is not synchronized, it will ignore the lock and just go ahead. 39
40 Reentrant Lock A thread can acquire the same lock multiple times Current Thread ID is checked against the thread holding the lock if the ID matches (i.e. a re-entrant call), a new entry is allowed The object will stay locked until all entries have exited A thread never blocks waiting for itself 40
41 Single-Threaded Objects A simple idiom for making objects thread-safe Declare all public methods synchronized This part is easy And prohibit other threads accessing fields and unsafe methods Easier said than done! use of private access modifier restricts class level access and not object or thread level access Needs good program discipline This ensures that at most one thread can be using the object at a time 41
42 Synchronization Wrappers An aside: Review Decorator design pattern Extend base object with decorators (or wrappers) Decorators implement same interface Delegate most behaviour to base object Can write synchronization decorators to do so java.util.collections provides static factory methods to construct synchronization wrappers for standard collections List<E> list = Collections.synchronizedList (new ArrayList<E>()); Set<E> set = Collections.synchronizedSet (new HashSet<E> ()); Map<K,V> map = Collections.synchronizedMap (new HashMap<K,V> ()); 42
43 What about Constructors? Constructors can NOT be synchronized Programmer discipline required (again)! Thread-safe as long as the constructor does not leak references to the new object to other threads during constructor execution 43
44 Synchronized Blocks Any block of code can be synchronized A variant of synchronized methods Acquire and release lock for a specified object public void addname(string name) { synchronized(this) { } } lastname = name; namecount++; namelist.add(name); 44
45 Synchronized Block vs Method In general its good style to factor out synchronized blocks into synchronized methods If need be, by refactoring methods so that critical sections needing synchronization appear as separate methods public void addname(string name) { } setname(name); namelist.add(name); synchronized protected void setname(string name) { lastname = name; namecount++; } 45
46 Finer Grain Synchronisation Synchronization blocks allow finer grain of control Gives more flexibility (but use may still indicate poor class design Example: lock splitting public class MsLunch { } private long c1 = 0; private long c2 = 0; private Object lock1 = new Object(); private Object lock2 = new Object(); public void inc1() { synchronized(lock1) { c1++; } } public void inc2() { synchronized(lock2) { c2++; } } 46
47 Finer Grain Synchronisation Exercise: What are the possible interleavings of calls on inc1 and inc2 by different threads? describe this by thinking of each call has being bracketed by two events: call start and call end How is this possible behaviour different from having both inc1 and inc2 declared to be synchronized methods? Why are lock1 and lock2 declared to be of type Object? 47
48 Homework Brush up on your Java skills if need be Recommended IDE is Eclipse (Classic is enough) See Scala web-site for recommended version for use with scala plugin Start reading the online Java Concurrency Tutorial Some parts will be covered in next lecture Decide whether you need to acquire a reference book: first choice is Java Concurrency in Practice Try to compile and run the examples from the Tutorial add print statements to observe interleaving of thread COMP4001 executions CSE UNSW Sydney 48
Java s Implementation of Concurrency, and how to use it in our applications.
Java s Implementation of Concurrency, and how to use it in our applications. 1 An application running on a single CPU often appears to perform many tasks at the same time. For example, a streaming audio/video
More informationThreads Synchronization
Synchronization Threads Synchronization Threads share memory so communication can be based on shared references. This is a very effective way to communicate but is prone to two types of errors: Interference
More informationCS 159: Parallel Processing
Outline: Concurrency using Java CS 159: Parallel Processing Spring 2007 Processes vs Threads Thread basics Synchronization Locks Examples Avoiding problems Immutable objects Atomic operations High"level
More informationThe Java Memory Model
The Java Memory Model What is it and why would I want one? Jörg Domaschka. ART Group, Institute for Distributed Systems Ulm University, Germany December 14, 2009 public class WhatDoIPrint{ static int x
More informationThread Safety. Review. Today o Confinement o Threadsafe datatypes Required reading. Concurrency Wrapper Collections
Thread Safety Today o Confinement o Threadsafe datatypes Required reading Concurrency Wrapper Collections Optional reading The material in this lecture and the next lecture is inspired by an excellent
More informationComputation Abstractions. Processes vs. Threads. So, What Is a Thread? CMSC 433 Programming Language Technologies and Paradigms Spring 2007
CMSC 433 Programming Language Technologies and Paradigms Spring 2007 Threads and Synchronization May 8, 2007 Computation Abstractions t1 t1 t4 t2 t1 t2 t5 t3 p1 p2 p3 p4 CPU 1 CPU 2 A computer Processes
More informationLecture 32: Volatile variables, Java memory model
COMP 322: Fundamentals of Parallel Programming Lecture 32: Volatile variables, Java memory model Vivek Sarkar Department of Computer Science, Rice University vsarkar@rice.edu https://wiki.rice.edu/confluence/display/parprog/comp322
More informationCOMP 346 WINTER Tutorial 2 SHARED DATA MANIPULATION AND SYNCHRONIZATION
COMP 346 WINTER 2018 1 Tutorial 2 SHARED DATA MANIPULATION AND SYNCHRONIZATION REVIEW - MULTITHREADING MODELS 2 Some operating system provide a combined user level thread and Kernel level thread facility.
More informationCS 2112 Lecture 20 Synchronization 5 April 2012 Lecturer: Andrew Myers
CS 2112 Lecture 20 Synchronization 5 April 2012 Lecturer: Andrew Myers 1 Critical sections and atomicity We have been seeing that sharing mutable objects between different threads is tricky We need some
More informationQuiz on Tuesday April 13. CS 361 Concurrent programming Drexel University Fall 2004 Lecture 4. Java facts and questions. Things to try in Java
CS 361 Concurrent programming Drexel University Fall 2004 Lecture 4 Bruce Char and Vera Zaychik. All rights reserved by the author. Permission is given to students enrolled in CS361 Fall 2004 to reproduce
More informationSynchronization SPL/2010 SPL/20 1
Synchronization 1 Overview synchronization mechanisms in modern RTEs concurrency issues places where synchronization is needed structural ways (design patterns) for exclusive access 2 Overview synchronization
More information연세대학교전기전자공학과프로세서연구실박사과정김재억.
이강좌는연세대학교이용석교수연구실에서제작되었으며 copyright가없으므로비영리적인목적에한하여누구든지복사, 배포가가능합니다. 연구실홈페이지에는 고성능마이크로프로세서에관련된많은강의가있으며누구나무료로다운로드받을 수있습니다. 연세대학교전기전자공학과프로세서연구실박사과정김재억 Email: yonglee@yonsei.ac.kr 멀티스레드프로그래밍 (Multithreaded
More informationTest the Byte Class 1 / 17
Test the Byte Class In Lab 1 and Quiz 1 we tested the class Byte by means of JUnit test case ByteTest. If we run the JUnit test case ByteTest and all tests pass, can we conclude that the class Byte correctly
More informationTHREADS & CONCURRENCY
27/04/2018 Sorry for the delay in getting slides for today 2 Another reason for the delay: Yesterday: 63 posts on the course Piazza yesterday. A7: If you received 100 for correctness (perhaps minus a late
More informationG52CON: Concepts of Concurrency
G52CON: Concepts of Concurrency Lecture 1: Introduction Brian Logan School of Computer Science bsl@cs.nott.ac.uk Outline of this lecture" why concurrency... applications of concurrency sequential vs concurrent
More informationCS 31: Introduction to Computer Systems : Threads & Synchronization April 16-18, 2019
CS 31: Introduction to Computer Systems 22-23: Threads & Synchronization April 16-18, 2019 Making Programs Run Faster We all like how fast computers are In the old days (1980 s - 2005): Algorithm too slow?
More informationGet out, you will, of this bind If, your objects, you have confined
CS 455: INTRODUCTION TO DISTRIBUTED SYSTEMS [THREAD SAFETY] Putting the brakes, on impending code breaks Let a reference escape, have you? Misbehave, your code will, out of the blue Get out, you will,
More informationReintroduction to Concurrency
Reintroduction to Concurrency The execution of a concurrent program consists of multiple processes active at the same time. 9/25/14 7 Dining philosophers problem Each philosopher spends some time thinking
More informationCSE 374 Programming Concepts & Tools
CSE 374 Programming Concepts & Tools Hal Perkins Fall 2017 Lecture 22 Shared-Memory Concurrency 1 Administrivia HW7 due Thursday night, 11 pm (+ late days if you still have any & want to use them) Course
More informationTHREADS AND CONCURRENCY
THREADS AND CONCURRENCY Lecture 22 CS2110 Spring 2013 Graphs summary 2 Dijkstra: given a vertex v, finds shortest path from v to x for each vertex x in the graph Key idea: maintain a 5-part invariant on
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 informationCPS221 Lecture: Threads
Objectives CPS221 Lecture: Threads 1. To introduce threads in the context of processes 2. To introduce UML Activity Diagrams last revised 9/5/12 Materials: 1. Diagram showing state of memory for a process
More informationThread Programming. Comp-303 : Programming Techniques Lecture 11. Alexandre Denault Computer Science McGill University Winter 2004
Thread Programming Comp-303 : Programming Techniques Lecture 11 Alexandre Denault Computer Science McGill University Winter 2004 February 16, 2004 Lecture 11 Comp 303 : Programming Techniques Page 1 Announcements
More informationMulti-threading in Java. Jeff HUANG
Multi-threading in Java Jeff HUANG Software Engineering Group @HKUST Do you use them? 2 Do u know their internals? 3 Let s see File DB How can they service so many clients simultaneously? l 4 Multi-threading
More informationCOMP 322: Fundamentals of Parallel Programming
COMP 322: Fundamentals of Parallel Programming https://wiki.rice.edu/confluence/display/parprog/comp322 Lecture 28: Java Threads (contd), synchronized statement Vivek Sarkar Department of Computer Science
More informationAdvances in Programming Languages
Advances in Programming Languages Lecture 8: Concurrency Ian Stark School of Informatics The University of Edinburgh Thursday 11 October 2018 Semester 1 Week 4 https://wp.inf.ed.ac.uk/apl18 https://course.inf.ed.uk/apl
More informationMultiThreading. Object Orientated Programming in Java. Benjamin Kenwright
MultiThreading Object Orientated Programming in Java Benjamin Kenwright Outline Review Essential Java Multithreading Examples Today s Practical Review/Discussion Question Does the following code compile?
More informationRecap. Contents. Reenterancy of synchronized. Explicit Locks: ReentrantLock. Reenterancy of synchronise (ctd) Advanced Thread programming.
Lecture 07: Advanced Thread programming Software System Components 2 Behzad Bordbar School of Computer Science, University of Birmingham, UK Recap How to deal with race condition in Java Using synchronised
More informationSSC - Concurrency and Multi-threading Java multithreading programming - Synchronisation (II)
SSC - Concurrency and Multi-threading Java multithreading programming - Synchronisation (II) Shan He School for Computational Science University of Birmingham Module 06-19321: SSC Outline Outline of Topics
More informationMultitasking Multitasking allows several activities to occur concurrently on the computer. A distinction is usually made between: Process-based multit
Threads Multitasking Multitasking allows several activities to occur concurrently on the computer. A distinction is usually made between: Process-based multitasking Thread-based multitasking Multitasking
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 informationConcurrent Programming using Threads
Concurrent Programming using Threads Threads are a control mechanism that enable you to write concurrent programs. You can think of a thread in an object-oriented language as a special kind of system object
More informationOutline. Threads. Single and Multithreaded Processes. Benefits of Threads. Eike Ritter 1. Modified: October 16, 2012
Eike Ritter 1 Modified: October 16, 2012 Lecture 8: Operating Systems with C/C++ School of Computer Science, University of Birmingham, UK 1 Based on material by Matt Smart and Nick Blundell Outline 1 Concurrent
More informationSharing Objects Ch. 3
Sharing Objects Ch. 3 Visibility What is the source of the issue? Volatile Dekker s algorithm Publication and Escape Thread Confinement Immutability Techniques of safe publication Assignment 1 Visibility
More informationThreads Questions Important Questions
Threads Questions Important Questions https://dzone.com/articles/threads-top-80-interview https://www.journaldev.com/1162/java-multithreading-concurrency-interviewquestions-answers https://www.javatpoint.com/java-multithreading-interview-questions
More informationConcurrency, Thread. Dongkun Shin, SKKU
Concurrency, Thread 1 Thread Classic view a single point of execution within a program a single PC where instructions are being fetched from and executed), Multi-threaded program Has more than one point
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 informationProgrammazione di sistemi multicore
Programmazione di sistemi multicore A.A. 2015-2016 LECTURE 12 IRENE FINOCCHI http://wwwusers.di.uniroma1.it/~finocchi/ Shared-memory concurrency & mutual exclusion TASK PARALLELISM AND OVERLAPPING MEMORY
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 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 informationCMSC 433 Programming Language Technologies and Paradigms. Concurrency
CMSC 433 Programming Language Technologies and Paradigms Concurrency What is Concurrency? Simple definition Sequential programs have one thread of control Concurrent programs have many Concurrency vs.
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 informationReal-Time and Concurrent Programming Lecture 4 (F4): Monitors: synchronized, wait and notify
http://cs.lth.se/eda040 Real-Time and Concurrent Programming Lecture 4 (F4): Monitors: synchronized, wait and notify Klas Nilsson 2016-09-20 http://cs.lth.se/eda040 F4: Monitors: synchronized, wait and
More informationThe New Java Technology Memory Model
The New Java Technology Memory Model java.sun.com/javaone/sf Jeremy Manson and William Pugh http://www.cs.umd.edu/~pugh 1 Audience Assume you are familiar with basics of Java technology-based threads (
More informationCSE 332: Data Structures & Parallelism Lecture 17: Shared-Memory Concurrency & Mutual Exclusion. Ruth Anderson Winter 2019
CSE 332: Data Structures & Parallelism Lecture 17: Shared-Memory Concurrency & Mutual Exclusion Ruth Anderson Winter 2019 Toward sharing resources (memory) So far, we have been studying parallel algorithms
More informationMultithreading and Interactive Programs
Multithreading and Interactive Programs CS160: User Interfaces John Canny. Last time Model-View-Controller Break up a component into Model of the data supporting the App View determining the look of the
More informationParallelism Marco Serafini
Parallelism Marco Serafini COMPSCI 590S Lecture 3 Announcements Reviews First paper posted on website Review due by this Wednesday 11 PM (hard deadline) Data Science Career Mixer (save the date!) November
More informationEI 338: Computer Systems Engineering (Operating Systems & Computer Architecture)
EI 338: Computer Systems Engineering (Operating Systems & Computer Architecture) Dept. of Computer Science & Engineering Chentao Wu wuct@cs.sjtu.edu.cn Download lectures ftp://public.sjtu.edu.cn User:
More informationCSE332: Data Abstractions Lecture 23: Programming with Locks and Critical Sections. Tyler Robison Summer 2010
CSE332: Data Abstractions Lecture 23: Programming with Locks and Critical Sections Tyler Robison Summer 2010 1 Concurrency: where are we Done: The semantics of locks Locks in Java Using locks for mutual
More informationIntroduction to Locks. Intrinsic Locks
CMSC 433 Programming Language Technologies and Paradigms Spring 2013 Introduction to Locks Intrinsic Locks Atomic-looking operations Resources created for sequential code make certain assumptions, a large
More informationA Sophomoric Introduction to Shared-Memory Parallelism and Concurrency Lecture 5 Programming with Locks and Critical Sections
A Sophomoric Introduction to Shared-Memory Parallelism and Concurrency Lecture 5 Programming with Locks and Critical Sections Dan Grossman Last Updated: May 2012 For more information, see http://www.cs.washington.edu/homes/djg/teachingmaterials/
More informationAdvanced concurrent programming in Java Shared objects
Advanced concurrent programming in Java Shared objects Mehmet Ali Arslan 21.10.13 Visibility To see(m) or not to see(m)... 2 There is more to synchronization than just atomicity or critical sessions. Memory
More informationPOSIX Threads: a first step toward parallel programming. George Bosilca
POSIX Threads: a first step toward parallel programming George Bosilca bosilca@icl.utk.edu Process vs. Thread A process is a collection of virtual memory space, code, data, and system resources. A thread
More informationCST242 Concurrency Page 1
CST242 Concurrency Page 1 1 2 3 4 5 6 7 9 Concurrency CST242 Concurrent Processing (Page 1) Only computers with multiple processors can truly execute multiple instructions concurrently On single-processor
More informationFrequently asked questions from the previous class survey
CS 370: OPERATING SYSTEMS [THREADS] Shrideep Pallickara Computer Science Colorado State University L7.1 Frequently asked questions from the previous class survey When a process is waiting, does it get
More informationDesign of Thread-Safe Classes
Design of Thread-Safe Classes 1 Topic Outline Thread-Safe Classes Principles Confinement Delegation Synchronization policy documentation 2 Thread-safe Class Design Process Identify the object s state (variables)
More informationJAVA CONCURRENCY FRAMEWORK. Kaushik Kanetkar
JAVA CONCURRENCY FRAMEWORK Kaushik Kanetkar Old days One CPU, executing one single program at a time No overlap of work/processes Lots of slack time CPU not completely utilized What is Concurrency Concurrency
More informationJava Concurrency in practice Chapter 9 GUI Applications
Java Concurrency in practice Chapter 9 GUI Applications INF329 Spring 2007 Presented by Stian and Eirik 1 Chapter 9 GUI Applications GUI applications have their own peculiar threading issues To maintain
More informationEffective Concurrent Java. Brian Goetz Sr. Staff Engineer, Sun Microsystems
Effective Concurrent Java Brian Goetz Sr. Staff Engineer, Sun Microsystems brian.goetz@sun.com The Big Picture Writing correct concurrent code is difficult, but not impossible. Using good object-oriented
More informationCISC370: Inheritance
CISC370: Inheritance Sara Sprenkle 1 Questions? Review Assignment 0 due Submissions CPM Accounts Sara Sprenkle - CISC370 2 1 Quiz! Sara Sprenkle - CISC370 3 Inheritance Build new classes based on existing
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 information20 Most Important Java Programming Interview Questions. Powered by
20 Most Important Java Programming Interview Questions Powered by 1. What's the difference between an interface and an abstract class? An abstract class is a class that is only partially implemented by
More informationCMSC 433 Programming Language Technologies and Paradigms. Spring 2013
CMSC 433 Programming Language Technologies and Paradigms Spring 2013 Encapsulation, Publication, Escape Data Encapsulation One of the approaches in object-oriented programming is to use data encapsulation
More informationExecutive Summary. It is important for a Java Programmer to understand the power and limitations of concurrent programming in Java using threads.
Executive Summary. It is important for a Java Programmer to understand the power and limitations of concurrent programming in Java using threads. Poor co-ordination that exists in threads on JVM is bottleneck
More informationAdvanced Concepts of Programming
Berne University of Applied Sciences E. Benoist / E. Dubuis January 2005 1 Multithreading in Java Java provides the programmer with built-in threading capabilities The programmer can create and manipulate
More informationAgenda. Highlight issues with multi threaded programming Introduce thread synchronization primitives Introduce thread safe collections
Thread Safety Agenda Highlight issues with multi threaded programming Introduce thread synchronization primitives Introduce thread safe collections 2 2 Need for Synchronization Creating threads is easy
More informationChapter 1 GETTING STARTED. SYS-ED/ Computer Education Techniques, Inc.
Chapter 1 GETTING STARTED SYS-ED/ Computer Education Techniques, Inc. Objectives You will learn: Java platform. Applets and applications. Java programming language: facilities and foundation. Memory management
More information+ Today. Lecture 26: Concurrency 3/31/14. n Reading. n Objectives. n Announcements. n P&C Section 7. n Race conditions.
+ Lecture 26: Concurrency Slides adapted from Dan Grossman + Today n Reading n P&C Section 7 n Objectives n Race conditions n Announcements n Quiz on Friday 1 + This week s programming assignment n Answer
More informationSynchronization. Announcements. Concurrent Programs. Race Conditions. Race Conditions 11/9/17. Purpose of this lecture. A8 released today, Due: 11/21
Announcements Synchronization A8 released today, Due: 11/21 Late deadline is after Thanksgiving You can use your A6/A7 solutions or ours A7 correctness scores have been posted Next week's recitation will
More informationConcurrent systems Lecture 1: Introduction to concurrency, threads, and mutual exclusion
Concurrent systems Lecture 1: Introduction to concurrency, threads, and mutual exclusion Michaelmas 2016 Dr Robert N. M. Watson (With thanks to Dr Steven Hand) 1 Concurrent and distributed systems One
More informationVirtual Machine Design
Virtual Machine Design Lecture 4: Multithreading and Synchronization Antero Taivalsaari September 2003 Session #2026: J2MEPlatform, Connected Limited Device Configuration (CLDC) Lecture Goals Give an overview
More informationLecture 16: Thread Safety in Java
COMP 150-CCP Concurrent Programming Lecture 16: Thread Safety in Java Dr. Richard S. Hall rickhall@cs.tufts.edu Concurrent programming March 13, 2008 Reference The content of this lecture is based on Chapter
More informationAgenda CS121/IS223. Reminder. Object Declaration, Creation, Assignment. What is Going On? Variables in Java
CS121/IS223 Object Reference Variables Dr Olly Gotel ogotel@pace.edu http://csis.pace.edu/~ogotel Having problems? -- Come see me or call me in my office hours -- Use the CSIS programming tutors Agenda
More informationG Programming Languages Spring 2010 Lecture 13. Robert Grimm, New York University
G22.2110-001 Programming Languages Spring 2010 Lecture 13 Robert Grimm, New York University 1 Review Last week Exceptions 2 Outline Concurrency Discussion of Final Sources for today s lecture: PLP, 12
More informationSafety SPL/2010 SPL/20 1
Safety 1 system designing for concurrent execution environments system: collection of objects and their interactions system properties: Safety - nothing bad ever happens Liveness - anything ever happens
More informationCE221 Programming in C++ Part 1 Introduction
CE221 Programming in C++ Part 1 Introduction 06/10/2017 CE221 Part 1 1 Module Schedule There are two lectures (Monday 13.00-13.50 and Tuesday 11.00-11.50) each week in the autumn term, and a 2-hour lab
More informationCIS233J Java Programming II. Threads
CIS233J Java Programming II Threads Introduction The purpose of this document is to introduce the basic concepts about threads (also know as concurrency.) Definition of a Thread A thread is a single sequential
More informationCS 556 Distributed Systems
CS 556 Distributed Systems Tutorial on 4 Oct 2002 Threads A thread is a lightweight process a single sequential flow of execution within a program Threads make possible the implementation of programs that
More informationJava Threads and intrinsic locks
Java Threads and intrinsic locks 1. Java and OOP background fundamentals 1.1. Objects, methods and data One significant advantage of OOP (object oriented programming) is data encapsulation. Each object
More informationA Sophomoric Introduction to Shared-Memory Parallelism and Concurrency Lecture 4 Shared-Memory Concurrency & Mutual Exclusion
A Sophomoric Introduction to Shared-Memory Parallelism and Concurrency Lecture 4 Shared-Memory Concurrency & Mutual Exclusion Dan Grossman Last Updated: August 2010 For more information, see http://www.cs.washington.edu/homes/djg/teachingmaterials/
More informationTHREADS & CONCURRENCY
4/26/16 Announcements BRING YOUR CORNELL ID TO THE PRELIM. 2 You need it to get in THREADS & CONCURRENCY Prelim 2 is next Tonight BRING YOUR CORNELL ID! A7 is due Thursday. Our Heap.java: on Piazza (A7
More informationOutline. Java Models for variables Types and type checking, type safety Interpretation vs. compilation. Reasoning about code. CSCI 2600 Spring
Java Outline Java Models for variables Types and type checking, type safety Interpretation vs. compilation Reasoning about code CSCI 2600 Spring 2017 2 Java Java is a successor to a number of languages,
More informationThread-Local. Lecture 27: Concurrency 3. Dealing with the Rest. Immutable. Whenever possible, don t share resources
Thread-Local Lecture 27: Concurrency 3 CS 62 Fall 2016 Kim Bruce & Peter Mawhorter Some slides based on those from Dan Grossman, U. of Washington Whenever possible, don t share resources Easier to have
More informationIntroduction to concurrency and GUIs
Principles of Software Construction: Objects, Design, and Concurrency Part 2: Designing (Sub)systems Introduction to concurrency and GUIs Charlie Garrod Bogdan Vasilescu School of Computer Science 1 Administrivia
More informationCS121/IS223. Object Reference Variables. Dr Olly Gotel
CS121/IS223 Object Reference Variables Dr Olly Gotel ogotel@pace.edu http://csis.pace.edu/~ogotel Having problems? -- Come see me or call me in my office hours -- Use the CSIS programming tutors CS121/IS223
More informationFaculty of Computers & Information Computer Science Department
Cairo University Faculty of Computers & Information Computer Science Department Theoretical Part 1. Introduction to Critical Section Problem Critical section is a segment of code, in which the process
More informationChapter 2 Processes and Threads
MODERN OPERATING SYSTEMS Third Edition ANDREW S. TANENBAUM Chapter 2 Processes and Threads The Process Model Figure 2-1. (a) Multiprogramming of four programs. (b) Conceptual model of four independent,
More informationCS 31: Intro to Systems Threading & Parallel Applications. Kevin Webb Swarthmore College November 27, 2018
CS 31: Intro to Systems Threading & Parallel Applications Kevin Webb Swarthmore College November 27, 2018 Reading Quiz Making Programs Run Faster We all like how fast computers are In the old days (1980
More informationLecture 17: Sharing Objects in Java
COMP 150-CCP Concurrent Programming Lecture 17: Sharing Objects in Java Dr. Richard S. Hall rickhall@cs.tufts.edu Concurrent programming March 25, 2008 Reference The content of this lecture is based on
More informationSynchronization Lecture 24 Fall 2018
Synchronization Lecture 24 Fall 2018 Prelim 2 tonight! The room assignments are on the course website, page Exams. Check it carefully! Come on time! Bring you Cornell id card! No lunch with gries this
More informationJAVA and J2EE UNIT - 4 Multithreaded Programming And Event Handling
JAVA and J2EE UNIT - 4 Multithreaded Programming And Event Handling Multithreaded Programming Topics Multi Threaded Programming What are threads? How to make the classes threadable; Extending threads;
More informationLecture 29: Java s synchronized statement
COMP 322: Fundamentals of Parallel Programming Lecture 29: Java s synchronized statement Vivek Sarkar Department of Computer Science, Rice University vsarkar@rice.edu https://wiki.rice.edu/confluence/display/parprog/comp322
More informationB2.52-R3: INTRODUCTION TO OBJECT ORIENTATED PROGRAMMING THROUGH JAVA
B2.52-R3: INTRODUCTION TO OBJECT ORIENTATED PROGRAMMING THROUGH JAVA NOTE: 1. There are TWO PARTS in this Module/Paper. PART ONE contains FOUR questions and PART TWO contains FIVE questions. 2. PART ONE
More informationIntroduction to Concurrent Software Systems. CSCI 5828: Foundations of Software Engineering Lecture 08 09/17/2015
Introduction to Concurrent Software Systems CSCI 5828: Foundations of Software Engineering Lecture 08 09/17/2015 1 Goals Present an overview of concurrency in software systems Review the benefits and challenges
More informationJava Threads. COMP 585 Noteset #2 1
Java Threads The topic of threads overlaps the boundary between software development and operation systems. Words like process, task, and thread may mean different things depending on the author and the
More informationProgrammazione Avanzata e Paradigmi Ingegneria e Scienze Informatiche - UNIBO a.a 2013/2014 Lecturer: Alessandro Ricci
v1.0 20130323 Programmazione Avanzata e Paradigmi Ingegneria e Scienze Informatiche - UNIBO a.a 2013/2014 Lecturer: Alessandro Ricci [module lab 2.1] CONCURRENT PROGRAMMING IN JAVA: INTRODUCTION 1 CONCURRENT
More informationOperating Systems CMPSCI 377, Lec 2 Intro to C/C++ Prashant Shenoy University of Massachusetts Amherst
Operating Systems CMPSCI 377, Lec 2 Intro to C/C++ Prashant Shenoy University of Massachusetts Amherst Department of Computer Science Why C? Low-level Direct access to memory WYSIWYG (more or less) Effectively
More informationJava Programming. Price $ (inc GST)
1800 ULEARN (853 276) www.ddls.com.au Java Programming Length 5 days Price $4235.00 (inc GST) Overview Intensive and hands-on, the course emphasizes becoming productive quickly as a Java application developer.
More informationCS 160: Interactive Programming
CS 160: Interactive Programming Professor John Canny 3/8/2006 1 Outline Callbacks and Delegates Multi-threaded programming Model-view controller 3/8/2006 2 Callbacks Your code Myclass data method1 method2
More informationConcurrency & Synchronization. COMPSCI210 Recitation 25th Feb 2013 Vamsi Thummala Slides adapted from Landon Cox
Concurrency & Synchronization COMPSCI210 Recitation 25th Feb 2013 Vamsi Thummala Slides adapted from Landon Cox Midterm Review http://www.cs.duke.edu/~chase/cps11 0-archive/midterm-210-13s1.pdf Please
More information