jdk 1.5 全新的並行機制
Post on 18-Sep-2015
36 Views
Preview:
DESCRIPTION
TRANSCRIPT
-
JDK 1.5 / William Yehpjyeh@cis.nctu.edu.tw2004.08.03.http://william.cswiz.org/present/20040803-javatwo
2004 Java2 *.
Java Concurrency Facilitiesjava.langKeyword: synchronized
2004 Java2 *.
Concurrent Programming
2004 Java2 *.
Java Concurrent Programming 310 pagesScott Oaks, Henry Wong, Java Threads, 2nd edition, OReilly, 1999.344 pagesJeff Magee, Jeff Kramer, Concurrency: State Models & Java Programs, John Wiley & Sons, 1999.292 pagesAllen Holub, Taming Java Threads, Apress, 2000.376 pagesDoug Lea, Concurrent Programming in Java: Design Principles and Patterns, 2nd edition, Addison-Wesley, 1999.309 pagesVijay K. Garg, Concurrent and Distributed Computing in Java, John Wiley & Sons, 2004.
2004 Java2 *.
Whats Special in util.concurrent?Creator of util.concurrent: Doug Lea says:Whenever youre about to usenew Thread();synchronizedObject.wait, Object.notify, Object.notifyAllCheck first if theres a class thatAutomates your tasksSimplifies your building blocks
2004 Java2 *.
History of util.concurrent1997Concurrent Programming in Java, 1st edition
1998Package EDU.oswego.cs.dl.util.concurrent
1999Concurrent Programming in Java, 2nd edition
2002JSR-166
2004JDK 1.5 (5.0)
2004 Java2 *.
OutlineBefore JDK1.5ThreadRace conditionSynchronizationSince JDK 1.5Better executorFlexible lockRicher IPC facilitiesOther stuff
2004 Java2 *.
@ 2004.08.03.SchedulingLockBounded buffer problemFIFO (first in first out)LIFO (last in first out)
-
1A. ThreadBasics*The world before JDK 1.5
2004 Java2 *.
Concurrent Programskernel
2004 Java2 *.
Java Threads, 1st Wayjava.langnmain
2004 Java2 *.
Thread Demo #1public class MyThread1 extends Thread {
public void run() {for (int x = 0; x < 20; ++x)System.out.println(x);}
public static void main(String[] args) {Thread[] worker = new Thread[5];for (int i = 0; i < 5; i++) worker[i] = new MyThread1();
for (int i = 0; i < 5; i++) worker[i].start();}}MyThread1Threadmain5
2004 Java2 *.
01234567 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 38 4 4 49 5 5 510 6 6 611 7 7 712 8 8 8 4 5 6 7 9 9 913 10 10 1014 11 11 1115 12 12 1216 817 9 10 11 12 13 14 15 16 17 1818 13 13 1319 14 14 14 15 15 15 16 16 16 17 17 17 19 18 19 18 19 18 19
2004 Java2 *.
Lessons Learned: UncertaintyTime sliceWhere? In general, unknown.
SchedulingWhen? In general, unknown.To Whom? In general, unknown.
2004 Java2 *.
Java Threads, 2nd WayThreadmain
2004 Java2 *.
Thread Demo #2public class MyThread2 implements Runnable {
public void run() {//}
public static void main(String[] args) {Thread[] worker = new Thread[5];for (int i = 0; i < 5; i++) worker[i] =new Thread( );
for (int i = 0; i < 5; i++) worker[i].start();}}Threadmain interface Runnablenew MyThread2()
-
1B. Executor*Whats new in JDK 1.5
2004 Java2 *.
Limitations of Java ThreadsNumber of threadsSpecified explicitlyHard to be adjusted dynamically
Execution modelsInflexible
2004 Java2 *.
MyWorkermain
2004 Java2 *.
Thread public class ThreadDemo extends Thread {private int sn;public ThreadDemo(int sn) { this.sn = sn; }
public void run() {// delay for a while...System.out.println(sn);}
public static void main(String[] args) {int i = 0;for (;;) {new ThreadDemo(i).start();++i;}}}
2004 Java2 *.
Executor Demopublic class ExecutorDemo implements Runnable {private int sn;public ExecutorDemo(int sn) { this.sn = sn; }public void run() { /* */ }
public static void main(String[] args) {Executor pool =Executors.newFixedThreadPool(300);// Executors.newCachedThreadPool();// Executors.newSingleThreadExecutor();
int i = 0;for (;;) {pool.execute( new ExecutorDemo(i) );++i;}}}
2004 Java2 *.
Whats Special? Seeing is Believing!
2004 Java2 *.
Asynchronous ExecutionMyWorker
-
2A. Race Conditionmutual execution*The world before JDK 1.5
2004 Java2 *.
Race Condition ()http://www.garfield.com/comics/comics_archives_strip.html?2004-ga040201
2004 Java2 *.
Race Condition Demopublic class Race1 extends Thread {
// shared variableprivate static int x = 0; // counter
public void run() {while (true) {
System.out.println( x );++x;
}}
public static void main(String[] args) { /**/ }}
2004 Java2 *.
012...439440441 442 443 444 . . 1037 1038 1039 1040 . . 1807 1808 1809 1810 1810 1810 1810 18101810 1039 1811 1812 1813 18141815 1816 1817 1818 1819 1820
2004 Java2 *.
Java Memory ModelWorking memoryEvery thread has a working memory in which it keeps its own working copy of variables that it must use or assign.As the thread executes a program, it operates on these working copies.
Master copyThe main memory contains the master copy of every variable.
Transfer: working master copyThere are rules about when a thread is permitted or required to transfer the contents of its working copy of a variable into the master copy or vice versa.The Java Virtual Machine Specification, 2nd EditionJSR-133
2004 Java2 *.
Read/Write Details// shared variableprivate static int x = 0;
System.out.println( x );
++x;Read( x )Write( x )
2004 Java2 *.
Why Race Condition?1809 Read( x )1810 Write( x )1810 Read( x )1811 Write( x )1810 Read( x )1810 Read( x )1811 Write( x )1811 Read( x )
2004 Java2 *.
Solution: Exclusive Executionpublic class Race2 extends Thread {
private static int x = 0;private static Object x_lock = new Object();
public void run() {while (true) {synchronized ( x_lock ) {System.out.println( x );++x;}}}
public static void main(String[] args) { /**/ }}
-
2B. Lock*Whats new in JDK 1.5
2004 Java2 *.
3 Ways to Use synchronizedprivate static int x = 0;
public synchronized void f() {while (true) {++x; //}}
public void g() {synchronized ( this ) {while (true) {++x; //}}}public void h() {while (true) {synchronized ( this ) {++x; //}}}123
2004 Java2 *.
JSR 166: Lock[1/2]private static int x = 0;
public void g() {synchronized ( this ) {while (true) {++x; //}}}import java.util.concurrent.locks.*;
private static Lock lock= new ReentrantLock();
public void g2() {lock.lock();try {while (true) {++x; //}} finally {lock.unlock();}}24
2004 Java2 *.
JSR 166: Lock[2/2]private static int x = 0;
public void h() {while (true) {synchronized (this) {++x; //}}}import java.util.concurrent.locks.*;
private static Lock lock= new ReentrantLock();
public void h2() {while (true) {lock.lock();try {++x; //} finally {lock.unlock();}}}35
2004 Java2 *.
Simple Benchmarkfor (int i = 0; i < 20; ++i) {x = 0;long start = System.nanoTime();f(); // g(), h(), g2(), h2()long period = System.nanoTime() - start;System.out.println("f(): " + period);}
private synchronized void f() { // g(), h(), g2(), h2()while (true) {++x;if (x >= Integer.MAX_VALUE / 50) return;} // while}
2004 Java2 *.
2004 Java2 *.
2004 Java2 *.
interface LockReentrantLockReentrantReadWriteLockjava.util.concurrent.locks
-
3A. Synchronizationordered execution*The world before JDK 1.5
2004 Java2 *.
Synchronization between ThreadsBounded buffer problemAlso known as producer-consumer problemFIFO queueboundary condition
2004 Java2 *.
Nave Solution: put()class BoundedBuffer {private String[] buf;private int in = -1, out = -1;private int count = 0;
public BoundedBuffer(int size) { buf = new String[size]; }
public void put(String s) {while (count >= buf.length); // full
synchronized (this) {++count;buf[++in % buf.length] = s;System.out.println("--> " + s);}}
2004 Java2 *.
Nave Solution: get()
public String get() {
while (count == 0); // empty
synchronized (this) {--count;String s = buf[++out % buf.length];System.out.println(" " + s);
notify();}
2004 Java2 *.
Right Solution: get()
public synchronized String get() {
while (count == 0)try{ wait(); } catch(InterruptedException e) { }
--count;String s = buf[++out % buf.length];System.out.println("
-
3B. IPC Facilities*Whats new in JDK 1.5
2004 Java2 *.
Java monitor isnt pure MONITORDifference: condition variable!Java: only one (usually unnamed and hidden) condition variable per monitornotify(): wakeup one candidate (usually miss the true target) notifyAll(): wakeup all candidates (usually too coarse-grained)
Pure monitor: n named condition variablesFiner-grained and true wakeup candidates
2004 Java2 *.
100% Monitor Solution:put()class BoundedBuffer {Lock lock = new ReentrantLock(); // mutual exclusion
Condition notFull = lock.newCondition();Condition notEmpty = lock.newCondition();
public void put(String s) {lock.lock();try {while (count >= buf.length) notFull.await();catch (InterruptedException e) {}// buffer manipulationnotEmpty.signal();} finally { lock.unlock(); }}try { }
2004 Java2 *.
100% Monitor Solution:get()// Condition notFull = lock.newCondition();// Condition notEmpty = lock.newCondition();
public String get() {lock.lock();try {while (count == 0) notEmpty.await();catch (InterruptedException e) {}// buffer manipulation
notFull.signal();return s;} finally { lock.unlock(); }}try { }
2004 Java2 *.
Other IPC FacilitiesSemaphoreCyclicBarrierExchangerCountDownLatch
-
4. Misc*Whats new in JDK 1.5
2004 Java2 *.
Topics not Covered in this TalkConcurrent containersjava.util.concurrentArrayBlockingQueueConcurrentHashMapCopyOnWriteArrayList
Atomic scalarsjava.util.concurrent.atomicAtomicLongAtomicIntegerArray
2004 Java2 *.
Recommended ReadingsJSR 166Concurrency JSR-166 Interest Sitehttp://gee.cs.oswego.edu/dl/concurrency-interest/Rationale behind JSR-166Doug Lea, Concurrent Programming in Java--Design Principles and Patterns, 2nd edition, Addison-Wesley, 1999.Concurrent programming conceptsAbraham Silberschatz et. al, Operating System Concepts, 6th edition, John Wiely & Sons, 2003.Andrew S. Tanenbaum, Modern Operating Systems, 2nd edition, Prentice Hall, 2001.http://william.cswiz.org/present/20040803-javatwo
2004 Java2 *.
JDK 1.5 Doug Lea wait/notify/notifyAllsynchronizedThread java.util.concurrent
1998 1.0 JSR 166 JDK 1.5
Java
*
*
44 / 562 = 7.83%Ken Arnold, James Gosling, David Holmes, The Java Programming Language, 3rd edition, Addison-Wesley, 2000.Chapter 10.
51 / 534 = 9.55%Mary Campione, Kathy Walrath, Alison Huml, The Java Tutorial, 3rd edition, Addison-Wesley, 2000.Chapter 8, Appendix D.
78 / 1090 = 7.16%Bruce Eckel, Thinking in Java, 3rd edition, Prentice Hall, 2002.Chapter 14.
46 / 244 = 18.85%Peter Haggar, Practical Java Programming Language Guide, Addison-Wesley, 2000.Praxis 34, 46 58.
24 / 232 = 10.34%Joshua Bloch, Effective Java Programming Language Guide, Addison-Wesley, 2001.Item 48 53.
137 / 867 = 15.80%
Abraham Silberschatz et. al, Operating System Concepts, 6th edition, John Wiely & Sons, 2003.Chapters 4, 5, 7, 8.
153 / 934 = 16.38%Andrew S. Tanenbaum, Modern Operating Systems, 2nd edition, Prentice Hall, 2001.Chapters 2, 3, 10, 11.
top related