public class Jav0 {
    static int i=0;
    public static void main(String[] args) {
        for(int k=0;k<1000;k++) {
            new Thread() {
                public void run() {
                    for(int j=0;j<1000;j++)
                        i++;
                    System.out.println("i="+i);
                }
            }.start();
        }
    }
}

#include <stdio.h>
#include <pthread.h>

int i = 0;
void *task(void *v) {
    for(int j=0;j<1000;j++)
        i++;
    printf("i=%d\n",i);
    return 0;
}

int main() {
    for(int j=0;j<100;j++) {
        pthread_t p;
        pthread_create(&p,0,task,0);
    }
    return 0;
}

#include <thread>
#include <iostream>

int i=0;

void inc() {
  for(int j=0;j<1000;j++)
    i++;
  std::cout << "i=" << i << std::endl;
}

int main() {
  for(int j=0;j<100;j++) {
    new std::thread(inc);
  }
  return 0;
}

public class Jav1 {
    static int i=0;
    public static void main(String[] args) {
        for(int k=0;k<1000;k++) {
            Thread t = new Thread() {
                public void run() {
                    for(int j=0;j<1000;j++)
                        i++;
                    System.out.println("i="+i);
                }
            };
            t.start();
            try {
                t.join();
            } catch(InterruptedException ie) {
                return;
            }
        }
    }
}

#include <stdio.h>
#include <pthread.h>

int i = 0;
void *task(void *v) {
    for(int j=0;j<1000;j++)
        i++;
    printf("i=%d\n",i);
    return 0;
}

int main() {
    for(int j=0;j<100;j++) {
        pthread_t p;
        pthread_create(&p,0,task,0);
        pthread_join(p,0);
    }
    return 0;
}

#include <thread>
#include <iostream>

int i=0;

void inc() {
  for(int j=0;j<1000;j++)
    i++;
  std::cout << "i=" << i << std::endl;
}

int main() {
  for(int j=0;j<100;j++) {
    std::thread t(inc);
    t.join();
  }
  return 0;
}

public class Jav2 {
    static int i=0;
    public static void main(String[] args) {
        for(int k=0;k<1000;k++) {
            Thread t = new Thread() {
                public void run() {
                    for(int j=0;j<1000;j++)
                        i++;
                    System.out.println("i="+i);
                }
            };
            t.setDaemon(true);
            t.start();
        }
    }
}

#include <stdio.h>
#include <pthread.h>

int i = 0;
void *task(void *v) {
    for(int j=0;j<1000;j++)
        i++;
    printf("i=%d\n",i);
    return 0;
}

int main() {
  for(int i=0;i<100;i++) {
    pthread_t p;
    pthread_create(&p,0,task,0);
    pthread_detach(p);
  }
  return 0;
}

#include <thread>
#include <iostream>

int i=0;

void inc() {
  for(int j=0;j<1000;j++)
    i++;
  std::cout << "i=" << i << std::endl;
}

int main() {
  for(int j=0;j<100;j++) {
    std::thread t(inc);
    t.detach();
  }
  return 0;
}

#include <stdio.h>
#include <pthread.h>

int i = 0;
void *task(void *v) {
    for(int j=0;j<1000;j++)
        i++;
    printf("i=%d\n",i);
    return 0;
}

int main() {
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr,
        PTHREAD_CREATE_DETACHED);
    for(int i=0;i<100;i++) {
        pthread_t p;
        pthread_create(&p,&attr,task,0);
    }
    return 0;
}

#include <stdio.h>
#include <pthread.h>

int i = 0;
void *task(void *v) {
    for(int j=0;j<1000;j++)
        i++;
    printf("i=%d\n",i);
    return 0;
}

int main() {
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr,
      PTHREAD_CREATE_DETACHED);
    for(int i=0;i<100;i++) {
        pthread_t p;
        pthread_create(&p,&attr,task,0);
    }
    pthread_attr_destroy(&attr);
    return 0;
}

