关于 thread safe

[dingounan]

我怎样才能使我的程序组件具有thread safe?

我想使原本single-thread下写的component只继承一个类就可以实现thread safe,可以吗?

[oo]

光这样不行的。

[dingounan]

能不能介绍一下<<modern c++ design>>(附录)里的threading-modle?
好像它能使我编写出那样的代码.

[hxblvc]

你必须对component中的数据进行互斥访问.

[idau7]

ohh, shit ,其实我还不明白你们在说虾米...

表鄙视我.

[lovefly_fanny]

保证thread的安全性 很大一部分考虑就是
基于共享数据的保护，即有多个线程共享某个
变量数据的时候必须保证同一时刻只有一个线程在
操纵这块数据，并且只有在该线程对这片数据
完成读写操作之后，才能由其他线程接管，
这样做的目的就是出于保持数据的一致性考虑，
否则的话由于线程调度的不可预测性将导致数据结果
的不可预见性，显然这不是我们所希望看到的，
因此在这里引入互坼访问机制就很必要了，
一般的机制实现有 加锁，信号量···都可以保证
java中的sychronize keyword 机制使其处理起来就很方便了

[Henry0]

如楼上据说的话，就要引入多线程了

[yjh1982]

非得自己控制不可.

[autoegg]

爱水鱼说得很对呀，根本原理就是防止共享资源的访问冲突。

[dingounan]

我在编写程序库时并不知道 未来的使用者 使用什么样的 多线程库锁件 lock我的组件
我如何才能提供一个统一的接口?

[xcopy]

要考虑一种情况,对象已经被delete了但是线程还没有结束.

[Jinhao]

>回复人： dingounan(don) ( ) 信誉：100 2005-01-27 16:46:00 得分: 0
>
> 我在编写程序库时并不知道 未来的使用者 使用什么样的 多线程库锁件 lock我的组件
>我如何才能提供一个统一的接口?

你就可以用<<modern c++ design>>的方法啊，用模板实现策略~~~
对于别人使用你的程序库。如果遇到接口不匹配的 多线程锁件，那么做个简单的包装使其能顺利工作在你的程序库中，这是使用者的责任

[dingounan]

我不想在库中使用多线程,只是想做到thread-safe.
我依然要像以下这样编写一段代码 加入到我自己的库中?
<伪码>
lock(mutex& m) { m.allow_to_access=false;}

unlock(mutex& m) {m.allow_to_access=true;}

I_want_to_write(obj& o)
{ while(对象o的allow_to_access==false) { 等待其他线程释放对象o;} }
</伪码>

是这样吗?

但好像STL都没那么负责任,它只提供了以下保证:
1 对同一container的read安全
2 对不同container的read,write安全
//引自 SGI STL design documents: http://stl.winterxy.com/html/bibliography.html#bi21

[Jinhao]

基本上就是那个pseudocode 的意思
你可以把mutex隐藏在幕后

template<typename _Lock>
class container
{
public:
void write()
{
lock_.in();
//....资源访问
lock_.out();
}
private:
_Lock lock_;
};

但是STL也可以保证你写出thread-safe的代码，只是你要在对容器访问前手动加锁

[Mephisto_76]

使用《modern c++ design》中介绍的线程模型实现策略，可以解决一些问题。但是我想，对于一个容器，如果要对里边的元素进行遍列，而每个元素的访问都需要lock/unlock的话效率上会不会有损耗？
但是如果对容器加锁，是不是又会影响系统的可伸缩性。

[sandrowjw]

再要么就是使用Guard，但是Lock和Unlock是肯定需要的。加锁可以对于某些个数量的元素进行，比如100万个元素的数组，可以对每256个元素加一个锁，这样可以赚回来一些效率。否则只有去研究Lock-Free了。
一个Guard的简单例子：
struct Guard
{
Guard()
{ lock(); }
~Guard()
{ unlock(); }
private:
Guard(const Guard&);
Guard& operator=(const Guard&);
};

void Foo()
{
Guard _dummy();
...
}

[caslwzgks]

Boost Library :

#ifdef _WIN32
struct mutex
{
private:
CRIECTION m_cs; //具体类型忘了（关键代码段）
public:
mutex()
{
InitXXX(&m_cs);
}
~mutex()
{
DeleteXXX(&m_cs);
}

struct Lock;
friend struct Lock;
struct Lock
{
mutex & m_;
Lock(mutex & m):m_(m)
{
EnterXXX( &m_.m_cs );
}
~Lock()
{
LeaveXXX(&m_.m_cs);
}

};
　
};

#endif


//use ....

class foo
{
private:
mutex lock_;
int data_; //要同步的数据
public:
void setData(int data)
{
mutex::Lock guard( lock_);
data_ = data;
}
int getData()const
{
mutex::Lock guard(lock_);
return data_;
}
};

这个放法是比较通用的，也很零活．可以进行方法级同步．而采用继承方式，就可以实现线程安全，我想可以参考一下COM的线程模型．

[Meuck]

STL只保正在多线程情况下读取是安全的。

[Meuck]

不过好象VC6。0自带的STL版本好象是不保正读安全的哦。

[nicknide]

//我写的:
#ifndef __NICK__CRITICAL_SECTION__K_IN_G__
#define __NICK__CRITICAL_SECTION__K_IN_G__

#ifndef __cplusplus
#error Must Have C++ Complier Support
#endif // __cplusplus

#include <windows.h>
#include <process.h>

//这个宏是好东西啊
#define LOCK(cs,opt) {cs.Enter();opt;cs.Leave();}

namespace nick{
class CriticalSection
{
public:
CriticalSection(void)
{
InitializeCriticalSection(&c_s_);
}

~CriticalSection(void)
{
DeleteCriticalSection(&c_s_);
}

void
Enter(void)
{
EnterCriticalSection(&c_s_);
}

void
Leave(void)
{
LeaveCriticalSection(&c_s_);
}

private:
CRITICAL_SECTION c_s_;

CriticalSection( const CriticalSection& other );
CriticalSection& operator = ( const CriticalSection& other );
};
} // namespace nick

#endif // __NICK__CRITICAL_SECTION__K_IN_G__



//例子:
CriticalSection cs;
int i = 0;

int
main()
{

LOCK(cs,
for (i=0;i < 1000;i++)
//do some thing
)
}


//other thread:
LOCK(cs,
for (i=1000;i < 2000;++i)
// do other thing;
)
//实现了使用 i 上的安全性
//不用写什么Enter Leave了，直接一个LOCK宏搞定,不过g++对于宏内部
//方面的支持有问题,不支持宏实参里面带分号(不知道最新的版本支持吗)
//但是.net 中没有问题