スレッドと同期しています。1）機能しないスレッドでsynchronized（this）を使用しないでください。（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を逆にして、Bのコメントを外し、//ブロックを終了します}。次に、データを失うことなく結果を確認するために実行します。C）コメントアウトB、コメントを外します。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