public class Jav5 {
  static int i=0;
  public static void main(String[] args) {
    Thread[] p = new Thread[100];
    for(int j=0;j<p.length;j++) {
      p[j] = new Thread() {
        public void run() {
          for(int j=0;j<1000;j++)
            i++;
          System.out.println("i="+i);
        }
      };
      p[j].start();
    }
    for(int j=0;j<p.length;j++) {
      try {
        p[j].join();
      } catch(InterruptedException ie) {
        return;
      }
    }
  }
}

#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <assert.h>
#include <bits/local_lim.h>

int i = 0;
void *task(void *v) {
    for(int j=0;j<1000;j++)
        i++;
    printf("i=%d\n",i);
    return 0;
}

int main() {
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setstacksize(&attr,PTHREAD_STACK_MIN);

    const int N = 100;
    pthread_t p[N];
    for(int i=0;i<N;i++) {
        pthread_create(&p[i],&attr,task,0);
    }
    pthread_attr_destroy(&attr);
    for(int i=0;i<N;i++) {
        pthread_join(p[i],0);
    }
    return 0;
}

#include <thread>
#include <vector>
#include <iostream>

int i=0;

void inc() {
  for(int j=0;j<1000;j++)
    i++;
  std::cout << "i=" << i << std::endl;
}

int main() {
  std::vector<std::thread> vec;
  for(int j=0;j<100;j++) {
    vec.push_back(std::thread(inc));
  }
  for(auto j=vec.begin();j != vec.end();++j) {
    j->join();
  }
  return 0;
}

public class Jav6 {
  static int i=0;
  public static void main(String[] args) {
    Thread[] p = new Thread[100];
    for(int j=0;j<p.length;j++) {
      p[j] = new Thread() {
        public void run() {
          for(int j=0;j<1000;j++)
            synchronized(Jav6.class) {
              i++;
            }
          System.out.println("i="+i);
        }
      };
      p[j].start();
    }
    for(int j=0;j<p.length;j++) {
      try {
        p[j].join();
      } catch(InterruptedException ie) {
        return;
      }
    }
  }
}

#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <assert.h>
#include <bits/local_lim.h>

pthread_mutex_t mut;
int i = 0;
void *task(void *v) {
    for(int j=0;j<1000;j++) {
        pthread_mutex_lock(&mut);
        i++;
        pthread_mutex_unlock(&mut);
    }
    printf("i=%d\n",i);
    return 0;
}

int main() {
    pthread_mutex_init(&mut,0);

    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setstacksize(&attr,PTHREAD_STACK_MIN);

    const int N = 100;
    pthread_t p[N];
    for(int i=0;i<N;i++) {
        pthread_create(&p[i],&attr,task,0);
    }
    pthread_attr_destroy(&attr);
    for(int i=0;i<N;i++) {
        pthread_join(p[i],0);
    }
    return 0;
}

#include <thread>
#include <vector>
#include <iostream>
#include <mutex>

int i=0;

std::mutex m;

void inc() {
  for(int j=0;j<1000;j++) {
    m.lock();
    i++;
    m.unlock();
  }
  std::cout << "i=" << i << std::endl;
}

int main() {
  std::vector<std::thread> vec;
  for(int j=0;j<100;j++) {
    vec.push_back(std::thread(inc));
  }
  for(auto j=vec.begin();j != vec.end();++j) {
    j->join();
  }
  return 0;
}

public class Jav7 {
  static int i=0;
  public static void main(String[] args) {
    Thread[] p = new Thread[100];
    for(int j=0;j<p.length;j++) {
      p[j] = new Thread() {
        public void run() {
          for(int j=0;j<1000;j++)
            synchronized(Jav7.class) {
              i++;
            }
          System.out.println("i="+i);
        }
      };
      p[j].start();
    }
    for(int j=0;j<p.length;j++) {
      try {
        p[j].join();
      } catch(InterruptedException ie) {
        return;
      }
    }
    System.out.println("AT FINISH: "+i);
  }
}

