• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Java concurrency
 

Java concurrency

on

  • 682 views

The presentation intended to give a basic introduction for Concurrency in Java

The presentation intended to give a basic introduction for Concurrency in Java

Statistics

Views

Total Views
682
Views on SlideShare
682
Embed Views
0

Actions

Likes
0
Downloads
21
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Java concurrency Java concurrency Presentation Transcript

    • JavaConcurrencyBy: Hithem Aly
    • Agenda Objective Facts ThreadSafety Java Concurrency Problems (Symptoms) Java Concurrency methods
    • Objective Managing shared state
    • Objective Shared State Method Area
    • Is That Thread Safe?package com.thread;class ApplicationThread implements Runnable{ private int i = 0; @Override public void run() { System.out.println(++i); }}public class Main {public static void main(String[] args) { for (int i = 0; i < 1000; i++) { Thread thread1 = new Thread(new ApplicationThread()); thread1.start(); } }}
    • Is That Thread Safe?package com.thread;class ApplicationThread implements Runnable{ private int i = 0; @Override public void run() { System.out.println(++i); }}public class Main { public static void main(String[] args) { Runnable runnable = new ApplicationThread(); for (int i = 0; i < 100000; i++) { Thread thread1 = new Thread(runnable); thread1.start(); } }}
    • Agenda Objective Facts ThreadSafety Java Concurrency Problems (Symptoms) Java Concurrency methods
    • Facts Processors,cache, RAM interactions Compilers optimization (Instructions Re- ordering)
    • Processors, cache, RAM interactionsThread 1 Thread 2 P1 P2 R1 R2 C1 C2 text Stack Stack RAM Heap (code) 1 2 segment
    • Compilers optimization• Constant foldingEx:static final int length = 25;static final int width = 10;int res = length * width; //int res = 250;• Drop memory write for non volatile variables• Instructions Reordering• int A, B; • int A, B;• void foo() • void foo()• { A = B + 1; • {B = 0;• B = 0; } • A = B + 1; } For more Reference, Cglib (Code generation Library)
    • Illustrative Examplepublic class NoVisibility{ private static boolean ready; private static int number; private static class ReaderThread extends Thread { public void run() { while (!ready) Thread.yield(); System.out.println(number); } } public static void main(String[] args) { new ReaderThread().start(); number = 42; ready = true; }}
    • Solutionpublic class NoVisibility{ private static volatile boolean ready; private static volatile int number; private static class ReaderThread extends Thread { public void run() { while (!ready) Thread.yield(); System.out.println(number); } } public static void main(String[] args) { new ReaderThread().start(); number = 42; ready = true; }}
    • Agenda Objective Facts ThreadSafety Java Concurrency Problems (Symptoms) Java Concurrency methods
    • SingletonIs That Thread Safe?class Demo { private static Collaborator collaborator; public Collaborator getCollaborator() { if (collaborator == null) { collaborator = new Collaborator(); } return collaborator; }}
    • Thread Safety Atomicity synchronized Concurrency Visibility VolatileVolatile Patterns • One thread writes Other Threads reads • Checking Status flags • Independent Observations
    • Thread Safeclass Demo { private static Collaborator collaborator; public synchronized Collaborator getCollaborator(){ if (collaborator == null) { collaborator = new Collaborator(); } return collaborator; }}
    • Optimized Solutionclass Demo { private static volatile Collaborator collaborator; public Collaborator getCollaborator() { if (collaborator == null) {// double checked locking code synchronized(this) { if (collaborator == null) { collaborator = new Collaborator(); } } } return collaborator; }}
    • Even more Optimizedclass Demo { private static volatile Collaborator collaborator; public Collaborator getCollaborator() { Collaborator tmp = collaborator; if (tmp == null) { synchronized(this) { if (tmp == null) { tmp = new Collaborator(); collaborator = tmp; } } } return tmp; }}
    • Agenda Objective Facts ThreadSafety Java Concurrency Problems (Symptoms) Java Concurrency methods
    • Java Concurrency Problemsand Symptoms Invalid States  Stale values (old values, other threads values)  Null pointer exceptions  Array out of bound exceptions Symptom  Code works in Debugging while not working in the running mode or production mode  Working with JVM vendor while not working with other  Working with certain usage load and doesn’t work when the usage is increased (JIT Compiler)
    • Agenda Objective Facts ThreadSafety Java Concurrency Problems (Symptoms) Java Concurrency methods
    • Java Concurrency methods Thread Confinement Stack Confinement Immutable Visibility Atomicity
    • Thread confinement(Not to share) If data is only accessed from a single thread, no synchronization is needed. JDBC Connections , confines the connection for a single thread Implementation using ThreadLocal
    • Thread Confinementpublic class ConnectionDispenser {private static class ThreadLocalConnection extends ThreadLocal { public Object initialValue() { return DriverManager. getConnection(ConfigurationSingleton.getDbUrl()); } } private static ThreadLocalConnection conn = newThreadLocalConnection(); public static Connection getConnection() { return (Connection) conn.get(); }}
    • Stack Confinement Not to share  Object can only reached using local variables.  Widely used in our projectspublic class Income extends HttpServlet { @override protected void doPost(HttpServletRequest request, HttpServletResponse response) { try { IncomeForm income = Util.jsonToObject(input, IncomeForm.class);
    • Immutable Fieldsare Final , values are set only from the constructors, (this reference does not escaped) Immutable V effectively Immutable (Fields are not declared final, but there are not setters methods ) Volatile Reference to Immutable Objects
    • Illustrative example@Immutableclass OneValueCache { private final BigInteger lastNumber; private final BigInteger[] lastFactors; public OneValueCache(BigInteger i, BigInteger[] factors) { lastNumber = i; lastFactors = Arrays.copyOf(factors, factors.length); } public BigInteger[] getFactors(BigInteger i) { if (lastNumber == null !lastNumber.equals(i)) return null; else return Arrays.copyOf(lastFactors, lastFactors.length); }}
    • Using volatile to publishimmutable objects @ThreadSafe public class VolatileCachedFactorizer implements Servlet { private volatile OneValueCache cache = new OneValueCache(null, null); public void service(ServletRequest req, ServletResponse resp) { BigInteger i = extractFromRequest(req); BigInteger[] factors = cache.getFactors(i); //Tip !!! if (factors == null) { factors = factor(i); cache = new OneValueCache(i, factors); } encodeIntoResponse(resp, factors); } }
    • Volatilevolatile boolean shutdownRequested;...public void shutdown() {shutdownRequested = true; }public void doWork() { while (!shutdownRequested) { // do stuff }}
    • Synchronizedclass SynchronizedCounter { private int c = 0; public synchronized void increment() { c++; } public synchronized void decrement() { c--; } public synchronized int value() { return c; }}
    • Agenda Objective Facts ThreadSafety Java Concurrency Problems (Symptoms) Java Concurrency methods
    • References Java Concurrency in Practice https://www.student.cs.uwaterloo.ca/~cs 350/W11/notes/threads.pdf http://antrix.net/posts/2012/java-lazy- initialization/?c=1276