static void *philosopher(void *arg)
{
pthread_detach(pthread_self());
int i = (int)arg;
while (1) {
thinking(i);
takeFolk(i);
eating(i);
putFolk(i);
}
}
void* philosopher(void *arg)
{
int i;
int tid = *( ( int* ) arg );
/*philosopher thread thinks, becomes hungry, ...*/
for (i=0;i<10;i++) {
thinking( tid );
hungry( tid );
eating( tid);
}
return 0;
}
void *philosopher(void *arg)
{
// pthread_detach(pthread_self());
int i = (int)arg;
while(1)
{
thinking(i, nsecs);
pthread_mutex_lock(&plock);
while(!isAvailable(i)){
pthread_cond_wait(&pwait, &plock);
}
takeFork(i);
pthread_mutex_unlock(&plock);
eating(i, nsecs);
putFork(i);
pthread_cond_broadcast(&pwait);
}
}
// This function simulates the philosophers eating and thinking.
void* philosopher(void* arg){
int philo = *((int*) arg);
int eatingTime = 0;
int totalEatingTime = 0;
int thinkingTime = 0;
int totalThinkingTime =0;
free(arg);
unsigned int state = philo;
while(totalEatingTime <= MAX_EATING_TIME){
// try to acquire chopsticks if available.
while (1) {
pthread_mutex_lock(&chopstiks[philo]);
int rtrn = pthread_mutex_trylock(&chopstiks[(philo+1) % 5]);
if (rtrn == EBUSY)
pthread_mutex_unlock(&chopstiks[philo]);
else break;
sleep(1);
}
/******* philosopher i is eating for a random amount of time.*******/
if((eatingTime = randomGaussian_r(EATING_MEAN, EATING_STD, &state)) < 0)
eatingTime = 0;
eating(philo, eatingTime, totalEatingTime);
totalEatingTime += eatingTime;
// done eating, Release the chopsticks.
pthread_mutex_unlock(&chopstiks[philo]);
pthread_mutex_unlock(&chopstiks[(philo+1) % 5]);
/****** Philo is thinking for a random amount of time. ********/
if((thinkingTime = randomGaussian_r(THINKING_MEAN, THINKING_STD, &state)) < 0)
thinkingTime = 0;
totalThinkingTime += thinkingTime;
thinking(philo, thinkingTime, totalThinkingTime);
}
printf("Philo %i has finished eating. [Total time spent eating = %i]\n", philo, totalEatingTime);
philoTimeEating[philo] = totalEatingTime;
philoTimeThinking[philo] = totalThinkingTime;
return NULL;
}
void big_bang(vector<planet>& V)
{
for(int i=0;i<V.size();i++){ // put the circles together add radius
for(int j=i+1; j< V.size();j++){
eating(V[i],V[j]);
}
}
for(int i=0;i<V.size();i++) //delete who radius is 0 >>delete
{
if(V[i].get_radius()==0){
V.erase(V.begin()+i); // note : for delete
}
}
for(int i=0;i<V.size();i++){ // dont let the circles exit the screen
if(V[i].get_x()+2*V[i].get_radius()>=SCREEN_WIDTH||V[i].get_x()<=0){
V[i].velocity_x= -V[i].get_velocity_x();
}
if(V[i].get_y()+2*V[i].get_radius()>=SCREEN_HEIGHT||V[i].get_y()<=0){
V[i].velocity_y= -V[i].get_velocity_y();
}
}
}
/*
* try_eating - thread function
* @arg: the pointer which point to an struct
*
* it seems should return a void pointer, but it's not actually.
* This function is going be a dead loop unless you interrupt it,
* manually.
*/
void *try_eating(void *arg)
{
/* get which philosopher reaching here */
struct philosopher *ph = (struct philosopher *) arg;
int i;
/* time seconds as our paramaters for random number */
srand(time(0));
while (1) {
if (count >= NR)
count = 0;
/* lock it up */
pthread_mutex_lock(&cp_mutex[count]);
i = rand()%NR;
thinking(ph+i);
pthread_mutex_unlock(&cp_mutex[count]);
phv_index[i] = i;
/* check the philosopher's location */
if ((ph + phv_index[i])->ith == 0) {
pthread_mutex_lock(&cp_mutex[count]);
if (cs_shared[NR - 1] == 0 && cs_shared[(ph + phv_index[i])->ith] == 0) {
cs_shared[NR - 1] = 1;
cs_shared[0] = 1;
pthread_mutex_unlock(&cp_mutex[count]);
eating(ph + phv_index[i]);
pthread_mutex_lock(&cp_mutex[count]);
cs_shared[NR - 1] = 0;
cs_shared[0] = 0;
pthread_mutex_unlock(&cp_mutex[count]);
}
else {
hungry(ph + phv_index[i]);
cs_shared[NR - 1] = 0;
cs_shared[0] = 0;
pthread_mutex_unlock(&cp_mutex[count]);
}
}
else {
pthread_mutex_lock(&cp_mutex[1]);
if (cs_shared[(ph + phv_index[i])->ith - 1] == 0 && cs_shared[(ph + phv_index[i])->ith] == 0) {
cs_shared[(ph + phv_index[i])->ith - 1] = 1;
cs_shared[(ph + phv_index[i])->ith] = 1;
eating(ph + phv_index[i]);
pthread_mutex_unlock(&cp_mutex[1]);
pthread_mutex_lock(&cp_mutex[1]);
cs_shared[(ph + phv_index[i])->ith - 1] = 0;
cs_shared[(ph + phv_index[i])->ith] = 0;
pthread_mutex_unlock(&cp_mutex[1]);
}
else {
hungry(ph + phv_index[i]);
cs_shared[(ph + phv_index[i])->ith - 1] = 0;
cs_shared[(ph + phv_index[i])->ith] = 0;
pthread_mutex_unlock(&cp_mutex[1]);
}
}
sleep(1);
}
}
int main()
{
//Calka z sinusa
cout << "CALKA Z SINUSA" << endl;
double result = 0.0;
TworzenieWatkow calka(0, M_PI, &result);
boost::thread thread(calka);
cout << "Hardware concurrency: " << boost::thread::hardware_concurrency
<< endl;
cout << "Thread ID" << thread.get_id() << endl;
thread.join();
cout << "result" << result << endl;
cout << "DONE!";
getchar();
//-------------------------------------
//Synchronizacja
cout << "SYNCHRONIZACJA" << endl;
mutex characterMutex;
string lancuch;
lancuch.resize(CHARACTERS_TO_WRITE);
thread_group threads;
for (unsigned int i = 0; i < NUMBER_OF_THREADS; ++i)
threads.create_thread(Watek('a'+i,lancuch,characterMutex));
threads.join_all();
cout << lancuch << endl;
cout << "DONE!";
getchar();
//----------------------------------------
//Zmienne warunkowe
cout << "ZMIENNE WARUNKOWE"<<endl;
mutex dataMutex;
Monitor<char>container(dataMutex);
thread_group conditional;
mutex consoleMutex;
for (int i = 0; i < 5; i++) {
conditional.create_thread(Consumer(container,i,consoleMutex));
conditional.create_thread(Producer(container,i,consoleMutex));
}
conditional.join_all();
cout << "DONE!";
getchar();
//------------------------------------
//Pociagi/semafory
cout << "STACJA KOLEJOWA"<<endl;
Peron p1("p1"), p2("p2"), p3("p3");
Train tr1 = Train("T1", p2, p1);
boost::thread t1(tr1);
boost::thread t2(Train("T2", p2, p3));
boost::thread t3(Train("T3", p2, p1));
boost::thread t4(Train("T4", p2, p3));
t1.join();
t2.join();
t3.join();
t4.join();
cout << "DONE"<<endl;
getchar();
cout << "FILOZOFOWIE" << endl;
Semafor eating(PHILOSOPHERS - 1);
Fork* forks[5];
thread_group philosophers;
for (int i = 0; i<PHILOSOPHERS; i++)
{
forks[i] = new Fork(i);
}
for (int i = 0; i<PHILOSOPHERS; i++)
{
philosophers.create_thread(Philosopher(i, forks[i], forks[(i + (PHILOSOPHERS -1)) % PHILOSOPHERS], eating));
}
philosophers.join_all();
cout << "DONE"<<endl;
getchar();
cout << "TASK 1" << endl;
mutex tConsoleMutex;
Task1 taskOne(tConsoleMutex,0);
Task1 taskTwo(tConsoleMutex,1);
boost::thread th1(taskOne);
boost::thread th2(taskTwo);
th1.join();
th2.join();
cout << "DONE" << endl;
getchar();
cout << "TASK 2" << endl;
boost::mutex task2Mutex;
Task2 task2DataGenerator(100);
boost::thread task2Thread(task2DataGenerator);
boost::unique_lock<mutex>task2Lock(task2Mutex);
task2DataGenerator.task2isGeneratingData->wait(task2Lock);
for (int i = 0; i < 100; i++)cout << task2Array[i] << endl;
cout << "DONE" << endl;
getchar();
cout << "TASK 3" << endl;
thread_group task3Group;
Semafor task3Semafor(1);
Semafor task3Max3ThreadsSemafor(3);
for (int i = 0; i < 10; i++) {
task3Group.create_thread(Task3(task3Max3ThreadsSemafor,task3Semafor,i));
}
task3Group.join_all();
cout << "DONE" << endl;
getchar();
cout << "SMOLKA EXAM"<<endl;
cout << "TASK 1"<<endl;
boost::mutex sConsoleMutex;
STask1 st1(sConsoleMutex);
STask1 st2(sConsoleMutex);
boost::thread sTask1Thread(st1);
boost::thread sTask1Thread2(st2);
sTask1Thread.join();
sTask1Thread2.join();
cout << "DONE" << endl;
getchar();
cout << "TASK 2" << endl;
sN = 75;
boost::thread sTask2Thread(sTask2);
boost::mutex sTask2Mutex;
boost::unique_lock<mutex>sTask2Lock(sTask2Mutex);
sTask2Condition.wait(sTask2Lock);
for (int i = 0; i < 75; i++) {
cout<< sTask2Array[i]<<endl;
}
getchar();
return 0;
}
