我现在正在阅读有关内存屏障和障碍的信息,以此来同步多线程代码并避免代码重新排序.
我通常在Linux OS下用C++开发,我boost大量使用libs,但是我找不到任何与之相关的类.你知道在增强中是否存在栅栏的记忆障碍,或者是否有办法实现相同的概念？如果不是我可以看看哪个好的图书馆？
我们正在编写一个具有大量后台处理功能的iPad应用程序,所有这些都是用一组C++库编写的.这些库在Linux,Mac和Windows上运行良好,但在iPad上它们只能在调试版本中运行.
在发布版本中,看起来当第一个子线程正在被旋转时,它或者从未实际启动,或者它在处理过程中得不到足以允许主线程继续运行(它不是很明显调试器,如果线程实际上是否正在启动,则由于在发布版本中使用断点的正常问题).
查看调试器中的主线程boost::thread::start_thread(实际上boost::detail::yield位于其中boost::detail::spin_lock::lock).
CPU不是100%,因此旋转锁似乎不会创建新线程.
我们尝试了Boost 1.42和Boost 1.44,它们的行为方式相同.iOS 3.2和4.2都失败了发布版本.
我们可能做错了什么,或者这是一个已知的不工作配置？
我正在学习boost.thread的基础知识.到目前为止,我可以手动逐个创建每个线程,让它们同时运行.但是,在通过循环创建时,它会依次运行而不是并发运行.
#include <iostream>
#include <boost/thread.hpp>
void workerFunc()
{
boost::posix_time::seconds workTime(3);
std::cout << "Worker: Running" << '\n';
boost::this_thread::sleep(workTime);
std::cout<< "Worker: Finished" << '\n';
}
int main()
{
std::cout << "main: startup" << '\n';
boost::thread workerThread(workerFunc);
std::cout << "main: waiting for thread" << '\n';
//these are ok
boost::thread t(workerFunc), t2(workerFunc), t3(workerFunc), t4(workerFunc);
t.join();
t2.join();
t3.join();
t4.join();
//these are not
for (int i = 0; i < 2; ++i)
{
boost::thread z(workerFunc);
z.join();
}
std::cout << "main:done" << '\n';
return 0;
}
我正在尝试一个例子,它会导致竞争条件应用互斥锁.但是,即使使用互斥锁,它仍然会发生.怎么了？这是我的代码:
#include <iostream>
#include <boost/thread.hpp>
#include <vector>
using namespace std;
class Soldier
{
private:
boost::thread m_Thread;
public:
static int count , moneySpent;
static boost::mutex soldierMutex;
Soldier(){}
void start(int cost)
{
m_Thread = boost::thread(&Soldier::process, this,cost);
}
void process(int cost)
{
{
boost::mutex::scoped_lock lock(soldierMutex);
//soldierMutex.lock();
int tmp = count;
++tmp;
count = tmp;
tmp = moneySpent;
tmp += cost;
moneySpent = tmp;
// soldierMutex.unlock();
}
}
void join()
{
m_Thread.join();
}
};
int Soldier::count, Soldier::moneySpent;
boost::mutex Soldier::soldierMutex;
int main()
{
Soldier s1,s2,s3; …所以我们有功能a和类b.线程one调用a,没有其他线程可以调用a或b直到one将调用b.意思是线程one能够调用a而不是a...而且a,而且one没有调用b其他想要调用a或b等待的线程.有可能做这样的事情,boost::mutex怎么做？
下面的代码会给我一个错误,因为boost :: mutex是不可复制的,而xyz.push_back()是一个复制构造函数.
class XYZ
{
public:
double x;
boost::mutex x_mutex;
}
vector<XYZ> xyz;
xyz.push_back(XYZ());
所以我试过这样的事,
class XYZ
{
public:
double x;
boost::mutex * x_mutex;
}
vector<XYZ> xyz;
xyz.push_back(XYZ());
它没有错误,但问题是"互斥体实际上是否会按原样运行？" 这是在类中封装互斥体,然后创建该类的向量的好方法吗？
谢谢.
我有一个由多个线程共享的对象,我想锁定单个成员变量,而不锁定整个对象,以便不同的线程可以同时访问不同的成员变量.阅读完一些文章后,我使用shared_mutex和getter()/ setter()函数编写代码.
class Test
{
public:
**// variable, shared_mutex and getter/setter for x**
double x;
boost::shared_mutex x_mutex;
double x_getter();
void x_setter();
**// variable, shared_mutex and getter/setter for y**
......
**// variable, shared_mutex and getter/setter for z**
......
};
double Test::x_getter()
{
// get shared access
boost::shared_lock lock(_access);
return x;
}
void Test::x_setter()
{
// get exclusive access
boost::unique_lock lock(_access);
// do something with x;
}
//getter/setter functions for y and z.
......
代码看起来很笨拙,特别是当成员变量的数量增加时.我想知道这类问题是否有更好的解决方案.
谢谢.
我希望能够按如下方式中断线程.
void mainThread(char* cmd)
{
if (!strcmp(cmd, "start"))
boost::thread thrd(sender); //start thread
if (!strcmp(cmd, "stop"))
thrd.interrupt(); // doesn't work, because thrd is undefined here
}
thrd.interrupt()是不可能的,因为当我尝试中断thrd对象时,它是未定义的.我怎样才能解决这个问题？
我已经浏览了Stack Overflow并且已经有了一些非常好的答案,(我的代码实际上基于这里的答案)但是由于某种原因我得到了奇怪的行为 - 因为thread_func应该被称为ls1次,但它在线程退出之前仅运行0到2次.似乎ioService.stop()在完成排队的作业之前就已经将其排除,但据我所知,这不应该发生.以下是相关的代码段:
boost::asio::io_service ioService;
boost::asio::io_service::work work(ioService);
boost::thread_group threadpool;
for (unsigned t = 0; t < num_threads; t++)
{
threadpool.create_thread(boost::bind(&boost::asio::io_service::run, &ioService));
}
//Iterate over the dimensions of the matrices
for (unsigned i = 0; i < ls1; i++)
{
ioService.post(boost::bind(&thread_func,i, rs1, rs2, ls2, arr, left_arr, &result));
}
ioService.stop();
threadpool.join_all();
任何帮助将不胜感激,谢谢!
我有一个主程序，它使用 boost 进程库来生成一个打印的子进程
Hello World !
每 5 秒在其标准输出上。
我想在主进程中读取/监视子进程的标准输出，当它与在主程序中执行其他操作一起可用时。
我已经尝试了boost asynchronous IO（http://www.boost.org/doc/libs/1_66_0/doc/html/boost_process/tutorial.html）的示例，但所有这些似乎都阻止了主程序，直到子进程退出。
我们是否需要在单独的线程中读取孩子的标准输出？有人可以提供一个示例，其中主程序可以同时做其他事情而不是阻止来自孩子的 stdout 吗？