Arraylist,vector Thread Safety Testing

Conclusion: If the collection is not thread-safe, the data loss problem occurs when inserting data in multithreaded situations. Java code

2. Import java.util.ArrayList;
4. Import java.util.List;
8. Threads that implement the Runnable interface
10. Public class Hellothread implements Runnable {
12. String name;
14. List<string> v;
18. Hellothread (String name, list<string> v) {
20. this.name = name;
22. this.v = v;
24. }
28. public Void Run () {
30. SYSTEM.OUT.PRINTLN (name + "Start");
32. While (true) {
34. V.add (name + ". Add");
36. SYSTEM.OUT.PRINTLN (name + "List size is" + v.size ());
40. try {
42. Thread.Sleep (10);
44. } catch (Interruptedexception e) {
46. System.out.println (E.getmessage ());
48. }
50. }
52. }
56. public static void Main (String args[]) throws interruptedexception {
60. List<string> v = new arraylist<string> ();
64. Hellothread hello1 = new Hellothread ("Hello1", V);
66. Hellothread Hello2 = new Hellothread ("Hello2", V);
68. Hellothread Hello3 = new Hellothread ("Hello3", V);
72. Thread H1 = new Thread (HELLO1);
74. Thread H2 = new Thread (HELLO2);
76. Thread h3 = new Thread (HELLO3);
78. H1.start ();
80. H2.start ();
82. H3.start ();
86. }
88. }

Results:

Hello3start
Hello3 list size is 1
Hello1start
Hello1 List size is 2
Hello2start
Hello2 List size is 3
Hello3 List size is 4
Hello1 List size is 5
Hello2 List size is 4
Hello3 List size is 6
Hello1 List size is 8
Hello2 List size is 7
Hello1 List size is 9
Hello3 List size is 10
Hello2 List size is 9

Added 12 times, but size was only 10, not safe.

Changed to a thread-safe vector:

Java code

2. Import Java.util.Vector;
6. Threads that implement the Runnable interface
8. Public class Hellothread implements Runnable {
10. String name;
12. Vector<string> v;
16. Hellothread (String name, vector<string> v) {
18. this.name = name;
20. this.v = v;
22. }
26. public Void Run () {
28. SYSTEM.OUT.PRINTLN (name + "Start");
30. While (true) {
32. V.add (name + ". Add");
34. SYSTEM.OUT.PRINTLN (name + "vector size is" + v.size ());
38. try {
40. Thread.Sleep (10);
42. } catch (Interruptedexception e) {
44. System.out.println (E.getmessage ());
46. }
48. }
50. }
54. public static void Main (String args[]) throws interruptedexception {
58. Vector<string> v = new vector<string> ();
62. Hellothread hello1 = new Hellothread ("Hello1", V);
64. Hellothread Hello2 = new Hellothread ("Hello2", V);
66. Hellothread Hello3 = new Hellothread ("Hello3", V);
70. Thread H1 = new Thread (HELLO1);
72. Thread H2 = new Thread (HELLO2);
74. Thread h3 = new Thread (HELLO3);
76. H1.start ();
78. H2.start ();
80. H3.start ();
82. }
84. }

Results:

Hello1start
Hello1 Vector size is 1
Hello2start
Hello2 Vector size is 2
Hello3start
Hello3 Vector size is 3
Hello1 Vector size is 4
Hello2 Vector size is 5
Hello3 Vector size is 6
Hello1 Vector size is 7
Hello2 Vector size is 8
Hello3 Vector size is 9
Hello1 Vector size is 10
Hello2 Vector size is 11
Hello3 Vector size is 12
Hello1 Vector size is 13
Hello3 Vector size is 15
Hello2 Vector size is 15
Hello1 Vector size is 16

Is there a thread-unsafe phenomenon? No

This is not a thread unsafe, add 16 times, size is 16, is exactly the performance of thread safety, but is to wait two threads are added after the size (), so are 15, skipped 14.

The same program more than a few times to appear, and the other about the vector thread-safety

All Vector methods is synchronized themselves, so as long as your is only synchronizing around a single method, your own Synchronization is not necessary. If you had several method calls, which depend on each other, e.g. something as to vec.get(vec.size()-2) get the second last element, yo U has to use your own synchronization since otherwise, the vector could change between vec.size () and Vec.get ().

All vector methods are synchronized to themselves, so if you just sync a single method, your extra sync measures will be lost. If several methods need to be called, and they are dependent on each other, such as Vec.get (Vec.size ()-2), is to get the second-to-last element, then must add their own synchronization measures, because otherwise, vectors may be in vec.size () and Vec.get () Change between

Arraylist,vector Thread Safety Testing