一、并发容器ConcurrentHashMap

HashMap是我们用得非常频繁的一个集合,但是它是线程不安全的。并且在多线程环境下,put操作是有可能产生死循环,不过在JDK1.8的版本中更换了数据插入的顺序,已经解决了这个问题

为了解决该问题,提供了Hashtable和Collections.synchronizedMap(hashMap)两种解决方案,但是这两种方案都是对读写加锁,独占式。一个线程在读时其他线程必须等待,吞吐量较低,性能较为低下。

而J.U.C给我们提供了高性能的线程安全HashMap:ConcurrentHashMap。

在1.8版本以前,ConcurrentHashMap采用分段锁的概念,使锁更加细化,但是1.8已经改变了这种思路,而是利用CAS+Synchronized来保证并发更新的安全,当然底层采用数组+链表+红黑树的存储结构。

  ConcurrentHashMap通常只被看做并发效率更高的Map,用来替换其他线程安全的Map容器,比如 Hashtable和Collections.synchronizedMap。线程安全的容器,特别是Map,很多情况下一个业务中 涉及容器的操作有多个(读get写put,remove),即复合操作,而在并发执行时,线程安全的容器只能保证自身的数据不被破 坏,和数据在多个线程间是可见的,但无法保证业务的行为是否正确

1、ConcurrentHashMap对比Hashtable

Hashtable和ConcurrentHashMap的不同点:

(1)、Hashtable 对get,put,remove都使用了同步操作,它的同步级别是正对Hashtable来进行同步的,也就是说如果有线程正在遍历集合,其他的线程就暂时不能使用该集合了,这样无疑就很容易对性能和吞吐量造成影响,从而形成单点。而ConcurrentHashMap则不同,它只对put,remove操作使用了同步操作,get操作并不影响。

(2)、Hashtable 在遍历的时候,如果其他线程,包括本线程对Hashtable进行了put,remove等更新操作的话,就会抛出ConcurrentModificationException异常,但如果使用ConcurrentHashMap的话,就不用考虑这方面的问题了

2、ConcurrentHashMap总结

(1)、HashMap 是线程不安全的,ConcurrentHashMap是线程安全的,但是线程安全仅仅指的是对容器操作的时候是线程安全的

(2)、ConcurrentHashMap 的public V get(Object key)不涉及到锁,也就是说获得对象时没有使用锁,它只对put,remove操作使用了同步操作

(3)、put 、remove方法,在jdk7使用锁,但多线程中并不一定有锁争用,原因在于ConcurrentHashMap将缓存的变量分到多个Segment,每个Segment上有一个锁,只要多个线程访问的不是一个Segment就没有锁争用,就没有堵塞,各线程用各自的锁,ConcurrentHashMap缺省情况下生成16个Segment,也就是允许16个线程并发的更新而尽量没有锁争用。而在jdk8中使用的CAS+Synchronized来保证线程安全,比加锁的性能更高

(4)、ConcurrentHashMap 线程安全的,允许一边更新、一边遍历,也就是说在对象遍历的时候,也可以进行remove,put操作,且遍历的数据会随着remove,put操作产出变化

以下例子分别使用HashMap、ConcurrentHashMap、HashTable在遍历的同时删除,

案例一:遍历的同时删除

说明:ConcurrentHashMap 线程安全的,允许一边更新、一边遍历,也就是说在对象遍历的时候,也可以进行remove,put操作,且遍历的数据会随着remove,put操作产出变化

情况一、使用HashMap进行遍历的同时删除

public class ConcurrentHashMapDemo {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("a",1);
        map.put("b",1);
        map.put("c",1);
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            map.remove(entry.getKey());
        }
        System.out.println(map.size());
    }
}

HashMap不能一边遍历一边更新,否则报异常ConcurrentModificationException

 情况二、使用ConcurrentHashMap进行遍历的同时删除

