CS 152: Programming Language Paradigms April 30 Class Meeting Department of Computer Science San Jose State University Spring 2014 Instructor: Ron Mak.

CS 152: Programming Language Paradigms

April 30 Class Meeting

Department of Computer ScienceSan Jose State University

Spring 2014Instructor: Ron Mak

www.cs.sjsu.edu/~mak

http://www.cs.sjsu.edu/~mak

http://www.cs.sjsu.edu/~mak

SJSU Dept. of Computer ScienceSpring 2014: April 30

CS 152: Programming Language Paradigms© R. Mak

2

CS Department Colloquium Prof. Juliette Kennedy

Professor of Mathematics University of Helsinki

Talk: “Reading Gödel’s 1946 Princeton Bicentennial Lecture” About the problem of transferring the

Turing analysis of computability to the cases of definability and provability.

Thursday, May 1, 3:00 PM MacQuarrie Hall, room 225



3

CS Department Colloquium, cont’d

See http://www.cs.sjsu.edu/sp14/kennedy.html

Up to 10 extra credit points if you attend. Added to your final score.

You must write a short summary of what the talk was about. One or two pages. Due Monday, May 5.

_

http://www.cs.sjsu.edu/sp14/kennedy.html



4

Computer History Museum

Saturday, May 3 at 11:30 AM.

Revolution Exhibit

IBM 1401 Demo Lab at 11:45 and 12:30 Not everybody at once, please!

Babbage Difference Engine Demo at 1:00

Extra-credit quiz To be posted to Canvas and Piazza



5

Multithreaded Programming in Java

Multithreaded programming involves havingmultiple threads of execution happening concurrently within a single Java program.

A thread is a program unit that executes independently of other parts of the program._



6

Thread vs. Process

A process is an executing program managed by the operating system.

A process has its own resources, such as its separate runtime stack and its separate share of main memory.

Switching between processes is relatively slow.

A thread runs within a single process.

Process resources such as memory are shared. Thread switching is very fast.



7

How to Create a Java Thread

Define a class that implements the Runnable interface:

Put the code that you want to run in parallel with other code in the run() method.

public interface Runnable{ void run();}

