百度了也很多，可能感觉是我基础不好的问题？ 越看 越晕，越不清楚。 说能简单的说下？

其实有时候没必要搞的那么清楚  只要是知道干什么的就行了

集合作为被多线程访问的数据集合，提供对外的方法供不同的线程的调用，
关键不是集合的同步的问题，主要还是多线程的同步问题。
以经典的生产者消费者这个为样板理解：

1. public class WaitNotifyDemo {
   
2.                                         public static void main(String[] args) {
   
3.                                                 Resource res = new Resource("商品");
   
4.                                                 Producer pro = new Producer(res);
   
5.                                                 Customer cus = new Customer(res);
   
6.                                                 new Thread(pro).start();
   
7.                                                 new Thread(cus).start();
   
8.                                                 new Thread(pro).start();
   
9.                                                 new Thread(cus).start();
   
10.                                         }
    
11.                                 }
    
12.                                 class Producer implements Runnable {
    
13.                                         private Resource res;
    
14.                                         Producer(Resource res) {
    
15.                                                 this.res = res;
    
16.                                         }
    
17.                                         @Override
    
18.                                         public void run() {
    
19.                                                 while (true) {
    
20.                                                         res.setRes();
    
21.                                                 }
    
22.                                         }
    
23.                                 }
    
24.                                 class Customer implements Runnable {
    
25.                                         private Resource res;
    
26.                                         Customer(Resource res) {
    
27.                                                 this.res = res;
    
28.                                         }
    
29.                                         @Override
    
30.                                         public void run() {
    
31.                                                 while (true) {
    
32.                                                         res.getRes();
    
33.                                                 }
    
34.                                         }
    
35.                                 }
    
36.                                 class Resource {
    
37.                                         private String name;
    
38.                                         private int count;
    
39.                                         private boolean flag; // flag表示是否存在资源
    
40.                                         Resource(String name) {
    
41.                                                 this.name = name;
    
42.                                                 count = 0;
    
43.                                                 flag = false;
    
44.                                         }
    
45.                                         public void setFlag(boolean flag) {
    
46.                                                 this.flag = flag;
    
47.                                         }
    
48.                                         public synchronized void setRes() {
    
49.                                                         while(this.flag) {                //注意要使用while而不是使用if来控制判断，当线程从wait状态醒来需要重新判断flag
    
50.                                                                 try {
    
51.                                                                         wait();
    
52.                                                                 } catch (InterruptedException e) {
    
53.                                                                         e.printStackTrace();
    
54.                                                                 }
    
55.                                                         }
    
56.                                                         System.out.println("生产者---------" + Thread.currentThread().getName()
    
57.                                                                         + this.name + " " + (++count));
    
58.                                                         setFlag(true);
    
59.                                                         notifyAll();
    
60.                                         }
    
61.                                         public synchronized void getRes() {
    
62.                                                         while (!this.flag) {
    
63.                                                                 try {
    
64.                                                                         wait();
    
65.                                                                 } catch (InterruptedException e) {
    
66.                                                                         e.printStackTrace();
    
67.                                                                 }
    
68.                                                         }
    
69.                                                         System.out.println("消费者" + Thread.currentThread().getName()
    
70.                                                                         + this.name + " " + count);
    
71.                                                         setFlag(false);
    
72.                                                         notifyAll();
    
73.                                         }
    
74.                                 }

复制代码

那么集合可以看作是这里面的Resource 类了 ，
不知道我的看法是不是正确，一起学习

李金中 发表于 2014-2-21 16:18
我对同步的理解是，如果多线程去访问同一个集合数据，是不会出错的。
访问包括读和写。。这就是同步吧。
...

哇， 好流弊，怎么一下38分了

看看这个帖子，更加具体的解释了所谓的同步
http://www.iteye.com/problems/61403

我对同步的理解是，如果多线程去访问同一个集合数据，是不会出错的。
访问包括读和写。。这就是同步吧。