void ServerController::start_server()
{
is_server_running = true;
// Create thread for consuming process
std::thread consumer_thread(&ServerController::consume_command, this);
consumer_thread.detach();
//Create server socket
ServerSocket server_socket(port_number);
while (true)
{
try
{
std::cerr << "Server listening" << "\n";
std::shared_ptr<Socket> socket_client = nullptr;
while ((socket_client = server_socket.accept()) != nullptr)
{
std::thread handler_thread(&ServerController::handle_client, this, socket_client);
handler_thread.detach();
std::cerr << "Server listening again" << "\n";
}
}
catch (const std::exception& ex)
{
std::cerr << ex.what() << ", resuming..." << "\n";
}
}
}
int main()
{
std::thread provider_thread(provider);
std::thread consumer_thread(consumer);
provider_thread.join();
consumer_thread.join();
return 0;
}
int main(int argc, char* argv[])
{
std::ios::sync_with_stdio(false);
if (argc < 3) {
std::cout << "usage: " << argv[0] << " path/to/file size (GB)" << std::endl;
return 1;
}
std::string file(argv[1]);
std::string size(argv[2]);
std::string::size_type sz;
double target_gb = std::stod(size, &sz);
double target = target_gb * GB_SIZE;
srand (time(NULL));
std::vector<std::thread> threads;
const size_t hardware_concurrency = std::thread::hardware_concurrency();
double segment_size = target / hardware_concurrency;
cstorage<std::vector<std::string>> storage;
for(size_t i = 0; i < hardware_concurrency; i++) {
threads.push_back(std::thread([&storage, segment_size](){
producer(storage, segment_size);
}));
}
bool done = false;
std::thread consumer_thread([&file, &storage, &done](){
consumer(file, storage, done);
});
for(size_t i = 0; i < hardware_concurrency; i++) {
threads[i].join();
}
done = true;
consumer_thread.join();
std::cout << "generated: " << file << " size: " << pretty_size(target) << std::endl;
return 0;
}
int main ()
{
Hx::thread consumer_thread (consume,10);
// produce 10 items when needed:
for (int i=0; i<10; ++i) {
while (shipment_available()) Hx::this_thread::yield();
mtx.lock();
cargo = i+1;
cv.notify_one();
mtx.unlock();
}
consumer_thread.join();
return 0;
}
int main() {
// 创建仓库
auto repository = std::make_shared<Repository>(10);
// 创建生产者和消费者
Producer producer(repository);
Consumer consumer(repository);
// 分别设定单位工作的耗时
producer.set_unit_cost(20);
consumer.set_unit_cost(30);
auto count = 50; // 准备生产和消费的产品数量
std::thread producer_thread([&producer, count] {producer.produce(count); });
std::thread consumer_thread([&consumer, count] {consumer.consume(count); });
// 等待线程合并
producer_thread.join();
consumer_thread.join();
return 0;
}
int main(void)
{
struct ringbuffer *ring_buf;
pthread_t produce_pid, consume_pid;
ring_buf = ringbuffer_create(FIFO_SIZE);
if (!ring_buf) {
perror("ringbuffer_create()");
exit(1);
}
printf("multi thread test.......\n");
produce_pid = producer_thread((void*)ring_buf);
consume_pid = consumer_thread((void*)ring_buf);
pthread_join(produce_pid, NULL);
pthread_join(consume_pid, NULL);
ringbuffer_destroy(ring_buf);
return 0;
}
