变量互斥访问

[北飞]

各位大侠好，我现在在一个类里，需要用到多线程访问一个BYTE[]成员变量，如何才能在一个线程访问时，保证另一个线程不对它做修改呢？能不能给个例子，非常感谢

[CGabriel]

[Quote=引用 4 楼 lerit 的回复:]
用不着多线程互斥这么麻烦，思路如下：
多个线程都需要访问BYTE[]成员变量，那么要设置一个标志（bool islock）当第一个线程需要修改BYTE[]时，将islock=true，修改完islock=false；每次一个线程修改这个成员变量时，都先判断islock，如果是true就不能修改而等待，如果为false，则可以修改并重复设置islock状态，从而可以保证成员变量只被一个线程修改中
[/Quote]

这个所谓的“简单”方法比 lock 至少低效百倍。

而且如果在高并发的环境之下还击有可能因为判断 islock 与修改 byte[] 并不是原子操作而出现 14 楼提到的错误

[CGabriel]

[Quote=引用 17 楼 cgabriel 的回复:]
引用 4 楼 lerit 的回复:
用不着多线程互斥这么麻烦，思路如下：
多个线程都需要访问BYTE[]成员变量，那么要设置一个标志（bool islock）当第一个线程需要修改BYTE[]时，将islock=true，修改完islock=false；每次一个线程修改这个成员变量时，都先判断islock，如果是true就不能修改而等待，如果为false，则可以修改并重复设置islock状态，从而可以保证成员变量只被一个线程修改中


这个所谓的“简单”方法比 lock 至少低效百倍。

而且如果在高并发的环境之下还击有可能因为判断 islock 与修改 byte[] 并不是原子操作而出现 14 楼提到的错误
[/Quote]

哦，漏了一点，如果在判断 islock == false 通过了，然后就是 islock = true, 接着处理 BYTE[], 要使这个过程出现异常了，非常好，islock 永远都是 true，所有线程都不用干活了。

[lerit]

[Quote=引用 18 楼 cgabriel 的回复:]
引用 17 楼 cgabriel 的回复:
引用 4 楼 lerit 的回复:
用不着多线程互斥这么麻烦，思路如下：
多个线程都需要访问BYTE[]成员变量，那么要设置一个标志（bool islock）当第一个线程需要修改BYTE[]时，将islock=true，修改完islock=false；每次一个线程修改这个成员变量时，都先判断islock，如果是true就不能修改而等待，如果为false，则可以修改并重复设置islock状态，从而可以保证成员变量只被一个线程修改中


这个所谓的“简单”方法比 lock 至少低效百倍。

而且如果在高并发的环境之下还击有可能因为判断 islock 与修改 byte[] 并不是原子操作而出现 14 楼提到的错误


哦，漏了一点，如果在判断 islock == false 通过了，然后就是 islock = true, 接着处理 BYTE[], 要使这个过程出现异常了，非常好，islock 永远都是 true，所有线程都不用干活了。
[/Quote]
那么何以见得是非常好呢？？

[lerit]

谁也没说不处理异常啊

[CGabriel]

对于线程来说非常好啊，工作时间都可以 sleep 去了， ^_^

当然，把整个操作用 try catch 起来，然后再手动抛出也可以

14 楼的问题才是致命伤。

[lerit]

[Quote=引用 21 楼 cgabriel 的回复:]
对于线程来说非常好啊，工作时间都可以 sleep 去了， ^_^

当然，把整个操作用 try catch 起来，然后再手动抛出也可以

14 楼的问题才是致命伤。
[/Quote]
恩，多线程很少用，所以就只想到这个方法，那么上面提到的加个volatile关键字，行不行呢？

[zhouyanfss]

[Quote=引用 19 楼 lerit 的回复:]
引用 18 楼 cgabriel 的回复:
引用 17 楼 cgabriel 的回复:
引用 4 楼 lerit 的回复:
用不着多线程互斥这么麻烦，思路如下：
多个线程都需要访问BYTE[]成员变量，那么要设置一个标志（bool islock）当第一个线程需要修改BYTE[]时，将islock=true，修改完islock=false；每次一个线程修改这个成员变量时，都先判断islock，如果是true就不能修改而等待，如果为false，则可以修改并重复设置islock状态，从而可以保证成员变量只被一个线程修改中


这个所谓的“简单”方法比 lock 至少低效百倍。

而且如果在高并发的环境之下还击有可能因为判断 islock 与修改 byte[] 并不是原子操作而出现 14 楼提到的错误


哦，漏了一点，如果在判断 islock == false 通过了，然后就是 islock = true, 接着处理 BYTE[], 要使这个过程出现异常了，非常好，islock 永远都是 true，所有线程都不用干活了。