#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <assert.h>
#include <bits/local_lim.h>

pthread_mutex_t mut;
int i = 0;
void *task(void *v) {
    for(int j=0;j<1000;j++) {
        pthread_mutex_lock(&mut);
        i++;
        pthread_mutex_unlock(&mut);
    }
    printf("i=%d\n",i);
    return 0;
}

int main() {
    pthread_mutex_init(&mut,0);

    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setstacksize(&attr,PTHREAD_STACK_MIN);

    const int N = 100;
    pthread_t p[N];
    for(int i=0;i<N;i++) {
        pthread_create(&p[i],&attr,task,0);
    }
    pthread_attr_destroy(&attr);
    for(int i=0;i<N;i++) {
        pthread_join(p[i],0);
    }
    printf("AT FINISH: %d\n",i);
    return 0;
}

#include <thread>
#include <vector>
#include <iostream>
#include <mutex>

int i=0;

std::mutex m;

void inc() {
  for(int j=0;j<1000;j++) {
    std::lock_guard<std::mutex> lg(m);
    i++;
  }
  std::cout << "i=" << i << std::endl;
}

int main() {
  std::vector<std::thread> vec;
  for(int j=0;j<100;j++) {
    vec.push_back(std::thread(inc));
  }
  for(auto j=vec.begin();j != vec.end();++j) {
    j->join();
  }
  std::cout << "AT FINISH: " << i << std::endl;
  return 0;
}

public class Jav8 {
    static int i=0;
    static final int THREADS = 100;
    static final int INCRS_PER_THREAD = 1000;
    public static void main(String[] args) {
        Thread fin = new Thread() {
            public void run() {
                synchronized(Jav8.class) {
                    while(i < THREADS*INCRS_PER_THREAD) {
                        try {
                            Jav8.class.wait();
                        } catch(InterruptedException ie) {
                            return;
                        }
                    }
                }
                System.out.println("AT FINISH: "+i);
            }
        };
        fin.start();
        Thread[] p = new Thread[THREADS];
        for(int j=0;j<p.length;j++) {
            p[j] = new Thread() {
                public void run() {
                    synchronized(Jav8.class) {
                        for(int j=0;j<INCRS_PER_THREAD;j++)
                            i++;
                        Jav8.class.notify();
                        System.out.println("i="+i);
                    }
                }
            };
            p[j].start();
        }
        for(int j=0;j<p.length;j++) {
            try {
                p[j].join();
            } catch(InterruptedException ie) {
                return;
            }
        }
        try {
            fin.join();
        } catch(InterruptedException ie) {
            return;
        }
    }
}

#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <assert.h>
#include <bits/local_lim.h>

pthread_mutex_t mut;
pthread_cond_t cond;
int i = 0;
void *task(void *v) {
    pthread_mutex_lock(&mut);
    for(int j=0;j<1000;j++)
        i++;
    pthread_cond_broadcast(&cond);
    pthread_mutex_unlock(&mut);
    printf("i=%d\n",i);
    return 0;
}

void *fin_task(void *v) {
    pthread_mutex_lock(&mut);
    while(i < 100000)
        pthread_cond_wait(&cond,&mut);
    pthread_mutex_unlock(&mut);
    printf("AT FINISH: %d\n",i);
}

int main() {
    pthread_mutex_init(&mut,0);
    pthread_cond_init(&cond,0);

    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setstacksize(&attr,PTHREAD_STACK_MIN);

    pthread_t fin;
    pthread_create(&fin,&attr,fin_task,0);

    const int N = 100;
    pthread_t p[N];
    for(int i=0;i<N;i++) {
        pthread_create(&p[i],&attr,task,0);
    }
    pthread_attr_destroy(&attr);
    for(int i=0;i<N;i++) {
        pthread_join(p[i],0);
    }
    pthread_join(fin,0);
    return 0;
}

#include <thread>
#include <vector>
#include <iostream>
#include <mutex>
#include <condition_variable>

int i=0;