public class ConcurrentHashMapDemo {
    public static void main(String[] args) {
//        Map<String, Integer> map = new HashMap<>();
        Map<String, Integer> map = new ConcurrentHashMap<>();
        map.put("a",1);
        map.put("b",1);
        map.put("c",1);
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            map.remove(entry.getKey());
        }
        System.out.println(map.size());
    }
}

ConcurrentHashMap不存在该问题,输出结果为0.

 情况三、使用HashTable进行遍历的同时删除

public class ConcurrentHashMapDemo {
    public static void main(String[] args) {
//        Map<String, Integer> map = new HashMap<>();
//        Map<String, Integer> map = new ConcurrentHashMap<>();
        Map<String, Integer> map = new Hashtable<>();
        map.put("a",1);
        map.put("b",1);
        map.put("c",1);
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            map.remove(entry.getKey());
        }
        System.out.println(map.size());
    }
}

如果用性能较低的安全容器HashTable,也报异常ConcurrentModificationException

 

案例2:业务操作的线程安全不能保证

说明:线程安全的容器,特别是Map,很多情况下一个业务中 涉及容器的操作有多个(读get写put,remove),即复合操作,而在并发执行时,线程安全的容器只能保证自身的数据不被破 坏,和数据在多个线程间是可见的,但无法保证业务的行为是否正确,即ConcurrentHashMap多线程操作不能保证数据同步

以下分别使用HashMap、ConcurrentHashMap、HashTable边遍历时边更新,运行了3个线程,理论上最后得到6000,