那么何以见得是非常好呢？？
[/Quote]
先前LZ问的是多线程并发byte[]的问题，现在你把问题提前了一层，变成多线程并发islock的问题了，好了，有了islock，byte[]不会有并发的问题了，那islock呢，现在并发islock了，你怎么解决，再加个isIsLock?
你用你的方法开个100个线程试试就知道了！

[lerit]

我是说islock定义为volatile，那么还有谁有并发问题啊

[LutzMark]

void method()
{
lock（o）{
//对byte[]的操作
}
}

[CGabriel]

[Quote=引用 22 楼 lerit 的回复:]
引用 21 楼 cgabriel 的回复:
对于线程来说非常好啊，工作时间都可以 sleep 去了， ^_^

当然，把整个操作用 try catch 起来，然后再手动抛出也可以

14 楼的问题才是致命伤。

恩，多线程很少用，所以就只想到这个方法，那么上面提到的加个volatile关键字，行不行呢？
[/Quote]

volatile 只是个声明，没有作用的，MSDN 有很详细的说明，建议你去翻翻

多线程环境下，只有原子操作才是安全的。

[lerit]

[Quote=引用 26 楼 cgabriel 的回复:]
引用 22 楼 lerit 的回复:
引用 21 楼 cgabriel 的回复:
对于线程来说非常好啊，工作时间都可以 sleep 去了， ^_^

当然，把整个操作用 try catch 起来，然后再手动抛出也可以

14 楼的问题才是致命伤。

恩，多线程很少用，所以就只想到这个方法，那么上面提到的加个volatile关键字，行不行呢？


volatile 只是个声明，没有作用的，MSDN 有很详细的说明，建议你去翻翻

多线程环境下，只有原子操作才是安全的。
[/Quote]
哦，那还真不知道，那我请教一下行吗，volatile 既然没有作用，那么何以说是“volatile 修饰符通常用于由多个线程访问但不使用 lock 语句对访问进行序列化的字段。”，确实不明白

[CGabriel]

[Quote=引用 24 楼 lerit 的回复:]
我是说islock定义为volatile，那么还有谁有并发问题啊
[/Quote]

volatile 只是声明变量可以被多个线程访问，没有保护作用啊

而且重点不在 isLock 上面。而是两条线程同时走到 if (isLock == false) 这一句上面。判断当然是通过的，然后就一起下到后面的处理语句中，结果可想而知

[CGabriel]

[Quote=引用 27 楼 lerit 的回复:]
引用 26 楼 cgabriel 的回复:
引用 22 楼 lerit 的回复:
引用 21 楼 cgabriel 的回复:
对于线程来说非常好啊，工作时间都可以 sleep 去了， ^_^

当然，把整个操作用 try catch 起来，然后再手动抛出也可以

14 楼的问题才是致命伤。

恩，多线程很少用，所以就只想到这个方法，那么上面提到的加个volatile关键字，行不行呢？


volatile 只是个声明，没有作用的，MSDN 有很详细的说明，建议你去翻翻

多线程环境下，只有原子操作才是安全的。

哦，那还真不知道，那我请教一下行吗，volatile 既然没有作用，那么何以说是“volatile 修饰符通常用于由多个线程访问但不使用 lock 语句对访问进行序列化的字段。”，确实不明白
[/Quote]

我不知道你看 MSDN 的时候为何跳过第一句

The volatile keyword indicates that a field might be modified by multiple threads that are executing at the same time. Fields that are declared volatile are not subject to compiler optimizations that assume access by a single thread. This ensures that the most up-to-date value is present in the field at all times.

然后就直接下到

The volatile modifier is usually used for a field that is accessed by multiple threads without using the lock statement to serialize access

这里来了

第一句已经写得很清楚了。如果你对 lock 有疑问的话，那个 lock 也是个链接来的，进去看看

而你说到的“多个线程访问但不使用 lock 语句对访问进行序列化的字段的字段”有很多，通常都是在一些32为系统中属于原子操作的东西， "The volatile keyword can be applied to fields of these types" 下面已经列出

你可以看出 long， double 都不在其中

[llxzj60]

lock(BYTE[]成员变量)
{
}
这样不行？

[lerit]

The volatile keyword indicates that a field might be modified by multiple threads that are executing at the same time. Fields that are declared volatile are not subject to compiler optimizations that assume access by a single thread. This ensures that the most up-to-date value is present in the field at all times.
恩，这句我看到了，就是说这个变量不能被多个线程同时修改，也就是解决多线程互斥修改？

[lerit]

吃饭去，回来聊哈，多谢指导

[yongyinmg]

方法应该不少,lock,信号量.......

[liu_xiao0425]

学习了

[smallfz]

互斥用Mutex

Mutex _mtx=new Mutex();

...
...

_mtx.WaitOne();
/* 这里访问和修改byte[] */
_mtx.ReleaseMutex();

[北飞]

谢谢各位，已经解决了，结贴去！