부스트 스레드 제한을 변경하는 방법은 무엇입니까?

Question

그래서 1.47.0의 부스트로 간단한 스피드 벤치를 만들려고 노력합니다. 하지만 1450 개 이상의 스레드를 만들려고하면 예외가 발생합니다. 그런 boost :: tread 제한을 제거하는 방법은 무엇입니까?

내 코드 샘플 :

#include <iostream> 
#include <boost/thread.hpp> 
#include <map> 
#include <boost/thread.hpp> 
#include <boost/thread/locks.hpp> 
#include <boost/random/mersenne_twister.hpp> 
#include <boost/random/uniform_int_distribution.hpp> 
#include <boost/random.hpp> 
#include <boost/timer.hpp> 

class TestDs 
{ 
public: 

    virtual bool containsKey(int key)=0; 
    virtual int get(int key)=0; 
    virtual int put(int key, int value)=0; 
    virtual int remove(int key)=0; 
    virtual int size()=0; 
    virtual const char* name()=0; 
    virtual void print()=0; 
    virtual void shutdown()=0; 
}; 

class GeneralMap: public TestDs 
{ 
private: 

    std::map<int,int> _ds; 
    mutable boost::mutex mut_; 
public: 
    GeneralMap() {} 

    bool containsKey(int key) { 
     boost::mutex::scoped_lock lock(mut_); 
     if (_ds.find(key) != _ds.end()) 
     { 
      return true; 
     } 
     else 
     { 
      return false; 
     } 
    } 

    int get(int key) { 
     boost::mutex::scoped_lock lock(mut_); 
     return _ds[key]; 
    } 

    int put(int key, int value) { 
     boost::mutex::scoped_lock lock(mut_); 
     _ds.insert(std::pair<int, int>(key,value)); 
     return key; 
    } 

    int remove(int key) { 
     boost::mutex::scoped_lock lock(mut_); 
     return _ds.erase(key); 
    } 

    int size() { 
     boost::mutex::scoped_lock lock(mut_); 
     return _ds.size(); 
    } 
    const char* name() { 
     return "StdMap"; 
    } 
    void print() {} 
    void shutdown() {} 

}; 

int n; 
boost::shared_mutex tests; 
boost::shared_mutex results; 
boost::timer timerForCaptureFame; 
GeneralMap Ds; 

void test(int i) 
{ 
    boost::shared_lock<boost::shared_mutex> lock_r(results); 
    boost::shared_lock<boost::shared_mutex> lock(tests); 
    Ds.put(i, 0); 
    if (Ds.containsKey(i)) 
    { 
     Ds.get(i); 
    } 
    Ds.remove(i); 
} 

void result() 
{ 
    boost::upgrade_lock<boost::shared_mutex> lock(results); 
    boost::upgrade_to_unique_lock<boost::shared_mutex> uniqueLock(lock); 
    std::cout << std::endl << "test of " << Ds.name() << " complite;" << std::endl << "test performed on " << n << " items" << std::endl << "test duration: " << timerForCaptureFame.elapsed() << std::endl; 
} 

void create_tests(int n) 
{ 
    boost::upgrade_lock<boost::shared_mutex> lock(tests); 
    boost::upgrade_to_unique_lock<boost::shared_mutex> uniqueLock(lock); 
    boost::shared_lock<boost::shared_mutex> lock_r(results); 

    for(int i=0; i<n; i++) 
    { 
     boost::thread worker(test, i); 
    } 
    boost::thread worker_r(result); 
    timerForCaptureFame.restart(); 
    return; 
} 

int main() 
{ 
    n = 1000;// if n == 1600 crushes. 
    create_tests(n); 
    std::cin.get(); 
    return 0; 
} 

Answer 1

나는 그것이 부스트의 제한이 있지만 Windows의 제한 사항입니다 그래서 확실하지 않다. Mark Russinovich에 따르면 32 비트 OS의 최대 스레드 수는 2048이므로 최대 허용 스레드 수의 3/4를 근사 적으로 할당했음을 의미합니다. 다른 프로세스가 실행 중이면 사용할 수있는 스레드의 양이 줄어 듭니다.