std::mutex m;
std::condition_variable cv;
const int N = 100;
const int N_INC = 1000;

void inc() {
  {
    std::lock_guard<std::mutex> lg(m);
    for(int j=0;j<N_INC;j++) {
      i++;
    }
    std::cout << "i=" << i << std::endl;
  }
  // after unlock
  cv.notify_all();
}

void fin() {
  std::unique_lock<std::mutex> ul(m);
  cv.wait(ul,[](){ return i==N*N_INC; });
}

int main() {
  std::thread f(fin);
  std::vector<std::thread> vec;
  for(int j=0;j<N;j++) {
    vec.push_back(std::thread(inc));
  }
  for(auto j=vec.begin();j != vec.end();++j) {
    j->join();
  }
  f.join();
  std::cout << "AT FINISH: " << i << std::endl;
  return 0;
}

public class Jav9 {
    static int i=0;
    static final int THREADS = 100;
    static final int INCRS_PER_THREAD = 1000;
    public static void main(String[] args) {
        Thread fin = new Thread() {
            public void run() {
                synchronized(Jav9.class) {
                    while(i < THREADS*INCRS_PER_THREAD) {
                        try {
                            Jav9.class.wait();
                        } catch(InterruptedException ie) {
                            return;
                        }
                    }
                }
                System.out.println("AT FINISH: "+i);
            }
        };
        fin.start();
        Thread[] p = new Thread[THREADS];
        for(int j=0;j<p.length;j++) {
            p[j] = new Thread() {
              public void run() {
                for(int j=0;j<INCRS_PER_THREAD;j++) {
                  synchronized(Jav9.class) {
                    i++;
                    if(i==THREADS*INCRS_PER_THREAD)
                      Jav9.class.notify();
                  }
                  System.out.println("i="+i);
                }
              }
            };
            p[j].start();
        }
        try {
            fin.join();
        } catch(InterruptedException ie) {
            return;
        }
    }
}

#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <assert.h>
#include <bits/local_lim.h>

pthread_mutex_t mut;
pthread_cond_t cond;
int i = 0;
const int N = 100;
const int N_INC = 1000;
void *task(void *v) {
    pthread_mutex_lock(&mut);
    for(int j=0;j<N_INC;j++)
        i++;
    if(i==N*N_INC)
        pthread_cond_broadcast(&cond);
    pthread_mutex_unlock(&mut);
    printf("i=%d\n",i);
    return 0;
}

void *fin_task(void *v) {
    pthread_mutex_lock(&mut);
    while(i < N*N_INC)
        pthread_cond_wait(&cond,&mut);
    pthread_mutex_unlock(&mut);
    printf("AT FINISH: %d\n",i);
}

int main() {
    pthread_mutex_init(&mut,0);
    pthread_cond_init(&cond,0);

    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setstacksize(&attr,PTHREAD_STACK_MIN);

    pthread_t fin;
    pthread_create(&fin,&attr,fin_task,0);

    pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
    for(int i=0;i<N;i++) {
        pthread_t p;
        pthread_create(&p,&attr,task,0);
    }
    pthread_attr_destroy(&attr);
    pthread_join(fin,0);
    return 0;
}

#include <thread>
#include <iostream>
#include <mutex>
#include <condition_variable>

int i=0;

std::mutex m;
std::condition_variable cv;

const int N = 100;
const int N_INC = 1000;

void inc() {
  {
    std::lock_guard<std::mutex> lg(m);
    for(int j=0;j<N_INC;j++) {
      i++;
    }
    std::cout << "i=" << i << std::endl;
  }
  // after unlock
  cv.notify_all();
}

void fin() {
  std::unique_lock<std::mutex> ul(m);
  cv.wait(ul,[](){ return i==N_INC*N; });
}

int main() {
  std::thread f(fin);
  for(int j=0;j<N;j++) {
    std::thread t(inc);
    t.detach();
  }
  f.join();
  std::cout << "AT FINISH: " << i << std::endl;
  return 0;
}