对某个文件进行读写操作,对于这些操作我们以前往往不能很好的进行处理,自从c#语言中引入了lock这个关键字,以上问题就比较容易予以解决了,下面就是一段简单的代码。
#include
#include
#includeint main(void)
{
clock_t start, end;
start = clock();delay(2000);
end = clock();
printf( "the time was: %fn ", (end - start) / clk_tck);return 0;
}
在做邮箱接收网关的时候遇到了以下的需求,要求为每一个邮箱开启一个接收线程,从pop3服务器上收取,然后将邮件存放到统一的ftp服务器上,要求邮件按收接顺充从1开始顺充编号。
我实现的方法为,为每个邮箱new出实例,然后分别赋给pop3邮箱地址,用户名,密码等参数。这里涉及到一个编号同步的问题,因为每个接收邮件的线程都是自己执行,所以取得编号并且递增这个动作是互斥的。
以一个静态变量表示编号如下
class emailinfo { public static int currentnumber; }
那在当前线程取得这个步骤为
_currentnumber=++emailinfo.currentnumber;
虽然此为一句,但在计算机运行时却分为多步,如下
emialinfo.currentnumber加1--emailinfo.currentnumber返回值给_currentnumber,也许线程1执行了emailinfo.currentnumber加1
的操作,但还没有取得返回值,此时线程2又执行了emailinfo.currentnumber加1的操作,然后又线程1,线程2取得了返回值就是一样的,这样就失去了按顺序递增的作用。
此时查找了网上有关线程同步的方法,其实用lock语句锁住递增的那一段即可。而介绍的相关用法为
lock(this) { _currentnumber=++emailinfo.currentnumber; }
本以为这样就可以成功,谁知道还是无效,反复查找才发现没弄清楚lock的用法。因为网上所讲的资料,举的例子比较简单,是直接new
出一个对像,然后为对像的一个函数创建了多个线程运行,所以它的同步只要lock住this即它自己就行了。因为此时只有一个实例在运,而我是new
出了多个对像,lock住每个自己的实例所以当然无效。
所以自然想了一个解决方法,就lock住相同的一个实例就行了。
因为我每个邮件接收线程的参数都是不同的,所以还是new出几个实像,但lock的方法改为如下
先为emailinfo加一个静态变量
class emailinfo {
public static object syncroot = new object(); public static int currentnumber; } 然后lock改为 lock(emailinfo.syncroot) { _currentnumber=++emailinfo.currentnumber; }
c# lock同时访问共享数据
同时需要对某个数据进行操作,或者对某个文件进行读写操作,对于这些操作我们以前往往不能很好的进行处理,自从c#语言中引入了lock这个关键字,以上问题就比较容易予以解决了,下面就是一段简单的代码。
public class accesscontrol()
{
private static object privateobjectlock = new object();public static accessresult()
{
lock(privateobjectlock)
{
//数据操作语句
}
}
}
下面个lock用法实例
using system;
namespace threadtest29
{
class account
{
private object thislock = new object();
int balance;
random r = new random();public account(int initial)
{
balance = initial;
}int withdraw(int amount)
{
if (balance < 0)
{
throw new exception("负的balance.");
}
//确保只有一个线程使用资源,一个进入临界状态,使用对象互斥锁,10个启动了的线程不能全部执行该方法
lock (thislock)
{
if (balance >= amount)
{
console.writeline("----------------------------:" + system.threading.thread.currentthread.name + "---------------");
console.writeline("调用withdrawal之前的balance:" + balance);
console.writeline("把amount输入 withdrawal :-" + amount);
//如果没有加对象互斥锁,则可能10个线程都执行下面的减法,加减法所耗时间片段非常小,可能多个线程同时执行,出现负数。
balance = balance - amount;
console.writeline("调用withdrawal之后的balance :" + balance);
return amount;
}
else
{
//最终结果
return 0;
}
}
}
public void dotransactions()
{
for (int i = 0; i < 100; i++)
{
//生成balance的被减数amount的随机数
withdraw(r.next(1, 100));
}
}
}class test
{
static void main(string[] args)
{
//初始化10个线程
system.threading.thread[] threads = new system.threading.thread[10];
//把balance初始化设定为1000
account acc = new account(1000);
for (int i = 0; i < 10; i++)
{
system.threading.thread t = new system.threading.thread(new system.threading.threadstart(acc.dotransactions));
threads[i] = t;
threads[i].name = "thread" + i.tostring();
}
for (int i = 0; i < 10; i++)
{
threads[i].start();
}
console.readkey();
}
}
}