Thank you very much :)
for keeping track of my created threads i decided to use thread_groups and accumulate them there . i came up with sth like this :

        boost::thread_group threadstore;
       
        threadstore.add_thread(&thread);
        threadstore.add_thread(&thread2);
        BOOST_FOREACH(boost::thread t ,threadstore.threads)
        {
            cout<<t.get_id();
        }


well it didnt compiled ! before that , i tried using sth like this which failed nontheless .

       vector<boost::thread> threadstore;
       
        threadstore.push_back(thread);
        threadstore.push_back(thread2);
        BOOST_FOREACH(boost::thread t ,threadstore)
        {
            cout<<t.get_id();
        }


im clueless of the cause .
The threadstore has member called  :threads , which i dont know how to work around it , there is also another member named: m ,
 which i have no clue of what it is !nor i know where it came form! or what i can do with it!
 i couldnt find any information on these members on the boost::thread documentation either
for that example i posted , i moved the mutex inside the loop and then used a sleep() method for couple of microseconds and got it working ( i mean now both threads seem to work as i expected them).
but i want to know if we have sth like , lets say a timed_lock kind of lock !, so that a thread would only hold a mutex for a specified time , and when the timeslice presented in the timed_lock() passes , the affordmentioned thread releases the mutex
and thus other thread(s) can get that mutex and so there would be no need for a sleep() for a thread to wait till it time-slice finishes up and thus releases the mutex .the current timed_lock tries to obtain the mutex in a specified time , which is not the case .
i remember i tried to use yield() for achieving such a possiblity (releasing mutex as soon as possible , i think it kinda worked ,i gave a similare result when i used sleep() )
here is the code which i wrote to actually speed up the sum action , which i think didnt give any speed ! would you see where the problem is ?
//in the name of GOD
//Seyyed Hossein Hasan Pour
//Working with Boost::threads
#define BOOST_THREAD_USE_LIB
#include <iostream>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/thread.hpp>
using namespace std;

boost::uint64_t  i = 0;
boost::uint64_t  sum=0;
boost::mutex mutex;

void IteratorFunc()
{

    for (i ; i<100000; i++)
    {
        mutex.lock();
        sum+=i;
       cout<<i<<"\t"<<boost::this_thread::get_id()<<endl;
        mutex.unlock();
        //boost::this_thread::sleep(boost::posix_time::microseconds(200));
       boost::this_thread::yield();
    }

}

int main()
{
    boost::posix_time::ptime start = boost::posix_time::microsec_clock::local_time();
    boost::thread thread(IteratorFunc);
    boost::thread thread2(IteratorFunc);

//    boost::thread_group threadstore;
//
//    threadstore.add_thread(&thread);
//    threadstore.add_thread(&thread2);
//
//    BOOST_FOREACH(boost::thread t ,threadstore.threads)
//    {
//        cout<<t.get_id();
//    }

    boost::posix_time::ptime end = boost::posix_time::microsec_clock::local_time();

    thread.join();
    thread2.join();

    cout << "sum =\t" << sum<< "\t"<<end-start<<endl;
    return 0;
}

i also want to know if we have such a capability where i can specify the priority of a thread or a group of thread against the other threads .
let me explain it little more, by that i mean , suppose we have couple of reader threads and one or two writer threads , is there any kind of possiblity that i can grant the writer thread(s) more priority in terms of accessing
a resource (by obtaining the mutex more often ? - or the writer thread(s) deny access to readers in some cases ? ) ? or a part of memory ? ( e.g an array of some kind ? )
if it is possible , how can i achieve such possibility ?
is it possible that i can know if a thread was successful in doing what it was sent to ?
can i specify that a thread or a group of thread execute in a specific order ? for example thread one must always execute first and thread two must always follow thread one . do we have such a thing ?
do i have any means of talking to threads ? checking the satus of a specific thread ? or group of threads ?
can i know by any means , that which threads are blocked and which are not ?

Thank you so much for your time and please excuse me for such newbish and yet long questions .
i really do appreciate your help and time :)
Regards
Hossein


On Wed, Apr 11, 2012 at 7:38 PM, Vicente J. Botet Escriba <vicente.botet@wanadoo.fr> wrote: