金沙国际官网_金沙国际平台登录

因为这个金沙国际官网_金沙国际平台登录网站与很多的大型澳门赌场都有合作,金沙国际官网_金沙国际平台登录尽职尽责,高效执行,保持好奇心,不断学习,追求卓越,点击进入金沙国际官网_金沙国际平台登录马上体验吧,所以现在也正式地开始了营业。

您的位置:金沙国际官网 > 编程 > Python垃圾回收机制,递归算法

Python垃圾回收机制,递归算法

发布时间:2019-11-03 17:53编辑:编程浏览(179)

    int Degree2(BitNode *t){

      在线程里,如果需要共享数据,那么一定需要使用同步技术,确保一次只有一个线程访问和改变共享数据的状态。在.net中,lock语句、Interlocked类和Monitor类可用于进程内部的同步。

    对于Python垃圾回收机制主要有三个,首先是使用引用计数来跟踪和回收垃圾,为了解决循环
    引用问题,就采用标记-清除的方法,标记-清除的方法所带来的额外操作实际上与系统中总的内存
    块的总数是相关的,当需要回收的内存块越多,垃圾检查带来的额外操作就越多,为了提高垃圾收集
    的效率,采用“空间换时间的策略”,即使用分代机制,对于长时间没有被回收的内存就减少对它的
    垃圾回收频率。

    if(t==null) 
    
        return 0;
    
    if(t->lchild!=null&&t->rchild!=null)
    
        return 1+Degree2(t->lchild)+Degree2(t->rchild);
    
    return Degree2(t->lchild)+Degree2(t->rchild);
    

    1、lock语句与线程安全

      lock语句是设置锁定和解除锁定的一种简单方式。在使用lock语句之前,先进入另一个争用条件。例如:

    public class SharedState
    {
        public int State { get; set; }
    }
    public class Job
    {
        SharedState sharedState;
        public Job(SharedState sharedState)
        {
            this.sharedState = sharedState;
        }
        public void DoTheJob()
        {
            for (int i = 0; i < 50000; i++)
            {
                    sharedState.State += 1;
            }
        }
    }
    static void Main()
    {
        int numTasks = 20;
        var state = new SharedState();
        var tasks = new Task[numTasks];//定义20个任务
    
        for (int i = 0; i < numTasks; i++)
        {
            tasks[i] = Task.Run(() => new Job(state).DoTheJob());//启动20个任务,同时对数据进行修改
        }
    
        for (int i = 0; i < numTasks; i++)
        {
            tasks[i].Wait();//等待所有任务结束
        }
    
        Console.WriteLine("summarized {0}", state.State);//预想应该输出:summarized 1000000
    }
    

      实际上的输出与预想输出并不一致,每次运行的输出结果都不同,但没有一个是正确的。如果将线程数量减少,那么得到正确值的次数会增多,但也不是每次都正确。

      使用lock关键字,可以实现多个线程访问同一个数据时的同步问题。lock语句表示等待指定对象的锁定,该对象只能时引用类型。进行锁定后——只锁定了一个线程,就运行lock语句块中的代码,在lock块最后接触锁定,以便另一个线程可以锁定该对象。

    lock(obj)
    {
        //执行代码
    }
    //锁定静态成员,可以所以其类型(object)
    lock(typeof(StaticCalss))
    {
        //执行代码
    }
    

      所以修改以上的代码,使用SyncRoot模式。但是,如果是对属性的访问进行锁定:

    public class SharedState
    {
        private object syncRoot = new object();
    
        private int state = 0;
        public int State
        {
            get { lock (syncRoot) return state; }
            set { lock (syncRoot) state = value; }
        }
    }
    

      仍会出现前面的争用情况。在方法调用get存储器,以获得state的当前值,然后set存储器给state设置新值。在调用对象的get和set存储器期间,对象并没有锁定,另一个线程仍然可以获得临时值。最好的方法是在不改变SharedState类的前提下,在调用方法中,将lock语句添加到合适的地方:

    public class SharedState
    {
        public int State { get; set; }
    }
    public class Job
    {
        SharedState sharedState;
        public Job(SharedState sharedState)
        {
            this.sharedState = sharedState;
        }
        public void DoTheJob()
        {
            for (int i = 0; i < 50000; i++)
            {
                lock (sharedState)
                {
                    sharedState.State += 1;
                }
            }
        }
    }
    

      在一个地方使用lock语句并不意味着访问对象的其他线程都在等待。必须对每个访问共享数据的线程显示使用同步功能。

      为使对state的修改作为一个原子操作,修改代码:

    public class SharedState
    {
        private int state = 0;
        public int State { get { return state; } }
        public int IncrementState()
        {
            lock (this)
            {
                return ++state;
            }
        }
    }
    //外部访问
    public void DoTheJob()
    {
        for (int i = 0; i < 50000; i++)
        {
             sharedState.IncrementState();        
        }
    }
    

    首先看一下Python的内存管理架构:

    本文由金沙国际官网发布于编程,转载请注明出处:Python垃圾回收机制,递归算法

    关键词:

上一篇:没有了

下一篇:没有了