/* threads_1: Multithreading support library Yauheni A. Akhotnikau (C) 2002-2003 eao197@yahoo.com ------------------------------------------------- Permission is granted to anyone to use this software for any purpose on any computer system, and to redistribute it freely, subject to the following restrictions: 1. This software is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 2. The origin of this software must not be misrepresented, either by explicit claim or by omission. 3. Altered versions must be plainly marked as such, and must not be misrepresented as being the original software. ------------------------------------------------- */ /* Демострация работы condition variable. */ #include <iostream> #include <cpp_util_2/h/defs.hpp> #include <threads_1/h/threads.hpp> /* Класс нити, которая ожидает наступление события (срабатывания condition variable), печатает на экран сообщение и завершается. */ class type1_thread_t : public threads_1::thread_t { private : // Condition variable, срабатывание // которой ожидается нитью. const threads_1::cond_var_t & m_cv; public : type1_thread_t( const threads_1::cond_var_t & cv ); virtual ~type1_thread_t(); protected : // Данный метод выполняет все действия нити. virtual void body(); }; type1_thread_t::type1_thread_t( const threads_1::cond_var_t & cv ) : m_cv( cv ) { } type1_thread_t::~type1_thread_t() { } void type1_thread_t::body() { std::cout << "Type1 thread started\n" << std::flush; { // Захватываем mutex. threads_1::mutex_sem_t::lock_t lock( m_cv ); // Ожидаем срабатывания condition variable. m_cv.wait(); // Condition variable сработала. // Если бы здесь выполнялись какие-то // операции над разделяемыми данными, то // этому бы никто не мешал, т.к. данная // нить владеет m_sem. std::cout << "Condition variable signaled\n" << std::flush; } std::cout << "Type1 thread finished\n" << std::flush; } /* Класс нити, которая: - засыпает на 1 секунду, - затем захватывает mutex и засыпает еще на 2 секунды, - затем порождает нотификацию, освобождает mutex, - затем засыпает на 1 секунду, - захватывает mutex, порождает нотификацию, - завершает свою работу. */ class type2_thread_t : public threads_1::thread_t { private : // Condition variable, срабатывание // которой ожидается нитью. threads_1::cond_var_t & m_cv; public : type2_thread_t( threads_1::cond_var_t & cv ); virtual ~type2_thread_t(); protected : // Данный метод выполняет все действия нити. virtual void body(); }; type2_thread_t::type2_thread_t( threads_1::cond_var_t & cv ) : m_cv( cv ) { } type2_thread_t::~type2_thread_t() { } void type2_thread_t::body() { std::cout << "Type2 thread started\n" << std::flush; { sleep( 1000 ); { // Захватываем mutex. threads_1::mutex_sem_t::lock_t lock( m_cv ); std::cout << "Mutex locked #1" << std::endl; sleep( 2000 ); std::cout << "Notification to all" << std::endl; m_cv.notify_all(); } sleep( 1000 ); { // Захватываем mutex. threads_1::mutex_sem_t::lock_t lock( m_cv ); std::cout << "Mutex locked #2" << std::endl; std::cout << "Notification to all" << std::endl; m_cv.notify_all(); } } std::cout << "Type2 thread finished\n" << std::flush; } /* Класс нити, которая сначала засыпает на 2 секунды, затем ожидает наступления события (срабатывания condition variable), печатает на экран сообщение и завершается. Данная нить должна завершить свою работу только после того, как нить типа 2 второй раз отошлет нотификацию. */ class type3_thread_t : public threads_1::thread_t { private : // Condition variable, срабатывание // которой ожидается нитью. const threads_1::cond_var_t & m_cv; public : type3_thread_t( const threads_1::cond_var_t & cv ); virtual ~type3_thread_t(); protected : // Данный метод выполняет все действия нити. virtual void body(); }; type3_thread_t::type3_thread_t( const threads_1::cond_var_t & cv ) : m_cv( cv ) { } type3_thread_t::~type3_thread_t() { } void type3_thread_t::body() { std::cout << "Type3 thread started\n" << std::flush; { sleep( 2000 ); // Захватываем mutex. threads_1::mutex_sem_t::lock_t lock( m_cv ); // Ожидаем срабатывания condition variable. m_cv.wait(); // Condition variable сработала. // Если бы здесь выполнялись какие-то // операции над разделяемыми данными, то // этому бы никто не мешал, т.к. данная // нить владеет m_sem. std::cout << "Condition variable signaled\n" << std::flush; } sleep( 1000 ); std::cout << "Type3 thread finished\n" << std::flush; } int main() { threads_1::cond_var_t cv( &threads_1::cond_var_t::own_mutex ); type1_thread_t th1_1( cv ); type1_thread_t th1_2( cv ); type1_thread_t th1_3( cv ); type1_thread_t th1_4( cv ); type1_thread_t th1_5( cv ); type2_thread_t th2_1( cv ); type3_thread_t th3_1( cv ); type3_thread_t th3_2( cv ); type3_thread_t th3_3( cv ); type3_thread_t th3_4( cv ); type3_thread_t th3_5( cv ); th1_1.start(); th1_2.start(); th1_3.start(); th1_4.start(); th1_5.start(); th2_1.start(); th3_1.start(); th3_2.start(); th3_3.start(); th3_4.start(); th3_5.start(); th1_1.wait(); th1_2.wait(); th1_3.wait(); th1_4.wait(); th1_5.wait(); th2_1.wait(); th3_1.wait(); th3_2.wait(); th3_3.wait(); th3_4.wait(); th3_5.wait(); return 0; }
00001 /* 00002 00003 threads_1: Multithreading support library 00004 Yauheni A. Akhotnikau (C) 2002-2003 00005 eao197@yahoo.com 00006 ------------------------------------------------- 00007 00008 Permission is granted to anyone to use this software for any purpose on any 00009 computer system, and to redistribute it freely, subject to the following 00010 restrictions: 00011 00012 1. This software is distributed in the hope that it will be useful, 00013 but WITHOUT ANY WARRANTY; without even the implied warranty of 00014 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 00015 00016 2. The origin of this software must not be misrepresented, either by 00017 explicit claim or by omission. 00018 00019 3. Altered versions must be plainly marked as such, and must not be 00020 misrepresented as being the original software. 00021 00022 ------------------------------------------------- 00023 00024 */ 00025 /* 00026 Демострация работы condition variable. 00027 */ 00028 00029 #include <iostream> 00030 00031 #include <cpp_util_2/h/defs.hpp> 00032 00033 #include <threads_1/h/threads.hpp> 00034 00035 /* 00036 Класс нити, которая ожидает наступление 00037 события (срабатывания condition variable), 00038 печатает на экран сообщение и завершается. 00039 */ 00040 class type1_thread_t : 00041 public threads_1::thread_t 00042 { 00043 private : 00044 // Condition variable, срабатывание 00045 // которой ожидается нитью. 00046 const threads_1::cond_var_t & m_cv; 00047 public : 00048 type1_thread_t( 00049 const threads_1::cond_var_t & cv ); 00050 virtual ~type1_thread_t(); 00051 00052 protected : 00053 // Данный метод выполняет все действия нити. 00054 virtual void 00055 body(); 00056 }; 00057 00058 type1_thread_t::type1_thread_t( 00059 const threads_1::cond_var_t & cv ) 00060 : 00061 m_cv( cv ) 00062 { 00063 } 00064 00065 type1_thread_t::~type1_thread_t() 00066 { 00067 } 00068 00069 void 00070 type1_thread_t::body() 00071 { 00072 std::cout << "Type1 thread started\n" << std::flush; 00073 00074 { 00075 // Захватываем mutex. 00076 threads_1::mutex_sem_t::lock_t lock( m_cv ); 00077 00078 // Ожидаем срабатывания condition variable. 00079 m_cv.wait(); 00080 00081 // Condition variable сработала. 00082 // Если бы здесь выполнялись какие-то 00083 // операции над разделяемыми данными, то 00084 // этому бы никто не мешал, т.к. данная 00085 // нить владеет m_sem. 00086 std::cout << "Condition variable signaled\n" 00087 << std::flush; 00088 } 00089 00090 std::cout << "Type1 thread finished\n" << std::flush; 00091 } 00092 00093 /* 00094 Класс нити, которая: 00095 - засыпает на 1 секунду, 00096 - затем захватывает mutex и засыпает еще на 2 секунды, 00097 - затем порождает нотификацию, освобождает mutex, 00098 - затем засыпает на 1 секунду, 00099 - захватывает mutex, порождает нотификацию, 00100 - завершает свою работу. 00101 */ 00102 class type2_thread_t : 00103 public threads_1::thread_t 00104 { 00105 private : 00106 // Condition variable, срабатывание 00107 // которой ожидается нитью. 00108 threads_1::cond_var_t & m_cv; 00109 00110 public : 00111 type2_thread_t( 00112 threads_1::cond_var_t & cv ); 00113 virtual ~type2_thread_t(); 00114 00115 protected : 00116 // Данный метод выполняет все действия нити. 00117 virtual void 00118 body(); 00119 }; 00120 00121 type2_thread_t::type2_thread_t( 00122 threads_1::cond_var_t & cv ) 00123 : 00124 m_cv( cv ) 00125 { 00126 } 00127 00128 type2_thread_t::~type2_thread_t() 00129 { 00130 } 00131 00132 void 00133 type2_thread_t::body() 00134 { 00135 std::cout << "Type2 thread started\n" << std::flush; 00136 00137 { 00138 sleep( 1000 ); 00139 00140 { 00141 // Захватываем mutex. 00142 threads_1::mutex_sem_t::lock_t lock( m_cv ); 00143 std::cout << "Mutex locked #1" << std::endl; 00144 00145 sleep( 2000 ); 00146 std::cout << "Notification to all" << std::endl; 00147 m_cv.notify_all(); 00148 } 00149 00150 sleep( 1000 ); 00151 { 00152 // Захватываем mutex. 00153 threads_1::mutex_sem_t::lock_t lock( m_cv ); 00154 std::cout << "Mutex locked #2" << std::endl; 00155 std::cout << "Notification to all" << std::endl; 00156 m_cv.notify_all(); 00157 } 00158 } 00159 00160 std::cout << "Type2 thread finished\n" << std::flush; 00161 } 00162 00163 /* 00164 Класс нити, которая сначала засыпает на 2 секунды, 00165 затем ожидает наступления 00166 события (срабатывания condition variable), 00167 печатает на экран сообщение и завершается. 00168 00169 Данная нить должна завершить свою работу только после 00170 того, как нить типа 2 второй раз отошлет нотификацию. 00171 */ 00172 class type3_thread_t : 00173 public threads_1::thread_t 00174 { 00175 private : 00176 // Condition variable, срабатывание 00177 // которой ожидается нитью. 00178 const threads_1::cond_var_t & m_cv; 00179 00180 public : 00181 type3_thread_t( 00182 const threads_1::cond_var_t & cv ); 00183 virtual ~type3_thread_t(); 00184 00185 protected : 00186 // Данный метод выполняет все действия нити. 00187 virtual void 00188 body(); 00189 }; 00190 00191 type3_thread_t::type3_thread_t( 00192 const threads_1::cond_var_t & cv ) 00193 : 00194 m_cv( cv ) 00195 { 00196 } 00197 00198 type3_thread_t::~type3_thread_t() 00199 { 00200 } 00201 00202 void 00203 type3_thread_t::body() 00204 { 00205 std::cout << "Type3 thread started\n" << std::flush; 00206 00207 { 00208 sleep( 2000 ); 00209 00210 // Захватываем mutex. 00211 threads_1::mutex_sem_t::lock_t lock( m_cv ); 00212 00213 // Ожидаем срабатывания condition variable. 00214 m_cv.wait(); 00215 00216 // Condition variable сработала. 00217 // Если бы здесь выполнялись какие-то 00218 // операции над разделяемыми данными, то 00219 // этому бы никто не мешал, т.к. данная 00220 // нить владеет m_sem. 00221 std::cout << "Condition variable signaled\n" 00222 << std::flush; 00223 } 00224 00225 sleep( 1000 ); 00226 std::cout << "Type3 thread finished\n" << std::flush; 00227 } 00228 00229 int 00230 main() 00231 { 00232 threads_1::cond_var_t cv( 00233 &threads_1::cond_var_t::own_mutex ); 00234 00235 type1_thread_t th1_1( cv ); 00236 type1_thread_t th1_2( cv ); 00237 type1_thread_t th1_3( cv ); 00238 type1_thread_t th1_4( cv ); 00239 type1_thread_t th1_5( cv ); 00240 type2_thread_t th2_1( cv ); 00241 type3_thread_t th3_1( cv ); 00242 type3_thread_t th3_2( cv ); 00243 type3_thread_t th3_3( cv ); 00244 type3_thread_t th3_4( cv ); 00245 type3_thread_t th3_5( cv ); 00246 00247 th1_1.start(); 00248 th1_2.start(); 00249 th1_3.start(); 00250 th1_4.start(); 00251 th1_5.start(); 00252 th2_1.start(); 00253 th3_1.start(); 00254 th3_2.start(); 00255 th3_3.start(); 00256 th3_4.start(); 00257 th3_5.start(); 00258 00259 th1_1.wait(); 00260 th1_2.wait(); 00261 th1_3.wait(); 00262 th1_4.wait(); 00263 th1_5.wait(); 00264 th2_1.wait(); 00265 th3_1.wait(); 00266 th3_2.wait(); 00267 th3_3.wait(); 00268 th3_4.wait(); 00269 th3_5.wait(); 00270 00271 return 0; 00272 }
1.3.7
