xml地图|网站地图|网站标签 [设为首页] [加入收藏]
密封类和类成员,洗礼灵魂
分类:编程

            string fileName = "***.xlsx";
            string AbsolutePath = "E:\***\***.xlsx";
            IWorkbook workbook = null;  //新建IWorkbook对象  
            FileStream fileStream = new FileStream(AbsolutePath, FileMode.Open, FileAccess.Read);
            if (fileName.IndexOf(".xlsx") > 0) // 2007版本  
            {
                workbook = new XSSFWorkbook(fileStream);  //xlsx数据读入workbook  
            }
            else if (fileName.IndexOf(".xls") > 0) // 2003版本  
            {
                workbook = new HSSFWorkbook(fileStream);  //xls数据读入workbook  
            }
            ISheet sheet = workbook.GetSheetAt(0);  //获取第一个工作表  
            IRow row;// = sheet.GetRow(0);            //新建当前工作表行数据 
            int i = 1;
            int num = 0;
            while (true)
            {
                row = sheet.GetRow(i);   //row读入第i行数据  
                if (row != null)
                {
                    //for (int j = 0; j < row.LastCellNum; j++)  //对工作表每一列  
                    row.GetCell(i).SetCellType(CellType.String);//设置i行j列数据为字符串类型
                    string iValue= row.GetCell(i).StringCellValue.ToString(); //获取i行j列数据 

                }
                else
                {
                    break;
                }
                i++;
            }

            fileStream.Close();
            workbook.Close();
//密封类不能用作基类,禁止派生

public sealed class B
{
    //Class members here.
}



//派生类重写方法、索引器、属性或事件时,可以将成员声明为密封成员,之后继承的类成员不能再覆写这些成员,只能用new关键字

public class C
{
    public virtual void OutPut()
    {
        Console.WriteLine("I am Class C.");
    }
}
public class D:C
{
    public sealed override void OutPut()
    {
        Console.WriteLine("I am Class D.");
    }
}
public class E : D
{
     public new void OutPut()
     {
        Console.WriteLine("I am Class E.");
     }
}

线程(下)

 

 

7.同步锁

以此例子很卓越,实话说,那一个例子小编是直接照搬前辈的,并非原创,可是确实也很风趣,请看:

#!usr/bin/env python
#-*- coding:utf-8 -*-

# author:yangva

import threading,time

number = 100
def subnum():
    global number
    number -= 1

threads = []
for i in range(100):
    t = threading.Thread(target=subnum,args=[])
    t.start()
    threads.append(t)

for i in threads:
    i.join()

print(number)

 

这段代码的意趣是,用九十多个线程去减1,以此让变量number为100的变为0

 

结果:

 

图片 1

 

那正是说作者稍稍的改下代码看看: 

 

#!usr/bin/env python
#-*- coding:utf-8 -*-

# author:yangva

import threading,time

number = 100
def subnum():
    global number
    temp = number
    time.sleep(0.2)
    number = temp -1

threads = []
for i in range(100):
    t = threading.Thread(target=subnum,args=[])
    t.start()
    threads.append(t)

for i in threads:
    i.join()

print(number)

  

并从未异常的大的更动对啊,只是加了四个不经常变量,何况中途抛锚了0.2s而已。

而以此结果就不一致等了:

图片 2

 

那边小编先说下,time.sleep(0.2)是自谢世意加的,正是要体现这几个效应,假如您的微管理器不加sleep就早就出现那个意况了那么您就不用加了,那咋回事呢?那便是线程共用数据的绝密危殆性,因为线程都是抢着CPU财富在运营,只要开采有空儿就分别抢着跑,所以在这里停顿的0.2s时间中,就可以有新的线程抢到时机最初运维,那么九贰11个线程就有一百个线程在抢机缘运营,抢到的年华府是在temp还从未减1的值,也正是100,所以大部分的线程都抢到了100,然后减1,少一些线程没抢到,抢到已经减了三次的99,那就是怎会是99的案由。而那几个抢占的时间和结果并非一直的缘故,究其平昔还是因为计算机的铺排难题了,配置越好的话,这种越不便于生出,因为八个线程抢到CPU财富后直接在运行,其余的线程在短间隔赛跑的光阴里得不到机缘。

 

而为什么number -= 1,不相信任任何变量的写法就没事吗?因为numebr -= 1其实是多个步骤,减1不分轩轾复赋值给number,这一个动作太快,所以根本没给别的的线程机会。

 

图解: 

图片 3

 

那便是说这一个难题大家怎么化解吗,在那后的支付中相对会境遇这种情况对吧,这些能够缓慢解决吧?依据上边的传授,有人会想到用join,而眼下早就提过了join会使十二线程形成串行,失去了十二线程的用意。这几个到底怎么消除吧,用同步锁

同步锁:当运营起来加锁,制止其余线程索取,当运营结束释放锁,让任何线程继续

 

#!usr/bin/env python
#-*- coding:utf-8 -*-

# author:yangva
import threading,time

