#pragma warning(disable:4996)

#include <iostream>

#include <functional>
#include <thread>

#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;

void func1() {


  for (size_t i = 0; i < 10;i++) {
    _sleep(10);
    printf("func1 # %d\n", i);

    if (i == 5) {
      printf("*** func1 から通知を送る *** \n");
      cv.notify_all();
    }
  }

}

void func2() {

  printf("待機開始\n");
  std::unique_lock<std::mutex> ul(mtx);
  cv.wait(ul);
  printf("通知が来たので func2 スレッド再開\n");

  for (size_t i = 0; i < 10; i++) {
    _sleep(10);
    printf("func2 : %d\n", i);
  }
  
}

int main()
{

  std::thread th1(func1);
  std::thread th2(func2);

  th1.join();
  th2.join();

  std::cout << "Hello World!\n";
}

#pragma warning(disable:4996)

#include <iostream>

#include <functional>
#include <thread>

#include <mutex>
#include <condition_variable>

bool notify = false; // Spurious Wakeup考慮　ステート変数
std::mutex mtx;
std::condition_variable cv;

void func1() {


  for (size_t i = 0; i < 10;i++) {
    _sleep(10);
    printf("func1 # %d\n", i);

    if (i == 5) {
      printf("*** func1 から通知を送る *** \n");
      notify = true;// notify_allするときにしかnotifyがtrueになることはない
      cv.notify_all();
    }
  }

}


void func2() {

  printf("待機開始\n");

  std::unique_lock<std::mutex> ul(mtx);
  cv.wait(ul, [&]{return notify; });// notifyがtrueの時だけ待機解除

  printf("通知が来たので func2 スレッド再開\n");

  for (size_t i = 0; i < 10; i++) {
    _sleep(10);
    printf("func2 : %d\n", i);
  }
  
}


int main()
{

  std::thread th1(func1);
  std::thread th2(func2);

  th1.join();
  th2.join();

  std::cout << "Hello World!\n";
}

#pragma warning(disable:4996)

#include <iostream>

// https://cutlassfish.wordpress.com/2016/09/14/c-%E3%81%A7-worker-thread-%E3%83%91%E3%82%BF%E3%83%BC%E3%83%B3/
#include "WorkerThread.hpp"

class Work1 : public Runnable {

  const char* _name;
  const int _count;
public:
  Work1(const char* name,int count):
    _name(name),_count(count)
  {}
  virtual void run() override {
    for (int i = 0; i < 10; i++) {
      _sleep(_count);
      printf("%s == %d\n",_name, i);
    }
  }

};

int main()
{
  int thread_count = 5;// 同時に走るスレッドの数
  int queue_count = 5;// 積んでおける仕事の数

  ThreadPool pool(thread_count,queue_count);

  pool.add(std::make_shared<Work1>("h",20));
  pool.add(std::make_shared<Work1>("i",25));
  pool.add(std::make_shared<Work1>("o",30));
  pool.add(std::make_shared<Work1>("k",35));


  _sleep(5000);
  std::cout << "End of main\n";
}

int main()
{

  int thread_count = 2;
  int queue_count = 5;

  ThreadPool pool(thread_count,queue_count);

  pool.add(std::make_shared<Work1>("h",20));
  pool.add(std::make_shared<Work1>("i",25));
  pool.add(std::make_shared<Work1>("o",30));
  pool.add(std::make_shared<Work1>("k",35));


  _sleep(5000);
  std::cout << "End of main\n";
}

  int thread_count = 5;
  int queue_count = 2;

#pragma once

#include <vector>


struct Image {
  std::vector<unsigned char> img;
  int width;
  int height;
};
void resize(Image* img, int w, int h) {
  img->width = w;
  img->height = h;
  img->img.resize(w * h);
}

//! @brief 画像のピクセルを着色する
//! @param [in,out] img 画像
//! @param [in] x 座標
//! @param [in] y 座標
//! @return なし
void plot(Image& img, int x, int y) {
  img.img[y * img.width + x] = 255;
}


enum class CPOS {
  left, right, top, bottom
};

