Changeset 55bfd6a


Ignore:
Timestamp:
Jul 15, 2011 8:47:49 PM (9 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
7fa874f
Parents:
79ac955
Message:

concurrentify

File:
1 edited

Legend:

Unmodified
Added
Removed
  • core/java/src/net/i2p/util/EventDispatcherImpl.java

    r79ac955 r55bfd6a  
    1010 */
    1111
    12 import java.util.ArrayList;
    1312import java.util.Collections;
    14 import java.util.HashMap;
    1513import java.util.HashSet;
    16 import java.util.Iterator;
    17 import java.util.ListIterator;
     14import java.util.List;
     15import java.util.Map;
    1816import java.util.Set;
     17import java.util.concurrent.ConcurrentHashMap;
     18import java.util.concurrent.CopyOnWriteArrayList;
    1919
    2020/**
     
    3535public class EventDispatcherImpl implements EventDispatcher {
    3636
    37     //private final static Log _log = new Log(EventDispatcherImpl.class);
    38 
    3937    private boolean _ignore = false;
    40     private final HashMap _events = new HashMap(4);
    41     private final ArrayList _attached = new ArrayList();
     38    private final Map<String, Object> _events = new ConcurrentHashMap(4);
     39    private final List<EventDispatcher> _attached = new CopyOnWriteArrayList();
    4240   
    4341    public EventDispatcher getEventDispatcher() {
     
    4745    public void attachEventDispatcher(EventDispatcher ev) {
    4846        if (ev == null) return;
    49         synchronized (_attached) {
    50             //_log.debug(this.hashCode() + ": attaching EventDispatcher " + ev.hashCode());
    51             _attached.add(ev);
    52         }
     47        _attached.add(ev);
    5348    }
    5449   
    5550    public void detachEventDispatcher(EventDispatcher ev) {
    5651        if (ev == null) return;
    57         synchronized (_attached) {
    58             ListIterator it = _attached.listIterator();
    59             while (it.hasNext()) {
    60                 if (((EventDispatcher) it.next()) == ev) {
    61                     it.remove();
    62                     break;
    63                 }
    64             }
    65         }
     52        _attached.remove(ev);
    6653    }
    6754   
     
    7158            args = "[null value]";
    7259        }
    73         //_log.debug(this.hashCode() + ": got notification [" + eventName + "] = [" + args + "]");
     60        _events.put(eventName, args);
    7461        synchronized (_events) {
    75             _events.put(eventName, args);
    7662            _events.notifyAll();
    77             synchronized (_attached) {
    78                 Iterator it = _attached.iterator();
    79                 EventDispatcher e;
    80                 while (it.hasNext()) {
    81                     e = (EventDispatcher) it.next();
    82                     //_log.debug(this.hashCode() + ": notifying attached EventDispatcher " + e.hashCode() + ": ["
    83                     //           + eventName + "] = [" + args + "]");
    84                     e.notifyEvent(eventName, args);
    85                 }
    86             }
     63        }
     64        for (EventDispatcher e : _attached) {
     65            e.notifyEvent(eventName, args);
    8766        }
    8867    }
     
    9069    public Object getEventValue(String name) {
    9170        if (_ignore) return null;
    92         Object val;
    93 
    94         synchronized (_events) {
    95             val = _events.get(name);
    96         }
    97 
    98         return val;
     71        return _events.get(name);
    9972    }
    10073
    101     public Set getEvents() {
     74    public Set<String> getEvents() {
    10275        if (_ignore) return Collections.EMPTY_SET;
    103         Set set;
    104 
    105         synchronized (_events) {
    106             set = new HashSet(_events.keySet());
    107         }
    108 
    109         return set;
     76        return new HashSet(_events.keySet());
    11077    }
    11178   
    11279    public void ignoreEvents() {
    11380        _ignore = true;
    114         synchronized (_events) {
    115             _events.clear();
    116         }
     81        _events.clear();
    11782    }
    11883   
     
    12388    public Object waitEventValue(String name) {
    12489        if (_ignore) return null;
    125         Object val;
    126 
    127         //_log.debug(this.hashCode() + ": waiting for [" + name + "]");
    12890        do {
    12991            synchronized (_events) {
    130                 if (_events.containsKey(name)) {
    131                     val = _events.get(name);
    132                     break;
    133                 }
     92                Object val = _events.get(name);
     93                if (val != null)
     94                    return val;
    13495                try {
    135                     _events.wait(1 * 1000);
    136                 } catch (InterruptedException e) { // nop
    137                 }
     96                    _events.wait(5 * 1000);
     97                } catch (InterruptedException e) {}
    13898            }
    13999        } while (true);
    140 
    141         return val;
    142100    }
    143101}
Note: See TracChangeset for help on using the changeset viewer.