public class ConcurrentHashMapDemo2 {
    public static void main(String[] args) {
        final Map<String, Integer> count = new ConcurrentHashMap<>();
//        final Map<String, Integer> count = new HashMap<>();
//        final Map<String, Integer> count = new Hashtable<>();
        count.put("count",0);
        Runnable task = new Runnable(){
            @Override
            public void run() {
                int value;
                for (int i = 0; i < 2000; i++) {
                    value = count.get("count");
                    count.put("count",value + 1);
                }
            }
        };
        new Thread(task).start();
        new Thread(task).start();
        new Thread(task).start();
        try {
            Thread.sleep(1000l);
            System.out.println(count);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果如下:

1、如果使用HashMap,结果为3426

{count=3426}

2、如果使用ConcurrentHashMap,结果为2525,因为只能保证对容器的操作是没问题的,但是不能保证业务是没有问题的,因为是复和操作且并发执行。

{count=2525}

3、HashTable也不能保证业务没有问题。

{count=3814}

如果非要在这种情况下保证线程安全问题,同步就可以了,加同步代码块,保证读写是同步的

public class ConcurrentHashMapDemo2 {
    public static void main(String[] args) {
        final Map<String, Integer> count = new ConcurrentHashMap<>();
//        final Map<String, Integer> count = new HashMap<>();
//        final Map<String, Integer> count = new Hashtable<>();
        count.put("count",0);
        Runnable task = new Runnable(){
            @Override
            public void run() {
                synchronized (count){
                    int value;
                    for (int i = 0; i < 2000; i++) {
                        value = count.get("count");
                        count.put("count",value + 1);
                    }
                }

            }
        };
        new Thread(task).start();
        new Thread(task).start();
        new Thread(task).start();
        try {
            Thread.sleep(1000l);
            System.out.println(count);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

结果如下:

{count=6000}

案例3:多线程删除

public class ConcurrentHashMapDemo3 {
    public static void main(String[] args) {
//        final Map<String, Integer> count = new HashMap<>();
        final Map<String, Integer> count = new ConcurrentHashMap<>();
        //final Hashtable<String, Integer> count = new Hashtable<>();
        for (int i = 0; i < 2000; i++) {
            count.put("count" + i, 1);
        }
        Runnable task1 = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 500; i++) {
                    count.remove("count" + i);
                }
            }
        };
        Runnable task2 = new Runnable() {
            @Override
            public void run() {
                for (int i = 1000; i < 1500; i++) {
                    count.remove("count" + i);
                }
            }
        };
        new Thread(task1).start();
        new Thread(task2).start();
        try {
            Thread.sleep(1000l);
            System.out.println(count.size());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

当使用ConcurrentHashMap时,结果为1000;当使用HashMap时,结果为1024;当使用HashTable时,结果为1000。

案例4:多线程遍历删除不同的的数据

public class ConcurrentHashMapDemo4 {
    public static void main(String[] args) {
        final Map<Integer, Integer> count = new ConcurrentHashMap<>();
        for (int i = 0; i < 2000; i++) {
            count.put(i, 1);
        }
        Runnable task1 = new Runnable() {
            @Override
            public void run() {
                Iterator<Map.Entry<Integer, Integer>> it = count.entrySet().iterator();
                while (it.hasNext()) {
                    Map.Entry<Integer, Integer> entry = it.next();
                    if (entry.getKey() < 5) {
                        count.remove(entry.getKey()); // 多线程遍历的时候删除
                        System.out.println(entry.getKey());
                    }
                }
            }
        };
        Runnable task2 = new Runnable() {
            @Override
            public void run() {
                Iterator<Map.Entry<Integer, Integer>> it = count.entrySet().iterator();
                while (it.hasNext()) {
                    Map.Entry<Integer, Integer> entry = it.next();
                    if (entry.getKey() >= 1995) {
                        count.remove(entry.getKey()); // 多线程遍历的时候删除
                        System.out.println(entry.getKey());
                    }
                }
            }
        };
        new Thread(task1).start();
        new Thread(task2).start();
        try {
            Thread.sleep(1000l);
            System.out.println("map中键值对的数量"+count.size());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

结果如下:

0
1
2
3
4
1995
1996
1997
1998
1999
map中键值对的数量1990

推荐HashMap应用场景:

  多线程操作下HashMap无法保证数据同步,多线程修改HashMap并且有遍历的操作时,可能会产生ConcurrentModificationException异常。所以,推荐的HashMap应用场景是单线程运行环境,并且不需要遍历操作的场景。
这个推荐场景不是硬性条件。比如多线操作HashMap,我们通过加锁或者加入同步控制依然能正常应用HashMap,只是需要加上同步操作的代价。(单线程且不需要遍历时使用HashMap)

ConcurrentHashMap推荐应用场景:

多线程对HashMap数据添加删除操作时,可以采用ConcurrentHashMap。

下面三个场景都使用ConcurrentHashMap:

1、多线程添加或删除。2、遍历的时候删除。3、多线程遍历的时候删除数据

注意ConcurrentHashMap多线程操作不能保证数据同步,此时可以加同步代码块进行同步操作。

二、项目中ConcurrentHashMap的使用案例

在实际的生产环境中,单看代码很多操作并没有使用到我们常说的实现多线程的方式,但是结合具体的使用场景,某个接口或者方法会多次由不同请求发起时候,一个请求就会打开一个新的线程,其场景和直接使用多线程的效果差不多。

应用1:webSocket用来存放客户端的信息

(1)、建立连接后,把登录用户的uid和session通过put操作写入ConcurrentHashMap中。同时广播时要遍历ConcurrentHashMap来给每一个存活的session发消息该用户上线了。

session值如下:

sessionID为4,session中携带的值uid为2

(2)、登录用户下线后,需要遍历ConcurrentHashMap,如果ConcurrentHashMap中的sessionID等于当前下线的用户的sessionID,则从ConcurrentHashMap中移出。然后广播时再遍历ConcurrentHashMap,然后给每一个Session发送该用户下线的消息。

/**
 * Socket处理器
 */
@Component
public class MyWebSocketHandler implements WebSocketHandler {
    //用于保存HttpSession与WebSocketSession的映射关系
    public static final Map<Long, WebSocketSession> userSocketSessionMap;

    @Autowired
    LoginService loginservice;

    static {
        userSocketSessionMap = new ConcurrentHashMap<Long, WebSocketSession>();
    }

    /**
     * 建立连接后,把登录用户的id写入WebSocketSession
     */
    public void afterConnectionEstablished(WebSocketSession session)
            throws Exception {
        Long uid = (Long) session.getAttributes().get("uid");
        String username=loginservice.getnamebyid(uid);
        if (userSocketSessionMap.get(uid) == null) {
            userSocketSessionMap.put(uid, session); // 多线程添加操作
            Message msg = new Message();
            msg.setFrom(0L);//0表示上线消息
            msg.setText(username);
            this.broadcast(new TextMessage(new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create().toJson(msg)));
        }
    }

    /**
     * 消息处理,在客户端通过Websocket API发送的消息会经过这里,然后进行相应的处理
     */
    public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception {
            if(message.getPayloadLength()==0)
                return;
            Message msg=new Gson().fromJson(message.getPayload().toString(),Message.class);
            msg.setDate(new Date());
            sendMessageToUser(msg.getTo(), new TextMessage(new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create().toJson(msg)));
    }

    /**
     * 消息传输错误处理
     */
    public void handleTransportError(WebSocketSession session,
            Throwable exception) throws Exception {
        if (session.isOpen()) {
            session.close();
        }
        Iterator<Entry<Long, WebSocketSession>> it = userSocketSessionMap.entrySet().iterator();
        // 移除当前抛出异常用户的Socket会话
        while (it.hasNext()) {
            Entry<Long, WebSocketSession> entry = it.next();
            if (entry.getValue().getId().equals(session.getId())) {
                userSocketSessionMap.remove(entry.getKey());
                System.out.println("Socket会话已经移除:用户ID" + entry.getKey());
                String username=loginservice.getnamebyid(entry.getKey());
                Message msg = new Message();
                msg.setFrom(-2L);
                msg.setText(username);
                this.broadcast(new TextMessage(new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create().toJson(msg)));
                break;
            }
        }
    }

    /**
     * 关闭连接后
     */
    public void afterConnectionClosed(WebSocketSession session,CloseStatus closeStatus) throws Exception {
        System.out.println("Websocket:" + session.getId() + "已经关闭");
        Iterator<Entry<Long, WebSocketSession>> it = userSocketSessionMap.entrySet().iterator();
        // 移除当前用户的Socket会话
        while (it.hasNext()) {
            Entry<Long, WebSocketSession> entry = it.next();
            if (entry.getValue().getId().equals(session.getId())) {
                userSocketSessionMap.remove(entry.getKey()); // 多线程遍历的时候删除
                System.out.println("Socket会话已经移除:用户ID" + entry.getKey());
                String username=loginservice.getnamebyid(entry.getKey());
                Message msg = new Message();
                msg.setFrom(-2L);//下线消息,用-2表示
                msg.setText(username);
                this.broadcast(new TextMessage(new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create().toJson(msg)));
                break;
            }
        }
    }

    public boolean supportsPartialMessages() {
        return false;
    }

    /**
     * 给所有在线用户发送消息
     * @param message
     * @throws IOException
     */
    public void broadcast(final TextMessage message) throws IOException {
        Iterator<Entry<Long, WebSocketSession>> it = userSocketSessionMap.entrySet().iterator();

        //多线程群发
        while (it.hasNext()) {

            final Entry<Long, WebSocketSession> entry = it.next();

            if (entry.getValue().isOpen()) {
                // entry.getValue().sendMessage(message);
                new Thread(new Runnable() {

                    public void run() {
                        try {
                            if (entry.getValue().isOpen()) {
                                entry.getValue().sendMessage(message);
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }

                }).start();
            }

        }
    }

    /**
     * 给某个用户发送消息
     *
     * @param uid
     * @param message
     * @throws IOException
     */
    public void sendMessageToUser(Long uid, TextMessage message) throws IOException {
        WebSocketSession session = userSocketSessionMap.get(uid);
        if (session != null && session.isOpen()) {
            session.sendMessage(message);
        }
    }

}

 

posted on 2021-02-24 11:27  周文豪  阅读(4625)  评论(0编辑  收藏  举报