스레드와 동기화 1) 작동하지 않는 스레드에서 동기화 된 것을 사용하지 마십시오. (this)와 동기화하면 현재 스레드가 잠금 스레드 오브젝트로 사용됩니다. 각 스레드는 다른 스레드와 독립적이므로 동기화 조정이 없습니다. 2) 코드 테스트에 따르면 Mac의 Java 1.6에서는 메소드 동기화가 작동하지 않습니다. 3) synchronized (lockObj) 여기서 lockObj는 동기화하는 모든 스레드의 공통 공유 객체입니다. 4) ReenterantLock.lock () 및 .unlock ()이 작동합니다. 이에 대한 Java 학습서를 참조하십시오.
다음 코드는 이러한 점을 보여줍니다. 또한 ArrayList로 대체되는 스레드 안전 Vector가 포함되어있어 Vector에 추가하는 많은 스레드가 정보를 잃지 않고 ArrayList와 동일한 정보가 손실 될 수 있음을 보여줍니다. 0) 현재 코드는 경쟁 조건으로 인한 정보 손실을 표시합니다. A) 현재 레이블이있는 A 행을 주석 처리하고 그 위의 A 행을 주석 해제 한 다음 실행하면 메소드가 데이터를 유실하지만 그렇지 않아야합니다. B) A 단계를 취소하고 주석 처리를 제거하고 // 블록 종료}. 그런 다음 데이터 손실이없는 결과를 보려면 실행하십시오. C) 주석을 해제하십시오. C의 주석 처리를 제거하십시오. 모든 변형을 완료 할 시간이 없습니다. 이것이 도움이되기를 바랍니다. (this)에서 동기화하거나 메소드 동기화가 작동하는 경우 테스트 한 Java 및 OS 버전을 지정하십시오. 감사합니다.
import java.util.*;
/** RaceCondition - Shows that when multiple threads compete for resources
thread one may grab the resource expecting to update a particular
area but is removed from the CPU before finishing. Thread one still
points to that resource. Then thread two grabs that resource and
completes the update. Then thread one gets to complete the update,
which over writes thread two's work.
DEMO: 1) Run as is - see missing counts from race condition, Run severa times, values change
2) Uncomment "synchronized(countLock){ }" - see counts work
Synchronized creates a lock on that block of code, no other threads can
execute code within a block that another thread has a lock.
3) Comment ArrayList, unComment Vector - See no loss in collection
Vectors work like ArrayList, but Vectors are "Thread Safe"
May use this code as long as attribution to the author remains intact.
/mf
*/
public class RaceCondition {
private ArrayList<Integer> raceList = new ArrayList<Integer>(); // simple add(#)
// private Vector<Integer> raceList = new Vector<Integer>(); // simple add(#)
private String countLock="lock"; // Object use for locking the raceCount
private int raceCount = 0; // simple add 1 to this counter
private int MAX = 10000; // Do this 10,000 times
private int NUM_THREADS = 100; // Create 100 threads
public static void main(String [] args) {
new RaceCondition();
}
public RaceCondition() {
ArrayList<Thread> arT = new ArrayList<Thread>();
// Create thread objects, add them to an array list
for( int i=0; i<NUM_THREADS; i++){
Thread rt = new RaceThread( ); // i );
arT.add( rt );
}
// Start all object at once.
for( Thread rt : arT ){
rt.start();
}
// Wait for all threads to finish before we can print totals created by threads
for( int i=0; i<NUM_THREADS; i++){
try { arT.get(i).join(); }
catch( InterruptedException ie ) { System.out.println("Interrupted thread "+i); }
}
// All threads finished, print the summary information.
// (Try to print this informaiton without the join loop above)
System.out.printf("\nRace condition, should have %,d. Really have %,d in array, and count of %,d.\n",
MAX*NUM_THREADS, raceList.size(), raceCount );
System.out.printf("Array lost %,d. Count lost %,d\n",
MAX*NUM_THREADS-raceList.size(), MAX*NUM_THREADS-raceCount );
} // end RaceCondition constructor
class RaceThread extends Thread {
public void run() {
for ( int i=0; i<MAX; i++){
try {
update( i );
} // These catches show when one thread steps on another's values
catch( ArrayIndexOutOfBoundsException ai ){ System.out.print("A"); }
catch( OutOfMemoryError oome ) { System.out.print("O"); }
}
}
// so we don't lose counts, need to synchronize on some object, not primitive
// Created "countLock" to show how this can work.
// Comment out the synchronized and ending {, see that we lose counts.
// public synchronized void update(int i){ // use A
public void update(int i){ // remove this when adding A
// synchronized(countLock){ // or B
// synchronized(this){ // or C
raceCount = raceCount + 1;
raceList.add( i ); // use Vector
// } // end block for B or C
} // end update
} // end RaceThread inner class
} // end RaceCondition outter class