Java multi-threaded Development seven--thread-safe data structure __arcinfo

volatile VariableThe volatile variable indicates that it must be consistent with the main memory, which is actually a "synchronization of the variables", meaning that the operation of the volatile variable is atomic, such as before a long or double variable. Variables in the Java language are saved in main memory and can be used for communication between multithreading, and each thread has its own working memory. Volatile is used to ensure that this variable is synchronized between the main memory and the working memory of the thread.       public class sample{int i;       volatile Int J; ......... } In the example above, when one thread changes the value of I, the value of I that is read by another thread may not be the changed value, because the value that the thread has changed in working memory may not have been synchronized to the main memory. This problem does not exist on the variable J, because volatile guarantees the synchronization of J from the working memory of the thread to the main memory. JDK1.5 provides data structure after a bunch of atomic variables, a variety of thread-safe List, Queue, MAP, etc., not one description, you can see the JDK documentation. Demonstrate it with a producer/consumer model. public class Blockqueuesample ... {
Blockingqueue < string > resource = new Linkedblockingqueue < string > (10);
Atomicinteger i = new Atomicinteger ();
Boolean exit = FALSE;

Public Blockqueuesample () ... {
Thread consumer = new Thread (new consumer ());
Thread producer = new Thread (new producer ());
Consumer.start ();
Producer.start ();
}

public void exit () ... {
this. Exit = true;
}

public static void Main (string[] args) ... {
Blockqueuesample sample = new Blockqueuesample ();
Try ... {
Thread.CurrentThread (). Sleep (2000);
catch (Interruptedexception e) ... {
return;
}
Sample.exit ();
}

public class Consumer implements Runnable ... {

public void run () ... {
while (! Exit) ... {
Try ... {
System.out.println ("Consumer Take:" + resource.take ());
catch (Interruptedexception e) ... {
return;
}
}

}

}

public class Producer implements Runnable ... {

public void run () ... {
while (! Exit) ... {
String r = "Resource" + i.getandincrement ();
System.out.println ("Producer put:" + R);
Try ... {
Resource.put (R);
catch (Interruptedexception e) ... {
return;
}

}