public class GreetingProducer implements Runnable { ...

public void run() { // Code to run in parallel here. }}



8

Runnable Example

Repeatedly print a greeting. Thread.sleep() yields control to another thread.

Can throw the InterruptedException exception.

public void run() { try { for (int i = 1; i <= REPETITIONS; i++) { System.out.println(i + ": " + greeting); Thread.sleep(DELAY); } } catch (InterruptedException exception) { // do nothing }}



9

Runnable Example, cont’d Example:

Create two threads. Each thread loops to repeatedly print a greeting.

Create a Runnable object of the class. Construct a Thread object using the Runnable object. Call the start() method of the Thread object.

Runnable r1 = new GreetingProducer("Hello, World!");Runnable r2 = new GreetingProducer("Goodbye, World!");

Thread t1 = new Thread(r1);Thread t2 = new Thread(r2);

t1.start();t2.start();

Demo: threads



10

Runnable Example, cont’d

The output may not always be perfectly interleaved! The thread scheduler

does not guarantee the order that the threads will execute.

1: Hello, World! 1: Goodbye, World! 2: Hello, World! 2: Goodbye, World! 3: Hello, World! 3: Goodbye, World! 4: Hello, World! 4: Goodbye, World! 5: Hello, World! 5: Goodbye, World! 6: Hello, World! 6: Goodbye, World! 7: Hello, World! 7: Goodbye, World! 8: Goodbye, World! 8: Hello, World! 9: Goodbye, World! 9: Hello, World! 10: Goodbye, World! 10: Hello, World!



11

Thread States

Each thread has a stateand a priority.

A state can be blockedif it is: sleeping waiting for I/O waiting to acquire a lock waiting for a condition

No state for athread that’srunning.



12

Activating Threads

The thread scheduler activates a thread whenever:

A running thread has completed its time slice.

A running thread blocks itself.

A thread with a higher priority becomes available._



13

Choosing Threads to Run

The thread scheduler determines which thread to run:

It selects the highest priority thread that is currently runnable.

The Java standard does not specify which thread among the eligible ones should be scheduled. random selection? round robin?



14

Terminating Threads

A thread terminates “naturally” when its run() method completes.

You can also interrupt a running thread from another thread:_ t1.interrupt();



15

Terminating Threads, cont’d

The thread can test whether the interrupt flag has been set:

Or it can catch the InterruptedException thrown by the Thread.sleep() method when the thread is interrupted.

Terminate the run() method after an interruption._

if (Thread.currentThread().isInterrupted()) { ... }



16

Thread Synchronization Example

Suppose a bounded queue object (circular buffer) is shared among several threads.

Two producer threads add messages. One adds “A Message”. The other adds “B Message”. Each prints the messages as it adds them.

One consumer thread removes messages. Prints the messages as it removes them.



17

Thread Synchronization, cont’d

The run() method of the Producer class:

int i = 1;

while (i <= count) { if (!queue.isFull()) { Message msg = new Message(index, i, text); queue.add(msg); ... i++; }

Thread.sleep((int) (DELAY*Math.random()));}



18

Thread Synchronization, cont’d

The run() method of the Consumer class:

int i = 1;

while (i <= count) { if (!queue.isEmpty()) { Message msg = queue.remove(); ... i++; }

Thread.sleep((int) (DELAY*Math.random()));}



19

Thread Synchronization, cont’d Create the queue. Create and start the threads.BoundedQueue queue = new BoundedQueue(10);

final int PRODUCER_C0UNT = 2;final int MESSAGE_COUNT = 100;

Runnable run1 = new Producer("A Message", queue, 1, MESSAGE_COUNT);Runnable run2 = new Producer("B Message", queue, 2, MESSAGE_COUNT);Runnable run3 = new Consumer(queue, PRODUCER_C0UNT*MESSAGE_COUNT);

Thread thread1 = new Thread(run1);Thread thread2 = new Thread(run2);Thread thread3 = new Thread(run3);

thread1.start();thread2.start();thread3.start();

Demo: queue1



20

What Can Go Wrong?

The consumer can’t retrieve all the messages that the producers inserted.

The consumer retrieves the same message multiple times._



21

What Can Go Wrong? cont’d How can such problems occur?

1. The first producer thread calls add() and executes elements[tail] = newValue;

2. The first producer thread reaches the end of its time slice .3. The second producer thread calls add() and executes

elements[tail] = newValue; tail++;

4. The second producer thread reaches the end of its time slice .5. The first producer thread executes

tail++; Bad consequences!

Step 1 starts to add a message to the queue. Step 3 overwrites the message added in step 1. Step 5 increments the tail index without filling the location,

leaving behind garbage.



22

"Message B"

"Message B"

"Message B"

"Message A"



23

A Race Condition

A race condition occurs when multiple threads access and modify some shared data, and the final result depends on the order that the threads modified the data.

An extremely bad situation. Results are often unpredictable and unrepeatable. Extremely hard to debug. Must avoid!

_



24

Another Race Condition Example

Suppose variable count is shared.

count++ can be implemented as: register1 = count register1 = register1 + 1 count = register1

count-- can be implemented as: register2 = count register2 = register2 – 1 count = register2



25

Another Race Condition Example, cont’d

Suppose the value of count is 5 and that thread T1 executes count++ at the same time that thread T2 executes count--.

Thread Operation ResultT1 register1 = count register1 = 5T1 register1 = register1 + 1 register1 = 6T2 register2 = count register2 = 5T2 register2 = register2 - 1 register2 = 4T1 count = register1 count = 6T2 count = register2 count = 4



26

Another Race Condition Example, cont’d

Thread Operation ResultT1 register1 = count register1 = 5T1 register1 = register1 + 1 register1 = 6T2 register2 = count register2 = 5T2 register2 = register2 - 1 register2 = 4T1 count = register1 count = 6T2 count = register2 count = 4

Whether count ends up equal to 6 or 4 depends on the order of the last two instructions._



27

Mutual Exclusion

One way to avoid race conditions is to prevent more than one thread from reading and writing the shared data at the same time.

This is called mutual exclusion.

Thread schedulers provide different primitives to achieve mutual exclusion._



28

Critical Region

A critical region (AKA critical section) is the part of a program’s code thatoperates on some shared data.

We need to prevent two threads from accessing that shared data at the same time.

Therefore, we need to prevent two threads from

being in their critical regions at the same time._



29

A Solution: Locks

When one thread enters its critical region, another thread must be prevented from entering its critical region.

The first thread must set a lock before entering the critical region, execute the code in the critical region, and then unlock the lock.

If another thread attempts to enter its critical region, that thread must wait until the lock is unlocked.



30

Locks, cont’d

Java provides re-entrant locks.

But is it sufficient to lock up the add() and remove() code of BoundedQueue?

Demo: queue2

Lock aLock = new ReentrantLock();...aLock.lock();try { critical region}finally { aLock.unlock();}



31

Locks, cont’d

Consider what the Producer does:if (!queue.isFull()) { Message msg = new Message(index, i, text); queue.add(msg); ...}



32

Locks, cont’d

Suppose the first Producer thread determines that the queue is not full.

But before it can call queue.add(), another Producer thread fills up the queue.

When the first Producer thread is reactivated, it adds to a full queue and thereby corrupts it.

if (!queue.isFull()) { Message msg = new Message(index, i, text); queue.add(msg); ...}



33

Locks, cont’d

Therefore, testing whether the queue is full and adding to the queue must happen together under the same lock._

if (!queue.isFull()) { Message msg = new Message(index, i, text); queue.add(msg); ...}

CS 152: Programming Language Paradigms April 30 Class Meeting Department of Computer Science San Jose State University Spring 2014 Instructor: Ron Mak.

Documents