这样的代码在linux上是安全的,在某种意义上1)它不会崩溃并且无法读取free()ed内存和2)freopen()ed文件与fclose()ed文件共享相同的lockcount？
线程1:
flockfile(file);
freopen("name", a", file);
funlockfile(file);
线程2:
flockfile(file);
fputs("stuff", file);
funlockfile(file);
我试图使用条件变量触发第二个线程在一定数量的缓冲区处于双端队列中后做一些工作.
我的问题是在thrd()中,在获得信号和缓冲区<4之后,它会循环回到while循环并立即再次获得条件.有没有办法重置简历？
deque<int> vbufs;
std::mutex thrdLock;
void thrd()
{
while (true) {
cout << "thrd() waiting for lock\n";
std::unique_lock < std::mutex > lock(thrdLock);
cout << "thrd() waiting for condition\n";
cv.wait(lock, []{ return (vbufs.size() > 0); });
thrdLock.unlock();
cout << "thrd() condition set\n";
if (vbufs.size() >= 4) { // pretend to do something with 4 buffers and remove them
std::lock_guard < std::mutex > lock(thrdLock);
vbufs.pop_front();
vbufs.pop_front();
vbufs.pop_front();
vbufs.pop_front();
cout << "thrd() reducing buffers:" << vbufs.size() …我目前正在研究多线程c#应用程序.
在我的例子中,我有一个列表/字典,在应用程序启动时分配并填充在主线程中.该列表永远不会再次修改.我只使用列表来获取对象.
我必须使用锁吗？
lock(list) { var test = list[0]; }
或者我可以直接访问该对象吗？
我知道,如果我访问列表中的对象,该对象必须是线程安全的.
在我的spring-jdbc项目中,我有一个类DBStuff,我用它连接到db并进行简单的数据库操作.这是一个Web项目,有用户,所以我自然会使用会话机制.当我需要在DBStuff类中检索请求数据时,我使用下面这行代码:
HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
但是,没有解释,如果RequestContextHolder是线程安全的.即使是春天的官方论坛也没有答案.由于使用servlet,我需要为用户提供线程安全的特性.
根据定义RequestContextHolder,定义为"以线程绑定RequestAttributes对象的形式公开Web请求的Holder类".但我不确定"线程绑定"是否代表线程安全.
想象一下,我有一个类,其方法可由多个线程访问.想象一下,该类包含一个整数"i"作为私有字段,并且某些方法增加/减少该值.
最后想象一下,每次i == 5时,我的一个方法都需要阻塞(使用AutoResetEvent)
我会写:
if(i == 5)
myAutoResetEvent.WaitOne()
但是如果在我检查"i"的值和我调用WaitOne的那一刻之间另一个线程改变了"我"呢？
我无法使用锁定块包装代码,因为如果未发出myAutoResetEvent信号,它将永远保持阻塞状态.
对此有何解决方案？谢谢
我在服务器中有CPUx2并且我有一个包含许多线程的程序,如果所有线程需要很长时间才能执行某些操作,是否可以使用Thread.Sleep(10)以便让CPU将作业释放到另一个线程中？我可以只使用thread.sleep并让CPU自动切换另一个线程以改善或提高性能吗？
在2016/06/06更新:每个线程都专注于从Executors获取来自Internet的HTTP内容,而我想让它延迟更多时间,但我不确定何时添加TimeUnit.MILLISECONDS.sleep(10 )在代码里面是使用MILLISECONDS还是NANOSECOND以及有多少时隙让CPU自动切换另一个线程,这样整体性能可以公平:
@Override
public void run() {
//this.RunActual = System.currentTimeMillis();
if ("Started".equals(this.JobStatus)) {
String startDate = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss.SSS").format(Calendar.getInstance().getTime());
System.out.println(this.HttpRequestAddress + " has started at " + startDate);
try {
this.url = new URL("http://" + this.HttpRequestAddress + ":" + this.HttpRequestPort);
this.conn = (HttpURLConnection) this.url.openConnection();
this.conn.setRequestMethod(this.HttpRequestMethod);
this.conn.setReadTimeout(this.HttpRequestReadTimeout);
this.conn.setConnectTimeout(this.HttpRequestConnectionTimeout);
this.conn.setInstanceFollowRedirects(false);
for (HttpHeader hh : this.HttpRequestHeader) {
this.conn.setRequestProperty(hh.Name, hh.Value);
}
this.conn.connect();
this.responseCode = 0;
this.responseCode = this.conn.getResponseCode();
System.out.println(this.HttpRequestAddress + " has response header " + this.conn.getHeaderFields().toString());
if (this.responseCode == HttpURLConnection.HTTP_OK) {
if …我正在编写一个C++多线程代码.在测试不同互斥锁的开销时,我发现线程不安全代码似乎产生了在Visual Studio中使用Release Configuration编译的正确结果,但比使用互斥锁的代码快得多.但是,使用Debug Configuration,结果就是我的预期.我想知道是不是编译器解决了这个问题,或者只是因为在Release配置中编译的代码运行得如此之快以至于两个线程在同一时间内从不访问内存？
我的测试代码粘贴如下.
class Mutex {
public:
unsigned long long _data;
bool tryLock() {
return mtx.try_lock();
}
inline void Lock() {
mtx.lock();
}
inline void Unlock() {
mtx.unlock();
}
void safeSet(const unsigned long long &data) {
Lock();
_data = data;
Unlock();
}
Mutex& operator++ () {
Lock();
_data++;
Unlock();
return (*this);
}
Mutex operator++(int) {
Mutex tmp = (*this);
Lock();
_data++;
Unlock();
return tmp;
}
Mutex() {
_data = 0;
}
private:
std::mutex mtx;
Mutex(Mutex& cpy) {
_data …我试图Mutex用这样的IDisposable类包装一个:
public class NamedMutex : IDisposable
{
private static readonly object _syncLock = new object();
private readonly Mutex _namedMutex;
private readonly bool _createdNew;
public NamedMutex(string name)
{
if (string.IsNullOrEmpty(name)) throw new ArgumentNullException("name");
//lock (_syncLock)
{
_namedMutex = new Mutex(initiallyOwned: false, name: name, createdNew: out _createdNew);
}
_namedMutex.WaitOne();
}
public void Dispose()
{
//lock (_syncLock)
{
//if (_createdNew)
_namedMutex.ReleaseMutex();
_namedMutex.Dispose();
}
}
}
正如你从注释掉的代码中看到的那样,我已经尝试了几乎所有我能想到的工作,但要么是我的测试错误,要么是上述实现不对,因为测试要么永远不会结束(可能是死锁我无法识别或与未同步的异常崩溃).
这是我为LINQPad改编的测试:
void Main()
{
var sw = Stopwatch.StartNew();
var task1 = Task.Run(async () …那么让我告诉你我正在尝试做什么:
我有一个记录统计数据的程序,很多很多,但它记录它们,因为它们一次发生一次并将它们放入ArrayList,例如:
请注意这是一个例子,我没有记录这些统计数据,我只是简化了一下
User clicks -> Add user_click to array
User clicks -> Add user_click to array
Key press -> Add key_press to array
在每个事件(点击,按键等)之后,它检查ArrayList的大小,如果大于150,则发生以下情况:
创建新线程
该线程被赋予ArrayList
的副本原始ArrayList是.clear() 'ed
新线程组合了类似的项目,因此user_click现在是一个数量为2的项目,而不是每个数量为1的2项目
.线程将数据处理为MySQL数据库
我很想找到一个更好的方法,虽然这很好.线程池和处理问题立即出现的问题是每天会有数千个MySQL查询,而不是先将它们组合在一起.
有没有更好的方法来实现这一目标？我的方法好吗？
要记住的另一件事是events被激活和记录的线程不能减慢,所以我真的不想在主线程中组合项目.
如果你有一些很好的代码示例,如果不是只是一个好方法的想法,那就太好了!
对于任何感兴趣的人,这个项目是在GitHub上托管的,主线程在这里,队列处理器在这里,请原谅我糟糕的命名惯例和一般代码清洁度,我仍然(总是)学习!
我想用线程安全的静态方法创建一个Java类来解析日期.我知道一些Java 7(及更早版本)的日期时间类不是线程安全的.Java8中此功能的最佳线程安全实现是什么:
String text = "5/16/2008";
long timestamp = DateUtil.getTimestamp(text);
在Java 7及更早版本中,您可以这样做:
public class DateUtil {
public static long getTimestamp(String text) {
DateFormat df = new SimpleDateFormat("M/d/yyyy");
df.setTimeZone(TimeZone.getTimeZone("America/New_York"));
long timestamp = df.parse(text).getTime();
return timestamp;
}
}
但是DateFormat,我没有为每个调用创建一个新实例,而是希望为所有对此静态getTimestamp方法的调用共享一个静态实例.我的理解是,这不是线程安全的.
一个关键要求是我要解析的文本有一个短日期,如"5/16/2008",没有HH:mm:ss分辨率.
我也不想使用像Joda-Time这样的第三方库,而只想使用标准的Java 8类.
thread-safety ×10
java ×4
c# ×3
c++ ×2
c ×1
concurrency ×1
cpu ×1
idisposable ×1
jvm ×1
linux ×1
list ×1
mutex ×1
performance ×1
spring ×1