Java集合中那些类是线程安全的以及 Map线程安全几种实现方法

来源：互联网发布：java微信开发教程 pdf 编辑：程序博客网时间：2024/05/21 11:36

线程安全类

在集合框架中，有些类是线程安全的，这些都是jdk1.1中的出现的。在jdk1.2之后，就出现许许多多非线程安全的类。下面是这些线程安全的同步的类：

vector：就比arraylist多了个同步化机制（线程安全），因为效率较低，现在已经不太建议使用。在web应用中，特别是前台页面，往往效率（页面响应速度）是优先考虑的。

statck：堆栈类，先进后出

hashtable：就比hashmap多了个线程安全

enumeration：枚举，相当于迭代器

除了这些之外，其他的都是非线程安全的类和接口。

线程安全的类其方法是同步的，每次只能一个访问。是重量级对象，效率较低。

其他：

1. hashtable跟hashmap的区别

hashtable是线程安全的,即hashtable的方法都提供了同步机制；hashmap不是线程安全的,即不提供同步机制；hashtable不允许插入空值,hashmap允许!

2. 多线程并发修改一个集合怎么办

用老的Vector/Hashtable类

StringBuffer是线程安全，而StringBuilder是线程不安全的。对于安全与不安全没有深入的理解情况下，易造成这样的错觉，如果对于StringBuffer的操作均是线程安全的，然而，Java给你的保证的线程安全，是说它的方法是执行是排它的，而不是对这个对象本身的多次调用情况下，还是安全的。看看下边的例子，在StringBufferTest中有一个数据成员contents它是用来扩展的，它的每一次append是线程安全的，但众多次append的组合并不是线程安全的，这个输出结果不是太可控的，但如果对于log和getContest方法加关键字synchronized，那么结果就会变得非常条理，如果换成StringBuider甚至是append到一半，它也会让位于其它在此基础上操作的线程：

public class StringBufferTest {
   private StringBuffer contents = new StringBuffer();
   public void log(String message){
      contents.append(System.currentTimeMillis());
      contents.append("; ");
      contents.append(Thread.currentThread().getName());
      for(int i=0;i<10000;i++){
        contents.append(i);
          contents.append(message);    //append本身是线程安全的，修改contents时，其它线程无法访问。
          contents.append("\n");
      }
      contents.append("\n\n");
   }
   public void getContents(){
      System.out.println(contents);
   }
}

class RunThread extends Thread{
   String message;
   StringBufferTest buffer;
   public RunThread(StringBufferTest buffer, String message){
      this.buffer = buffer;
      this.message = message;
   }
   public void run(){
      while(true){
         buffer.log(message);
         buffer.getContents();
      }
   }
   public static void main(String[] args) {
      StringBufferTest ss = new StringBufferTest();
      new RunThread(ss, "you").start();
      new RunThread(ss, "me").start();
      new RunThread(ss, "she").start();
   }
}
        StringBuilder和StringBuffer的方法是一模一样，就是一个多线程和一个单线程的问题。线程调用同一StringBuffer 的append方法，这跟他是不是线程安全没有关系的，除非你的结果是append的一系列字符串变乱了，那才能说明他是线程不安全的。线程安全是指任何时刻都只有一个线程访问临界资源。线程安全并不是说他的一系列操作是同步的只是对于他执行某个方法的时候不允许别的线程去改变。针对一个类来说是不是线程安全就要看，多个线程在同时在运行，这些线程可能会同时执行某个方法。但是每次运行结果和单线程执行的结果一样，那么就可以说是线程安全的。因为log方法没有上锁，每个现在在append锁释放后，都可能得到cpu的执行片段。

但不要对多线程安全存在误解：

   public String toString(){
      StringBuffer buffer = new StringBuffer();
      buffer.append('<');
      buffer.append(this.name);
      buffer.append('>');
      return buffer.toString();
   }

这个代码是完全线程安全的，在方法内部定义的变量，在每个线程线程进入的时候都会创建这个局部变量！不涉及线程安全问题。通常涉及系统安全的变量一般都是成员变量! stringBuffer本身的内部实现是现场安全的！线程安全那是类本身提供的功能是安全的。即你提供插入一个字符串，那么这个字符串插入是安全的，但是要插入两个字符串，两个的顺序你来定，这之间如果有别的插入出错就不管类的事情了，是你自己代码的问题。

