Threads
Sponsored Links
This presentation is the property of its rightful owner.
1 / 30

Threads PowerPoint PPT Presentation


  • 90 Views
  • Uploaded on
  • Presentation posted in: General

Threads. CS 3250. Some of these slides contain material by Professor Chuck Allison. What is a thread?. an independent unit of execution within a process a path of execution through a program a "lightweight process". Sharing (or not).

Download Presentation

Threads

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Threads

CS 3250

Some of these slides contain material by Professor Chuck Allison


What is a thread?

  • an independent unit of execution within a process

  • a path of execution through a program

  • a "lightweight process"


Sharing (or not)

  • Threads share the same address space and share the heap

    • + Easy to communicate with other threads

    • - Possibility of inconsistent states

  • Each thread has its own execution stack


  • Multi-threaded vs. Single-threaded

    Advantages of using more than one thread:

    • Single-threaded processes can't easily handle concurrent activities

      • e.g., waiting for user I/O, network I/O, and doing calculations at the same time

    • Better performance if more than one processor

      • No guarantees

      • Can sometimes get better performance even if there's only one CPU. How?


    Multi-threaded vs. Single-threaded

    Disadvantages of using more than one thread:

    • Race conditions and deadlock

    • One thread can accidentally modify another's resources.

    • Have to deal with synchronization.

    • Concurrency can lead to worse performance rather than better.


    Pitfalls

    • Watch out for libraries that aren’t thread-safe

    • Don’t make any assumptions about when threads will execute.

    • Don’t use reasoning like “that will hardly ever happen”.

    • Testing is necessary but not sufficient.

    • Test on a variety of systems.


    Pitfalls

    • Only use threads when appropriate.

    • “Fortunately, correct programs are frequently the simplest and have the most elegant design. Complexity should be avoided wherever possible.”

    Windows System Programming, p. 223


    A First Example

    // Illustrates Independent Threads

    class MyThread extends Thread

    {

    private int count;

    public MyThread(String name, int count)

    {

    super(name); // Optional thread name

    this.count = count;

    }

    public void run()

    {

    for (inti = 0; i < count; ++i)

    System.out.println(getName());

    }

    }

    Example by Professor Chuck Allison


    Main program launches 2 threads

    public class Independent

    {

    public static void main(String[] args)

    {

    Thread t1 = new MyThread("DessertTopping", 8);

    Thread t2 = new MyThread("FloorWax", 4);

    t1.start();

    t2.start();

    }

    }

    Define run(), call start()


    Output(Dependent on platform and environment - YMMV)

    DessertTopping

    DessertTopping

    DessertTopping

    FloorWax

    DessertTopping

    FloorWax

    DessertTopping

    FloorWax

    DessertTopping

    FloorWax

    DessertTopping

    DessertTopping


    The Runnable Interface

    • Alternative to extending java.lang.Thread

    • Declares a run( ) method

    • 2 virtues:

      • Separates task from thread objects

      • Leaves you free to extend another class

        • Java only supports single inheritance

    • Thread has a constructor that takes a Runnable object


    The Runnable interface

    class MyTask implements Runnable{

    private int count;

    private String name;

    public MyThread(String name, int count){

    this.count= count;

    this.name= name;

    }

    public void run(){

    for (inti = 0; i < count; ++i)

    System.out.println(name);

    }

    }


    Create threads fromRunnable objects

    public class IndependentR{

    public static void main(String[] args){

    Thread t1 = new Thread(

    new MyTask("DessertTopping", 8));

    Thread t2 = new Thread(

    new MyTask("FloorWax", 4));

    t1.start();

    t2.start();

    }

    }


    Blocking I/O

    • Note that the calls to println( ) run uninterrupted

    • I/O is a blocking operation

      • The thread waits until it completes

      • Other threads may run, but the I/O will be undisturbed

        • Reason: I/O is coarse-grained native code

    • JDK 1.4 java.nio provides non-blocking I/O

      • Buffers, channels, selectors, for more fine-grained control

        • One thread can manage multiple connections


    Interleaved I/O

    class MyThread extends Thread

    {

    // <snip>

    public void run()

    {

    for (inti = 0; i < count; ++i)

    {

    display();// Replaces println()

    }

    }

    void display()

    {

    String s = getName();

    for (inti = 0; i < s.length(); ++i)

    System.out.print(s.charAt(i));

    System.out.println();

    }

    }

    Example by Professor Chuck Allison


    Output (interleaved – oops!)

    DessertTopping

    DFloorWax

    FloorWax

    FloorWax

    FloorWessertTopping

    Desax

    sertTopping

    DessertTopping

    DessertTopping

    DessertTopping

    DessertTopping

    DessertTopping


    Race Condition

    balance starts at 1000

    result of executing program(s) depends on who runs precisely when

    Thread 1

    Thread 2

    b = getBalance(“1234”);

    b -= 100;

    setBalance(“1234”, b);

    b = getBalance(“1234”);

    b += 500;

    setBalance(“1234”, b);

    What should the ending balance be? What will it be?

    Will getting rid of the local variable b solve the problem?

    How can we solve this problem?


    Synchronization

    • Need to prevent race conditions

    • Critical region

      • Part of a program that accesses shared memory (or another shared resource)

    • To prevent race conditions, only allow one thread at a time to enter critical region


    Locks and Monitors

    • Every object has a hidden lock object

      • Used to protect code blocks

    • Monitor concept

      • Only allows one thread in at a time

      • Thread acquires a lock via some object

      • Other related threads wait until lock is released

        • Applies to all guarded methods for that object only

    • Achieved with the synchronized keyword

      • Protects code (not data directly)

      • Make data private!


    How synchronized works(conceptually)

    synchronized void f()

    {

    <protected code>

    }

    is the same as the following pseudocode…

    • void f() {

      • this.lock.acquire();

      • try

      • {

      • <protected code>

      • }

      • finally

      • {

      • this.lock.release();

      • }

    • }

    Very important. Why?


    Library Example

    • Check-out system

      • Usually solved by database locks, but humor me

    • Book class

    • Must only allow one thread access to check-out check-in code

    • Synchronized methods


    // Illustrates synchronized methods

    class Book

    {

    private final String title;

    private final String author;

    private String borrower;

    public Book(String title, String author)

    {

    this.title = title;

    this.author = author;

    borrower = null;

    }

    public synchronized boolean

    checkOut(String borrower)

    {

    if (isAvailable())

    {

    this.borrower = borrower;

    return true;

    }

    else

    return false;

    }


    public synchronized boolean checkIn()

    {

    if (!isAvailable())

    {

    borrower = null;

    return true;

    }

    else

    return false;

    }

    public String getTitle()

    {

    return title;

    }

    public String getAuthor()

    {

    return author;

    }


    public synchronized boolean isAvailable()

    {

    return borrower == null;

    }

    public synchronized String getBorrower()

    {

    return borrower;

    }

    }


    Principles

    • Always make data private

    • Always protect access to shared data with a monitor (i.e., using synchronized)

    • Synchronize as little code as possible

      • Blocks instead of entire methods:

        • {… synchronized (obj) {…} … }


    Synchronizing display

    class MyThread extends Thread

    {

    private static Object lock = new Object();

    // <snip>

    void display()

    {

    synchronized(lock) {

    String s = getName();

    for (inti = 0; i < s.length(); ++i)

    System.out.print(s.charAt(i));

    System.out.println();

    }

    }

    }


    Output (not interleaved)

    DessertTopping

    FloorWax

    DessertTopping

    DessertTopping

    FloorWax

    DessertTopping

    DessertTopping

    FloorWax

    DessertTopping

    DessertTopping

    FloorWax

    DessertTopping


    A simpler way of synchronizing display

    synchronized static void display(Strings)

    {

    for (inti = 0; i < s.length(); ++i)

    System.out.print(s.charAt(i));

    System.out.println();

    }

    Will use lock on class object


    Threads and Exceptions

    • Exceptions belong to a thread

      • Both are stack-based

    • When an exception occurs in a monitor, the lock is released

    • For uncaught exceptions, the current thread dies

      • ThreadGroup.uncaughtException() is called, which prints the stack trace as its default behavior


    Deadlock

    • Circular wait

      • e.g., Breakfasting Kindergarteners, pirate map

    • Order access to resources

    • All or nothing requests for resources

      • Must get everything requested or nothing


  • Login