r = threading.Lock() #创建同步锁对象

number = 100
def subnum():
    global number
    r.acquire() #加锁
    temp = number
    time.sleep(0.2)
    number = temp - 1
    r.release() #释放


threads = []
for i in range(100):
    t = threading.Thread(target=subnum,args=[])
    t.start()
    threads.append(t)

for i in threads:
    i.join()

print(number)

  

运作结果:

图片 4

 

不过你意识没,那个运营太慢了,各种线程都运营了二次sleep,竟然又改为和串行运维大概了对啊?不过依旧和串行稍微有一点不一致,只是在有共同锁这里是串行,在其余地点仍然十六线程的功用

 

那正是说有心上人要问了,既然都是锁,已经有了一个GIL,那么还要一齐锁来干嘛呢?一句话,GIL是器重于保险线程安全,同步锁是顾客级的可控机制,开采中幸免这种不鲜明的秘密隐患

 

 8.死锁现象/可选取锁

日前既然已经用了联合锁,那么相信在之后的付出中,绝对会用到利用八个同步锁的时候,所以那边模拟一下选择五个联合锁,看看会有怎么着情况发生

 

#!usr/bin/env python
#-*- coding:utf-8 -*-

# author:yangva
import threading,time

a = threading.Lock() #创建同步锁对象a
b = threading.Lock() #创建同步锁对象b

def demo1():
    a.acquire() #加锁
    print('threading model test A....')
    b.acquire()
    time.sleep(0.2)
    print('threading model test B....')
    b.release()
    a.release() #释放

def demo2():
    b.acquire() #加锁
    print('threading model test B....')
    a.acquire()
    time.sleep(0.2)
    print('threading model test A....')
    a.release()
    b.release() #释放

threads = []
for i in range(5):
    t1 = threading.Thread(target=demo1,args=[])
    t2 = threading.Thread(target=demo2,args=[])
    t1.start()
    t2.start()
    threads.append(t1)
    threads.append(t2)

for i in threads:
    i.join()

 

  

运营结果:

图片 5

 

此间就一直阻塞住了,因为demo1函数用的锁是外围a锁,内层b锁,demo2函数刚好相反,外层b锁,内层a锁,所以当二十四线程运维时,两个函数同临时间在互抢锁,哪个人也不让什么人,那就导致了不通,那一个阻塞现象又叫死锁现象。

 

那么为了防止发出这种事,大家得以采用threading模块下的奥德赛LOCK来创立重用锁依此来幸免这种现象

 

#!usr/bin/env python
#-*- coding:utf-8 -*-

# author:yangva
import threading,time

r = threading.RLock() #创建重用锁对象

def demo1():
    r.acquire() #加锁
    print('threading model test A....')
    r.acquire()
    time.sleep(0.2)
    print('threading model test B....')
    r.release()
    r.release() #释放

def demo2():
    r.acquire() #加锁
    print('threading model test B....')
    r.acquire()
    time.sleep(0.2)
    print('threading model test A....')
    r.release()
    r.release() #释放

threads = []
for i in range(5):
    t1 = threading.Thread(target=demo1,args=[])
    t2 = threading.Thread(target=demo2,args=[])
    t1.start()
    t2.start()
    threads.append(t1)
    threads.append(t2)

for i in threads:
    i.join()

  

运行结果:

图片 6

 

本条XC90lock其实正是Lock+总括器,总括器里的先河值为0,每嵌套活龙活现层锁,总计器值加1,每释放风姿罗曼蒂克层锁,总计器值减1,和协同锁一样,只有当班值日为0时才算了却,让别的线程接着抢着运营。而以此PRADOlock也可以有一个合法一点的名字,递归锁

 

 那么估量有朋友会问了,为何会有死锁现象吧?或然你应当问,是怎么生产条件变成有死锁现象的,如故那句,为了掩护数量同步性,防止八线程操作同大器晚成数据时爆发冲突。这几个说辞很暧昧对吧,我说细点。例如前边的购物车系统,即使大家在操作数据时又又一次取了三回数据来保障数据的真人真事,假诺多个用户同一时候登入购物车系统在操作的话,大概差别的操作但会提到到同叁个数量的时候,就能够导致数据也许不联合了,那么就足以在内部代码里加三遍联合锁,然后再在实际上操作处再加三遍联袂锁,那样就出现多层同步锁,那么也就能够冒出死锁现象了,而那时候以此死锁现象是我们开采中恰恰供给的。

自己想,说了这些事例你应有能够驾驭为啥lock里还要有lock,相当的轻便产生死锁现象大家依然要用它了,总的说来假诺要求死锁现象就用协同锁,不需求就换来递归锁。

 

本文由澳门新葡亰手机版发布于编程,转载请注明出处:密封类和类成员,洗礼灵魂

上一篇:汽车之家配置页面,有想知道哪里有做六合彩投 下一篇:窗体关闭事件,Net的DNS解析模块
猜你喜欢
热门排行
精彩图文