Map线程安全几种实现方法

如果需要使 Map 线程安全，大致有这么四种方法：
1、使用 synchronized 关键字，代码如下
synchronized(anObject) {
　　value = map.get(key);
}

2、使用 JDK1.5提供的锁（java.util.concurrent.locks.Lock）。代码如下
lock.lock();
value = map.get(key);
lock.unlock();

3、使用 JDK1.5 提供的读写锁（java.util.concurrent.locks.ReadWriteLock）。代码如下
rwlock.readLock().lock();
value = map.get(key);
rwlock.readLock().unlock();
这样两个读操作可以同时进行，理论上效率会比方法 2 高。

4、使用 JDK1.5 提供的 java.util.concurrent.ConcurrentHashMap 类。该类将 Map 的存储空间分为若干块，每块拥有自己的锁，大大减少了多个线程争夺同一个锁的情况。代码如下
value = map.get(key); //同步机制内置在 get 方法中

5、使用Collections.synchronizedMap

比较：
1、不同步确实最快，与预期一致。
2、四种同步方式中，ConcurrentHashMap 是最快的，接近不同步的情况。
3、synchronized 关键字非常慢，比使用锁慢了两个数量级。如果需自己实现同步，则使用 JDK1.5 提供的锁机制，避免使用 synchronized 关键字。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
public class MapTest {
            public static final int THREAD_COUNT = 1;
            public static final int MAP_SIZE = 1000;
            public static final int EXECUTION_MILLES = 1000;
            public static final int[] KEYS = new int[100];
 
            public static void main(String[] args) throws Exception {
                // 初始化
                Random rand = new Random();
                for (int i = 0; i < KEYS.length; ++i)
                    KEYS[i] = rand.nextInt();
                // 创建线程
                long start = System.currentTimeMillis();
                Thread[] threads = new Thread[THREAD_COUNT];
                for (int i = 0; i < THREAD_COUNT; ++i) {
                    threads[i] = new SynchronizedThread();
                    // threads[i] = new LockThread();
                    threads[i].start();
                }
                // 等待其它线程执行若干时间
                Thread.sleep(EXECUTION_MILLES);
                // 统计 get 操作的次数
                long sum = 0;
                for (int i = 0; i < THREAD_COUNT; ++i) {
                    sum += threads[i].getClass().getDeclaredField("count")
                            .getLong(threads[i]);
                }
                long millisCost = System.currentTimeMillis() - start;
                System.out.println(sum + "(" + (millisCost) + "ms)");
                System.exit(0);
            }
 
            public static void fillMap(Map<Integer, Integer> map) {
                Random rand = new Random();
                for (int i = 0; i < MAP_SIZE; ++i) {
                    map.put(rand.nextInt(), rand.nextInt());
                }
            }
        }
        class SynchronizedThread extends Thread {
            private static Map<Integer, Integer> map = new HashMap<Integer, Integer>();
            public long count = 0;
            static {
                MapTest.fillMap(map);
            }
 
            public void run() {
                for (;;) {
                    int index = (int) (count % MapTest.KEYS.length);
                    synchronized (SynchronizedThread.class) {
                        map.get(MapTest.KEYS[index]);
                    }
                    ++count;
                }
            }
        }
 
        class LockThread extends Thread {
            private static Map<Integer, Integer> map = new HashMap<Integer, Integer>();
            private static Lock lock = new ReentrantLock();
            public long count = 0;
            static {
                MapTest.fillMap(map);
            }
 
            public void run() {
                for (;;) {
                    int index = (int) (count % MapTest.KEYS.length);
                    lock.lock();
                    map.get(MapTest.KEYS[index]);
                    lock.unlock();
                    ++count;
                }
            }
        }

阅读全文

0 0

Java集合中那些类是线程安全的 以及 Map线程安全几种实现方法

Map线程安全几种实现方法

Java集合中那些类是线程安全的以及 Map线程安全几种实现方法