//! @brief 円の指定した1/4を描画する
//! @param [out] img 画像
//! @param [in] cx 中心座標
//! @param [in] cy 中心座標
//! @param [in] r  半径
//! @param [in] bx 円の四分割したエリアの指定
//! @param [in] by 円の四分割したエリアの指定
//! @return なし
void arc4(Image& img, const int cx, const int cy, const int r, const CPOS bx, const CPOS by) {
  int x, y;//描画位置
  const int rr = r * r;//半径の二乗
  int dx, dy;
  int limx;
  int limy;

  if (bx == CPOS::right && by == CPOS::bottom) {
    // □□
    // □■
    //初期位置
    x = r;
    y = 0;
    dx = -1;
    dy = +1;
    limx = 0;
    limy = r;
  }
  else if (bx == CPOS::left && by == CPOS::bottom) {
    // □□
    // ■□
    x = 0;
    y = r;
    dx = -1;
    dy = -1;
    limx = -r;
    limy = 0;
  }
  else if (bx == CPOS::left && by == CPOS::top) {
    // ■□
    // □□
    x = -r;
    y = 0;
    dx = +1;
    dy = -1;
    limx = 0;
    limy = -r;
  }
  else if (bx == CPOS::right && by == CPOS::top) {
    // □■
    // □□
    x = 0;
    y = -r;
    dx = +1;
    dy = +1;
    limx = r;
    limy = 0;
  }

  //最初の一点
  //plot(img,x + cx, y + cy);

  while ((x != limx) || (y != limy)) {

    /////////////////////////
    // 次に描画するポイントを決定

    //次に描画するのは以下のいずれか。
    int xy1 = pow(x + dx, 2) + pow(y, 2);
    int xy2 = pow(x + dx, 2) + pow(y + dy, 2);
    int xy3 = pow(x, 2) + pow(y + dy, 2);

    // x*x + y*y == r*rなので
    // 上記各xyのうち最もr*rとの差が少ないx*x+y*yを選択
    xy1 = abs(xy1 - rr);
    xy2 = abs(xy2 - rr);
    xy3 = abs(xy3 - rr);

    if (xy1 < xy2) {
      if (xy1 < xy3) {
        // xy1
        x = x + dx;
        y = y;
      }
      else {
        // xy2
        x = x + dx;
        y = y + dy;
      }
    }
    else {
      if (xy2 < xy3) {
        // xy2
        x = x + dx;
        y = y + dy;
      }
      else {
        // xy3
        x = x;
        y = y + dy;
      }
    }

    /////////////////////////
    // 描画
    if (
      (img, x + cx < 0) ||
      (img, x + cx >= img.width) ||
      (img, y + cy < 0) ||
      (img, y + cy >= img.height)
      ) {
      continue;
    }
    plot(img, x + cx, y + cy);


  }

}

//! @brief ブレゼンハムの直線描画
//! @param [out] img 画像データ（一次元配列）へのポインタ
//! @param [in] width 画像の幅（画素数）
//! @param [in] height 画像の高さ（画素数）
//! @param [in] sx 線の始点X
//! @param [in] sy 線の始点Y
//! @param [in] ex 線の終点X
//! @param [in] ey 線の終点Y
//! @param [in] color 線の色
void Bresenham(
  Image& img,
  const int sx,
  const int sy,
  const int ex,
  const int ey
) {
  // https://ja.wikipedia.org/wiki/%E3%83%96%E3%83%AC%E3%82%BC%E3%83%B3%E3%83%8F%E3%83%A0%E3%81%AE%E3%82%A2%E3%83%AB%E3%82%B4%E3%83%AA%E3%82%BA%E3%83%A0

  const int dx = std::abs(ex - sx);
  const int dy = std::abs(ey - sy);

  const int nx = (sx < ex) ? 1 : -1;
  const int ny = (sy < ey) ? 1 : -1;

  int err = dx - dy;

  int x = sx;
  int y = sy;
  while (1) {

    plot(img, x, y);

    if (x == ex && y == ey)
      break;

    const int e2 = 2 * err;
    if (e2 > -dy) {
      err = err - dy;
      x += nx;
    }
    if (e2 < dx) {
      err = err + dx;
      y += ny;
    }
  }
}