写一个简单的程序，测试LinkedList是否线程安全。

1. public class User implements Cloneable{
   
2.         private String name;
   
3.         private int age;
   
4.        
   
5.         public User(String name, int age) {
   
6.                 this.name = name;
   
7.                 this.age = age;
   
8.         }
   
9.         public boolean equals(Object obj) {
   
10.                 if(this == obj) {
    
11.                         return true;
    
12.                 }
    
13.                 if(!(obj instanceof User)) {
    
14.                         return false;       
    
15.                 }
    
16.                 User user = (User)obj;
    
17.                 //if(this.name==user.name && this.age==user.age)
    
18.                 if(this.name.equals(user.name)
    
19.                         && this.age==user.age) {
    
20.                         return true;
    
21.                 }
    
22.                 else {
    
23.                         return false;
    
24.                 }
    
25.         }
    
26.         public int hashCode() {
    
27.                 return name.hashCode() + age;
    
28.         }
    
29.        
    
30.         public String toString() {
    
31.                 return "{name:'" + name + "',age:" + age + "}";
    
32.         }
    
33.         public Object clone()  {
    
34.                 Object object = null;
    
35.                 try {
    
36.                         object = super.clone();
    
37.                 } catch (CloneNotSupportedException e) {}
    
38.                 return object;
    
39.         }
    
40.         public void setAge(int age) {
    
41.                 this.age = age;
    
42.         }
    
43.         public String getName() {
    
44.                 return name;
    
45.         }
    
46. }
    
47. 
    
48. 
    
49. import java.util.ArrayList;
    
50. import java.util.Collection;
    
51. import java.util.Iterator;
    
52. import java.util.concurrent.CopyOnWriteArrayList;
    
53. public class CollectionModifyExceptionTest {
    
54.         /** 迭代集合时不能对集合进行修改
    
55.          * @param args
    
56.          */
    
57.         public static void main(String[] args) {
    
58.                 Collection users = new LinkedList();//集合并发同步操作。
    
59.                 //
    
60.                 //new ArrayList();
    
61.         users.add(new User("张三",28));       
    
62.         users.add(new User("李四",25));                       
    
63.         users.add(new User("王五",31));       
    
64.         Iterator itrUsers = users.iterator();
    
65.         while(itrUsers.hasNext()){
    
66.                 System.out.println("aaaa");
    
67.                 User user = (User)itrUsers.next();
    
68.                 if("王五".equals(user.getName())){
    
69.                         users.remove(user);
    
70.                         //itrUsers.remove();
    
71.                 } else {
    
72.                         System.out.println(user);                               
    
73.                 }
    
74.                 }
    
75.         }
    
76. 
    
77. }
    

复制代码

如果真能写出这样一个程序，那难道要把你所有调用同一个LinkedList对象的代码块传进去分析吗

这个问题是哪里来的，个人认为，线程安不安全是需要自己控制的，如果你想让LinkedList同步，可以自己加锁，也可以通过List list = Collections.synchronizedList(new LinkedList(...));

说下我的思路：
要测试线程安全，可以极端一点，新建多个线程，其中注意加上提示信息，然后对你的linkedList进行数据的操作，然后运行几次看看是否有数据存取的异常显示。

这个问题在老毕的视频中专门有讲过，就在多线程的安全问题那里。

package Test;

import java.util.LinkedList;
import java.util.List;

//写一个简单的程序，测试LinkedList是否线程安全。
public class Test1 {

        public static void main(String[] args) {
                // TODO Auto-generated method stub
                LinkedList linkList = new LinkedList();
                new Thread(new runLinkList(linkList)).start();
                new Thread(new runLinkList(linkList)).start();
        }

}

class runLinkList implements Runnable{
        private LinkedList linklist;
        boolean flag;
        int count;
        public runLinkList(LinkedList linklist) {
                // TODO Auto-generated constructor stub
                this.linklist=linklist;
        }
        @Override
        public void run() {
                // TODO Auto-generated method stub
                while(true){
                        if(flag){
                               
                                linklist.add("abc");
                                //这里给你分析下，线程0到这里停，线程1到这里也停，这时线程0醒了继续执行，执行一圈回来停了，这时集合中只有一个
//                                “abc”字符串，线程1醒了接着执行，输出集合中的内容然后删除集合中的字符串，现在集合为空，线程1又停了，线程0醒了输出集合
//                                再删除的时候集合中就什么都没了删除不成功。说明线程是不安全的，需要加锁，说明线程是不同步的。
                                try {
                                        Thread.sleep(10);
                                } catch (InterruptedException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
                                System.out.println(Thread.currentThread().getName()+"..."+linklist+"....."+count++);
                                flag=false;
                                                       
                        }
                        if(!flag){
                                linklist.remove("abc");
                                System.out.println(Thread.currentThread().getName()+"..."+linklist+"::"+count++);
                                flag=true;
                               
                        }
                }
        }
}