Re: [Boost-users] Several novice questions concerning threading

Subject: Re: [Boost-users] Several novice questions concerning threading
From: Master (master.huricane_at_[hidden])
Date: 2012-04-11 12:39:27

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_at_[hidden]> wrote:

>  Le 11/04/12 13:31, Master a écrit :
>
> Hello all .
> i am a newbie to the boost community . i recently started learning about
> threads in boost . now there are some questions i would like to ask :
>
> Welcome.
>
>  1.where can i find examples showing practical uses of boost::thread
> features?
>
> The documentation doesn't contains too much examples. You can take a look
> at the libs/thread/example and tutorial directories :(
>
>  2.how can i get all threads ID issued by me in my app?
>
> No direct way other that storing them in a container. What is your use
> case?
>
>  3.how can i iterate through running threads in my app ?
>
> No direct way other than storing a thread pointer in a container. What is
> your use case?
>
>  4.is there any kind of means to get all the running threads using boost
> library? if it does whats the calss? if it doesnt how can i do that?
>
> See above. I think that you need to specialize the thread class so that it
> inserts a handle to the created thread on a container at construction time
> and remove it at destruction time.
>
>  5.can i resume a thread after pausing it ? ( how can i pause a thread? )
>
> Boost.Thread doesn't provide fibers or resumable threads. There is
> Boost.Fiber for that purpose (not yet in Boost).
>
>  6. how can i share a variable between two or more threads , suppose i
> have a loop , i want two threads to simultaneously iterate through it , if
> thread1 counted to 3, thread2 continues it from 4 and so on . ?
> i already tried
>
> You need to protect the access to the loop index variable 'i' with a mutex
> as you did with sum.
>
> HTH,
> Vicente
>
>  ------
>
>> what is wrong with my sample app ?
>> #include <iostream>
>> #include <boost/thread.hpp>
>> using namespace std;
>> using namespace boost;
>>
>> mutex bmutex;
>> int i=0;
>> int sum=0;
>> void IteratorFunc(int threadid)
>> {
>>              for (  ; i<25 ; i++)
>>             {
>>                     lock_guard<mutex> locker(bmutex);
>>
>> cout<<"\t"<<threadid<<"\t"<<this_thread::get_id()<<"\t"<<i<<"\n";
>>                       sum+=i;
>>             }
>> }
>>
>> int main()
>> {
>>     //boost::posix_time::ptime start =
>> boost::posix_time::microsec_clock::local_time();
>>
>>     thread thrd(IteratorFunc,1);
>>     thread thrd2(IteratorFunc,2);
>>
>>     cout<<sum;
>>     thrd.join();
>>     thrd2.join();
>> }
>>
>
>
>
> _______________________________________________
> Boost-users mailing list
> Boost-users_at_[hidden]
> http://lists.boost.org/mailman/listinfo.cgi/boost-users
>