practical session 6 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Practical Session 6 PowerPoint Presentation
Download Presentation
Practical Session 6

Loading in 2 Seconds...

play fullscreen
1 / 25

Practical Session 6 - PowerPoint PPT Presentation


  • 135 Views
  • Uploaded on

Practical Session 6. Multitasking vs. multithreading Threads Concurrency vs. Parallelism Java Threads Thread confinement Object/Class Immutability. Multitasking vs. Multithreading . Multitasking: Running more than one process on same processor.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Practical Session 6' - fedora


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
practical session 6

Practical Session 6

Multitasking vs. multithreading

Threads

Concurrency vs. Parallelism

Java Threads

Thread confinement

Object/Class Immutability

multitasking vs multithreading
Multitasking vs. Multithreading
  • Multitasking:
    • Running more than one process on same processor.
    • Uses context switching between different processes:

(context=CPU state=content of CPU registers + program counter)

      • Switching from process A to B:
        • Context of process A is stored.
        • Context of process B is restored.
  • Multithreading:
    • Running more than one thread under same process.
    • Has the ability of resource sharing – all threads can access all resources of a process.
threads
Threads
  • Definition
    • A way to share a single CPU between multiple tasks.
  • Benefits
    • Allows maintaining responsiveness of an application.
      • HTTP Server waiting for requests
    • Enable cancellation of separate tasks
    • Some problems require parallelism
      • Google’s Map/Reduce
    • Allows monitoring status of a resource (data base)
    • Allows taking advantage of multiple processors
concurrency vs parallelism
Concurrency vs. Parallelism
  • Concurrency:
    • Two tasks can start and compete for CPU resources
      • Two threads running on same processor
      • They “share” the processor.
  • Parallelism
    • Two tasks that run at the same time in parallel.
      • They do not compete on process time.
      • Threads are executing simultaneously
java threads
Java Threads
  • Done by implementing the interface java.lang.Runnable.
  • java.lang.Runnable
    • Allows any class that implements it to operate as a thread.
    • Requires one method to be implemented:
      • public void run()
    • Implementation:

class <className> implements Runnable {

public void run(){

//the “main” function of the thread

}

}

how to run threads
How to Run Threads
  • By implementing Runnable and wrapping it with a Threadinstance.
    • takes a single Runnable object and executes it in a separate thread.
    • It is activated by calling start()
      • calls the Runnable run() method.
  • By implementing Runnable and passing it to an Executor.
  • By extending the Thread class.
wrapped by a thread threads01 java
Wrapped by a Thread- Threads01.java
  • class SimpleRunnable implements Runnable {
  • private String name;
  • SimpleRunnable(String name) {
  • this.name = name;
  • }
  • //prints name three time waits 0.1 second between each print
  • public void run() {
    • for (int i = 0; i < 3; i++) {
  • System.out.println("RUNNABLE:" + this.name);
  • try {
  • Thread.sleep(100);//time in miliseconds
  • } catch (Exception e) {
  • e.printStackTrace();
  • }
  • }
  • }
  • }
slide9

public class Threads01 {

  • //creates to simeRunnable threads and starts them
  • public static void main(String[] a) {
  • SimpleRunnable r1 = new SimpleRunnable("r1");
  • Thread t1 = new Thread(r1);
          • SimpleRunnable r2 = new SimpleRunnable("r2");
          • Thread t2 = new Thread(r2);
          • t1.start();
          • t2.start();
  • }
  • }

The order of start does not guarantee the order of execution.

runnable executor
Runnable Executor
  • Used to run threads that implemented Runnable
  • Decouples task creating and task running:
    • Class does not have to be ran right after creation
  • Creating the Executor:
      • ExecutorService e = Executors.newFixedThreadPool(<numberOfThreads>);
        • numberOfThreads: maximal number of threads running at same time.
  • Executing the thread:
    • e.execute(Runnable object);
  • Shutting down executor:
    • e.shutdown()
      • Causes the executor not to accept any new threads, and close all threads when all submitted tasks are done.
using executor threads01e java
Using Executor - Threads01e.java

class SimpleRunnable implements Runnable {

private intm_number;

public SimpleRunnable(inti) {

this.m_number = i;

}

/**

* Main lifecycle of the task.

* Prints the task ID 10 times.

*/

public void run() {

for (int i = 0; i < 10; i++) {

System.out.print(" " + m_number);

}

}

}

slide12

import java.util.concurrent.*;

public class Threads01e {

public static void main(String[] a) {

// Create an executor:

ExecutorService e = Executors.newFixedThreadPool(3);

// create 10 runnables, and execute them.

for(inti=0;i<10;i++) {

System.out.println("creating a new task: " + i + " ");

SimpleRunnable r = new SimpleRunnable(i);

e.execute(r);

}

e.shutdown();

}

}

extending java threads
Extending Java Threads
  • Java.lang.Thread
    • Allows maximal threading functionality
    • Less common than Runnable, however much more powerful.
    • Requires one method to be implemented:
      • public void run()
  • Implementation:

class <classname> extends Thread{

public void run(){

//thread “main” function

}

}

threads can be dangerous
Threads can be Dangerous
  • Having things run "at the same time, in the same place", can be dangerous.
  • The two tasks can interfere with each other, and unexpected results might occur.
example shared counter
Example – shared counter

public class Counter{

private intfCounter;

public Counter(){

fCounter = 0;

}

public void increment(){

fCounter++;

}

public intgetValue(){

return fCounter;

}

}

slide16

public class Incrementer implements Runnable {

Counter fCounter;

Incrementer(Counter ctr) {

fCounter = ctr;

}

/**

* Main lifecycle.

* increment the counter 200 times then dies.

*/

public void run() {

for (int i = 0; i<200; i++) {

fCounter.increment();

}

}

}

slide17

public class Threads03{

  • // Demonstrating problems with access to a shared resource.
  • public static void main(String[] a) {
  • for (inti=1;i<10;i++){
  • // create our shared object
  • Counter ctr = new Counter();
  • Thread t1 = new Thread(new Incrementer(ctr));
  • Thread t2 = new Thread(new Incrementer(ctr));
      • t1.start();
      • t2.start();
  • //wait until their job is done
      • while (t1.isAlive() || t2.isAlive()); //wait until all done.
      • //print out result of attempt i
      • System.out.println("Attempt " + i + ", total value: " + ctr.getValue());
      • }
  • }
  • }
  • }
shared resources and safety
Shared Resources and Safety
  • Safety problems arise when multiple threads access the same resource.
  • A shared resource is any object that is visible to severalthreads:
    • global (static) objects
    • non-primitive method parameters
    • class members.
    • Basically non-primitive variables.
slide19

class Foo {

public static double NUMBER = 33.3;

}

class ClassA {

public long i;

public Vector v;

public ClassA() { /* ... */ }

public void doSomething(long x, List lst) {

long localVar = 0;

Object o;

o = this.v.elementAt(2);

localVar += 2;

this.i += 2;

x += 2;

lst.elementAt(2);

Foo.NUMBER = 4;

localVar = Foo.NUMBER;

}

}

class TaskA implements Runnable {

//...

private ClassA a;

private List lst;

public long r;

public void run() {

this.r = 2;

this.a.doSomething(9, lst);

}

}

class Main {

public static void main(String[] args) {

// ....

ClassA o1 = new ClassA();

Thread t1 = new Thread(new TaskA(o1));

t1.start();

// ....

}

}

Not safe - Accessing a public member variable.

Not Safe - The private member variable (lst) is exposed to class A.

Not safe - Accessing a public

member variable.

Local variable - Safe

Not safe - Accessing a public member variable.

Primitive- Safe

Not Safe - Accessing a possible shared object (lst).

Not Safe (static - never safe!)

Not Safe (static - never safe!)

some solutions
Some Solutions
  • Thread-confined A thread-confined object is owned exclusively by and confined to one thread, and can be modified only by the thread that owns it.
  • Shared read-only A shared read-only object can be accessed concurrently by multiple threads, but cannot be modified by any thread. Shared read-only objects are immutable.
solution 1 thread confinement
Solution 1 - Thread Confinement
  • Problem is solved by not accessing the shared resources! By not having shared resources.
  • Called thread confinement:
    • threads access local resources only.
  • This way, no need to worry about thread safety since no thread can access any other thread’s variables.
example
Example

//NotThreadConfined

// e is not confined to this method - it is visible from the outside

public Car createCar(Engine e) {

List<Door> doors = new LinkedList<Door>();

doors.add(new FrontDoor());

doors.add(new FrontDoor());

doors.add(new BackDoor());

doors.add(new BackDoor());

Radio r = new AMFMRadio();

Car c = new Car(e, doors, r);

return c;

}

//ThreadConfined

public Car createCar() {

Engine e = new FuelEngine();

List<Door> doors = new LinkedList<Door>();

doors.add(new FrontDoor());

doors.add(new FrontDoor());

doors.add(new BackDoor());

doors.add(new BackDoor());

Radio r = new AMFMRadio();

Car c = new Car(e, doors, r);

return c;

}

solution 2 immutability
Solution 2 - Immutability
  • An immutable object cannot be changed after construction.
  • Solves thread safety problem by not allowing any variable modifications at all.
immutable class conditions
Immutable Class - conditions
  • All of its fields are final
  • The class is declared final (cannot be subclassed)
  • The this reference is not allowed to escape during construction. (the object is not fully constructed!)

For more info: http://www.ibm.com/developerworks/java/library/j-jtp0618/

  • Any fields that contain references to mutable objects, such as arrays, collections, or mutable classes like Date:
    • Are private
    • Are never returned or otherwise exposed to callers
    • Are the only reference to the objects that they reference
    • Do not change the state of the referenced objects after construction
slide25

/**

* The constructed class is immutable even-though it consists of mutable objects.

* The class is immutable due to its design, not just by using the final keyword.

* class ThreeStooges is declared to be final, which means that it cannot have subclasses. */

public final class ThreeStooges {

private final Set<String> stooges = new HashSet<String>();

public ThreeStooges() {

stooges.add("Moe");

stooges.add("Larry");

stooges.add("Curly");

}

public booleanisStooge(String name) {

return stooges.contains(name);

}

}

it won't change after construction, meaning it won't be assigned with another reference, but still the object stooges is mutable: its internal values may change