zoukankan      html  css  js  c++  java
  • SafeList-线程安全的List(c#)

    List是线程不安全的,通过一个数组存储数据,当容量达到数组上限时,创建一个新数组,因此存在线程安全问题
    SafeList是在做增删改操作时返回一个新的ReadonlyList,所以不存在线程安全问题

    /// <summary>
        /// SafeList is mutable, but it uses immutable data structures to minimize the need for locking.
        /// The provided manipulation 
        /// Exposes a immutable list. Changes are made by copying the lists.
        /// SafeList is 
        /// Never perform logic on SafeList directly, always use GetList() or GetCollection() first, followed by SetList().
        /// If you need involved list-fu, use ModifyList and specify a callback. It will execute inside a lock, preventing changes on other threads from overwriting each other.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public class SafeList<T> :IEnumerable<T> {
    
            public delegate void ChangedHandler(SafeList<T> sender);
    
            public delegate IEnumerable<T> ListEditor(IList<T> items);
    
            [CLSCompliant(false)]
            protected volatile ReadOnlyCollection<T> items;
    
            protected object writeLock = new object();
    
    
            public SafeList(){
                items = new ReadOnlyCollection<T>(new List<T>());
            }
    
            public SafeList(IEnumerable<T> items) {
                items = new ReadOnlyCollection<T>(new List<T>(items));
            }
    
            public event ChangedHandler Changed;
            protected void FireChanged() {
                if (Changed != null) Changed(this);
            }
    
            public ReadOnlyCollection<T> GetCollection() {
                return items;
            }
    
            public IList<T> GetList() {
                return new List<T>(items);
            }
            
    
            public void SetList(IEnumerable<T> list) {
                lock (writeLock) {
                    items = new ReadOnlyCollection<T>(new List<T>(list));
                }
                FireChanged();
            }
    
            public void Add(T item) {
                lock (writeLock) {
                    IList<T> newList = GetList();
                    newList.Add(item);
                    items = new ReadOnlyCollection<T>(newList);
                }
                FireChanged();
            }
    
    
            public bool Remove(T item) {
                lock (writeLock) {
                    IList<T> newList = GetList();
                    bool removed = newList.Remove(item);
                    if (!removed) return false; //The item didn't exist, don't fire changed events.
                    items = new ReadOnlyCollection<T>(newList);
                }
                FireChanged();
                return true;
            }
    
            public T First {
                get {
                    ReadOnlyCollection<T> copy = items; //So we can do logic without getting an index invalid exception
                    if (copy.Count > 0) return copy[0];
                    else return default(T);
                }
            }
    
            public T Last {
                get {
                    ReadOnlyCollection<T> copy = items; //So we can do logic without getting an index invalid exception
                    if (copy.Count > 0) return copy[copy.Count -1];
                    else return default(T);
                }
            }
    
            public void AddFirst(T item) {
                lock (writeLock) {
                    IList<T> newList = GetList();
                    newList.Insert(0, item);
                    items = new ReadOnlyCollection<T>(newList);
                }
                FireChanged();
            }
    
            public void ModifyList(ListEditor callback) {
                lock (writeLock) {
                    items = new ReadOnlyCollection<T>(new List<T>(callback(GetList())));
                }
                FireChanged();
            }
    
            public bool Contains(T item) {
                return items.Contains(item);
            }
        
    
    
            public IEnumerator<T>  GetEnumerator()
            {
                return items.GetEnumerator();
            }
    
            IEnumerator IEnumerable.GetEnumerator()
            {
                return ((IEnumerable)items).GetEnumerator();
            }
    
            public IEnumerable<T> Reversed {
                get {
                    return new ReverseEnumerable<T>(items);
                }
            }
    
    
        }
    
  • 相关阅读:
    Sql诊断之Explain
    Cenos7安装docker环境以及docker-compose
    uniapp苹果内购获取不到苹果的iap支付通道
    iOS云打包如何设置通用链接等Capabilities配置
    iOS应用id,套装id,appid,BundleID申请教程
    利用Appuploader在window上申请IOS开发所需要的证书及描述文件
    浅析GET和POST请求的本质区别以及关于get请求的长度限制到底是多少的问题
    iOS苹果开发者组织账号申请时的坑
    apache开源项目--HIVE
    [Unit testing Java] Unit testing Junit Controller
  • 原文地址:https://www.cnblogs.com/fanfan-90/p/14417727.html
Copyright © 2011-2022 走看看