Java concurrency

803 views

Published on

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

Published in: Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
803
On SlideShare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
31
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Java concurrency

  1. 1. JavaConcurrencyBy: Hithem Aly
  2. 2. Agenda Objective Facts ThreadSafety Java Concurrency Problems (Symptoms) Java Concurrency methods
  3. 3. Objective Managing shared state
  4. 4. Objective Shared State Method Area
  5. 5. 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(); } }}
  6. 6. 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(); } }}
  7. 7. Agenda Objective Facts ThreadSafety Java Concurrency Problems (Symptoms) Java Concurrency methods
  8. 8. Facts Processors,cache, RAM interactions Compilers optimization (Instructions Re- ordering)
  9. 9. Processors, cache, RAM interactionsThread 1 Thread 2 P1 P2 R1 R2 C1 C2 text Stack Stack RAM Heap (code) 1 2 segment
  10. 10. 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)
  11. 11. 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; }}
  12. 12. 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; }}
  13. 13. Agenda Objective Facts ThreadSafety Java Concurrency Problems (Symptoms) Java Concurrency methods
  14. 14. SingletonIs That Thread Safe?class Demo { private static Collaborator collaborator; public Collaborator getCollaborator() { if (collaborator == null) { collaborator = new Collaborator(); } return collaborator; }}
  15. 15. Thread Safety Atomicity synchronized Concurrency Visibility VolatileVolatile Patterns • One thread writes Other Threads reads • Checking Status flags • Independent Observations
  16. 16. Thread Safeclass Demo { private static Collaborator collaborator; public synchronized Collaborator getCollaborator(){ if (collaborator == null) { collaborator = new Collaborator(); } return collaborator; }}
  17. 17. 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; }}
  18. 18. 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; }}
  19. 19. Agenda Objective Facts ThreadSafety Java Concurrency Problems (Symptoms) Java Concurrency methods
  20. 20. 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)
  21. 21. Agenda Objective Facts ThreadSafety Java Concurrency Problems (Symptoms) Java Concurrency methods
  22. 22. Java Concurrency methods Thread Confinement Stack Confinement Immutable Visibility Atomicity
  23. 23. 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
  24. 24. 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(); }}
  25. 25. 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);
  26. 26. 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
  27. 27. 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); }}
  28. 28. 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); } }
  29. 29. Volatilevolatile boolean shutdownRequested;...public void shutdown() {shutdownRequested = true; }public void doWork() { while (!shutdownRequested) { // do stuff }}
  30. 30. Synchronizedclass SynchronizedCounter { private int c = 0; public synchronized void increment() { c++; } public synchronized void decrement() { c--; } public synchronized int value() { return c; }}
  31. 31. Agenda Objective Facts ThreadSafety Java Concurrency Problems (Symptoms) Java Concurrency methods
  32. 32. 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

×