请教高手,多个相同的exe进程访问同一个文件时,如何实现排他性???

Question

   本人目前用的是信号量和共享内存来实现的,但是当快速运行多个exe(这里是6个)时,会出现问题,请帮小弟解决一下,或者有好的方法或建议请回复一下.        public static Semaphore semNew1 = null;        public static Semaphore semOpen1 = null;        public static void opn(object strObj)
        {
            try
            {                byte[] byData;
                char[] charData;                string fileName = "C:\\NEXCO\\LOG\\test.txt";
                FileStream objFileStream = new FileStream(fileName, FileMode.Append, FileAccess.Write);                //获得字符数组
                string str = Convert.ToString(strObj);
                charData = str.ToCharArray();
                //初始化字节数组
                byData = new byte[charData.Length];
                //将字符数组转换为正确的字节格式
                Encoder enc = Encoding.UTF8.GetEncoder();
                enc.GetBytes(charData, 0, charData.Length, byData, 0, true);                // objFileStream.Seek(0, SeekOrigin.Begin);
                objFileStream.Write(byData, 0, byData.Length);
                Console.WriteLine("1!");
                Thread.Sleep(6000);
                Console.WriteLine("2!");
                objFileStream.Close();
                
            }
            catch (Exception ex)
            {
                Console.WriteLine("File is being used!");
            }        }
        static void Main(string[] args)
        {            //GetLuckNo();            //スレッドプールを作成し、引数を転送する
            ShareMem MemDB = new ShareMem();
            byte[] bytData = new byte[1];            if (MemDB.Init("MemTest", 1) != 0)
            {
                //共享内存初始化失败
                Console.WriteLine("初始化失败");
            }
            else
            {
                // MessageBox.Show("初始化成功");
                int intRet = MemDB.Read(ref bytData, 0, 1);                if (bytData[0] == 0)
                {
                    bytData[0] += 1;
                    MemDB.Write(bytData, 0, 1);
                    semNew1 = new Semaphore(0, 10, "SemaphoreShare");
                    semOpen1 = Semaphore.OpenExisting("SemaphoreShare");
                    string str = "hello:" + DateTime.Now.ToString() + "\n";
                    opn(str);
                    bytData[0] -= 1;
                    MemDB.Write(bytData, 0, 1);
                }
                else
                {
                    bytData[0] += 1;
                    MemDB.Write(bytData, 0, 1);
                    semOpen1 = Semaphore.OpenExisting("SemaphoreShare");
                    semOpen1.WaitOne();
                    string str = "nihao:" + DateTime.Now.ToString() + "\n";
                    opn(str);
                    bytData[0] -= 1;
                    MemDB.Write(bytData, 0, 1);
                }
                semOpen1.Release();
            }            Console.Read();
        }

Answer 1

http://topic.csdn.net/u/20110212/16/0d79446b-e197-4faf-89b5-00164af79015.html

Answer 2

FileStream objFileStream = new FileStream(fileName, FileMode.Append, FileAccess.Write);改为：FileStream objFileStream = new FileStream(fileName, FileMode.Append, FileAccess.Write, FileShare.None);共享模式改为独占。直到文件关闭。其他尝试打开该文件的语句则会抛出异常。

Answer 3

底层加锁本来就是“排他性”。你所需要的不过是封装出来更加适合自己项目的高层的业务逻辑。比如：public static object OpenFileStream(string path)
{
    int tms = 0;
begin:
    try
    {
        var objFileStream = new FileStream(path, FileMode.Append, FileAccess.Write);
        return objFileStream;
    }
    catch (IOException ex)
    {
        if (++tms < 20)
        {
            Thread.Sleep(800);
            goto begin;
        }
        else
            throw ex;
    }
}

Answer 4

什么“信号量”啊、“共享内存”啊，我不知道说的是什么，也没有耐心去看。文件不能以write方式打开的时候，从而抛出异常，这本来就是非常轻便的“排他性”机制了。所以你需要的只是把抛出异常之后的捕获异常的行为，再编织进自己的同步策略控制中（而不是立刻抛出给系统界面层统一处理）。

Answer 5

多个进程访问文件时，进程自己去执行 Thread.Sleep（立刻交还CPU控制），这就是在排队。