#include <iostream>
#include <semaphore.h>
#include <thread>
#include <chrono>

sem_t sem;

void task(const char* name, int waitSeconds) {
    std::this_thread::sleep_for(std::chrono::seconds(waitSeconds));
    sem_wait(&sem); // 尝试获取信号量
    std::cout << "Task " << name << " is running.\n";
    std::this_thread::sleep_for(std::chrono::seconds(1));
    sem_post(&sem); // 释放信号量
}

int main() {
    sem_init(&sem, 0, 2); // 初始化信号量，初始值为2

    std::thread t1(task, "A", 1);
    std::thread t2(task, "B", 2);
    std::thread t3(task, "C", 3);

    t1.join();
    t2.join();
    t3.join();

    sem_destroy(&sem); // 销毁信号量

    return 0;
}

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

#define NUM_THREADS 5
#define ITERATIONS 100000

int counter = 0;
pthread_mutex_t mutex;

void* increment_counter(void* arg) {
    for (int i = 0; i < ITERATIONS; ++i) {
        pthread_mutex_lock(&mutex); // 加锁
        ++counter;
        pthread_mutex_unlock(&mutex); // 解锁
    }
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];
    
    // 初始化互斥锁
    if (pthread_mutex_init(&mutex, NULL) != 0) {
        printf("Mutex init failed\n");
        return 1;
    }

    // 创建多个线程
    for (int i = 0; i < NUM_THREADS; ++i) {
        if (pthread_create(&threads[i], NULL, increment_counter, NULL) != 0) {
            printf("Thread creation failed\n");
            return 1;
        }
    }

    // 等待所有线程完成
    for (int i = 0; i < NUM_THREADS; ++i) {
        pthread_join(threads[i], NULL);
    }

    // 销毁互斥锁
    pthread_mutex_destroy(&mutex);

    printf("Final counter value: %d\n", counter);
    return 0;
}

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

#define BUFFER_SIZE 10

int buffer[BUFFER_SIZE];
int fill_ptr = 0;
int use_ptr = 0;
int count = 0;

pthread_mutex_t mutex;
pthread_cond_t cond_var;

void put(int value) {
    buffer[fill_ptr] = value;
    fill_ptr = (fill_ptr + 1) % BUFFER_SIZE;
    count++;
}

int get() {
    int tmp = buffer[use_ptr];
    use_ptr = (use_ptr + 1) % BUFFER_SIZE;
    count--;
    return tmp;
}

void* producer(void* arg) {
    int item;
    while (1) {
        item = rand() % 100; // 生产随机数
        pthread_mutex_lock(&mutex);
        while (count == BUFFER_SIZE) {
            pthread_cond_wait(&cond_var, &mutex); // 缓冲区满，等待
        }
        put(item);
        pthread_cond_signal(&cond_var); // 通知消费者
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

void* consumer(void* arg) {
    int item;
    while (1) {
        pthread_mutex_lock(&mutex);
        while (count == 0) {
            pthread_cond_wait(&cond_var, &mutex); // 缓冲区空，等待
        }
        item = get();
        pthread_cond_signal(&cond_var); // 通知生产者
        pthread_mutex_unlock(&mutex);
        printf("Consumed: %d\n", item);
    }
    return NULL;
}

int main() {
    pthread_t prod_thread, cons_thread;

    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond_var, NULL);

    pthread_create(&prod_thread, NULL, producer, NULL);
    pthread_create(&cons_thread, NULL, consumer, NULL);

    pthread_join(prod_thread, NULL);
    pthread_join(cons_thread, NULL);

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond_var);

    return 0;
}

#include <iostream>
#include <sys/select.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <cstring>
#include <vector>

class EventHandler {
public:
    virtual ~EventHandler() = default;
    virtual void handle_event(int fd) = 0;
};

class Reactor {
private:
    fd_set read_fds; // 监听的文件描述符集合
    int max_fd;      // 最大文件描述符
    std::vector<EventHandler*> handlers;

public:
    Reactor() : max_fd(0) {
        FD_ZERO(&read_fds);
    }

    void register_handler(int fd, EventHandler* handler) {
        FD_SET(fd, &read_fds);
        if (fd > max_fd) {
            max_fd = fd;
        }
        handlers.push_back(handler);
    }

    void run_event_loop() {
        while (true) {
            fd_set tmp_fds = read_fds;
            int ret = select(max_fd + 1, &tmp_fds, nullptr, nullptr, nullptr);
            if (ret < 0) {
                std::cerr << "Select error!" << std::endl;
                break;
            }

            for (int i = 0; i <= max_fd; ++i) {
                if (FD_ISSET(i, &tmp_fds)) {
                    for (auto handler : handlers) {
                        handler->handle_event(i);
                    }
                }
            }
        }
    }
};

class ReadHandler : public EventHandler {
public:
    void handle_event(int fd) override {
        char buffer[1024];
        int bytes = read(fd, buffer, sizeof(buffer) - 1);
        if (bytes > 0) {
            buffer[bytes] = '\0';
            std::cout << "Received: " << buffer << std::endl;
        } else {
            std::cerr << "Client disconnected." << std::endl;
            close(fd);
        }
    }
};

int main() {
    // 创建服务器套接字
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    sockaddr_in server_addr{};
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = INADDR_ANY;

    bind(server_fd, reinterpret_cast<sockaddr*>(&server_addr), sizeof(server_addr));
    listen(server_fd, 5);

    Reactor reactor;
    ReadHandler read_handler;

    // 注册服务器套接字
    reactor.register_handler(server_fd, &read_handler);

    // 运行事件循环
    reactor.run_event_loop();

    return 0;
}

#include <iostream>
#include <aio.h>
#include <fcntl.h>
#include <unistd.h>
#include <cstring>
#include <vector>

class Proactor {
private:
    std::vector<aiocb*> aio_controls; // 异步 I/O 控制块

public:
    ~Proactor() {
        for (auto cb : aio_controls) {
            delete cb;
        }
    }

    void start_read(int fd) {
        aiocb* cb = new aiocb();
        memset(cb, 0, sizeof(aiocb));

        char buffer[1024];
        cb->aio_fildes = fd;
        cb->aio_buf = buffer;
        cb->aio_nbytes = sizeof(buffer) - 1;
        cb->aio_offset = 0;

        aio_controls.push_back(cb);

        if (aio_read(cb) < 0) {
            std::cerr << "Error starting async read." << std::endl;
            return;
        }

        std::cout << "Async read started on fd: " << fd << std::endl;
    }

    void wait_for_completion() {
        for (auto cb : aio_controls) {
            while (aio_error(cb) == EINPROGRESS) {
                usleep(1000); // 等待操作完成
            }

            ssize_t bytes = aio_return(cb);
            if (bytes > 0) {
                std::cout << "Async read completed. Data: "
                          << static_cast<char*>(cb->aio_buf) << std::endl;
            } else {
                std::cerr << "Async read failed." << std::endl;
            }
        }
    }
};

int main() {
    // 打开一个文件进行异步读取
    int fd = open("test.txt", O_RDONLY);
    if (fd < 0) {
        std::cerr << "Failed to open file." << std::endl;
        return -1;
    }

    Proactor proactor;
    proactor.start_read(fd); // 开始异步读取
    proactor.wait_for_completion(); // 等待完成

    close(fd);
    return 0;
}

#include <sys/select.h>
int select(int nfds, fd_set *readfds, fd_set *writefds,
          fd_set *exceptfds, struct timeval *timeout);

/* fd_set for select and pselect.  */
typedef struct
  {
    /* XPG4.2 requires this member name.  Otherwise avoid the name
       from the global namespace.  */
#ifdef __USE_XOPEN
    // __FD_SETSIZE = 1024 表示fd_set是个包含一个1024bit数组的结构体
    __fd_mask fds_bits[__FD_SETSIZE / __NFDBITS];
# define __FDS_BITS(set) ((set)->fds_bits)
#else
    __fd_mask __fds_bits[__FD_SETSIZE / __NFDBITS];
# define __FDS_BITS(set) ((set)->__fds_bits)
#endif
  } fd_set;

fd_set read_fds, active_fds;
 int max_fd = sockfd;
 std::vector<unsigned int> clients_fd;
 FD_ZERO(&read_fds);
 FD_SET(sockfd, &read_fds);
 while (true) {
   // 轮询select 直到有连接
   timeval timeout{1, 0};
   read_fds = active_fds;
   // select阻塞,直到相应文件描述符就绪(可读,可写或异常)
   // 成功返回时(>=1),fd_set内容更新,仅保留就绪的fd
   int ret = select(max_fd + 1, &read_fds, nullptr, nullptr, &timeout);
   errif(ret < 0, "select failed");

   if (FD_ISSET(sockfd, &read_fds)) {
     // 服务器可读(有connect连接)
     sockaddr_in client_addr;
     socklen_t client_addr_len = sizeof(client_addr);
     bzero(&client_addr, client_addr_len);
     int client_sockfd =
         accept(sockfd, (struct sockaddr *)&client_addr, &client_addr_len);
     FD_SET(client_sockfd, &active_fds);
     max_fd = std::max(client_sockfd, max_fd);
     clients_fd.push_back(client_sockfd);

     std::cout << "New connection, socket fd: " << client_sockfd
               << ", IP: " << inet_ntoa(client_addr.sin_addr)
               << ", Port: " << ntohs(client_addr.sin_port) << std::endl;
   }
   for (auto it = clients_fd.begin(); it != clients_fd.end();) {
     unsigned int client_fd = *it;
     if (FD_ISSET(client_fd, &read_fds)) {
       //客户端可读数据
       // 读取数据
       char read_bytes[1024]{};
       size_t bytes_len = read(client_fd, read_bytes, sizeof(read_bytes));
       if (bytes_len <= 0) {
         std::cout << "client closed...\n";
         close(client_fd);
         FD_CLR(client_fd, &active_fds);
         it = clients_fd.erase(it);
         continue;
       } else {
         std::string resp =
             "你好,你发送了" + std::string(read_bytes, bytes_len);
         errif(write(client_fd, resp.c_str(), resp.size()) == -1,
               "write socket failed");
         ++it;
       }
     } else {
       ++it;
     }
   }
 }
 for (auto &client_fd : clients_fd) {
   // 关闭所有客户端
   close(client_fd);
 }
 // close 关闭服务端
 close(sockfd);

#include <poll.h>

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

/* Data structure describing a polling request.  */
struct pollfd
  {
    int fd;			/* File descriptor to poll.  */
    short int events;		/* Types of events poller cares about.  */
    short int revents;		/* Types of events that actually occurred.  */
  };

/* Event types that can be polled for.  These bits may be set in `events'
   to indicate the interesting event types; they will appear in `revents'
   to indicate the status of the file descriptor.  */
#define POLLIN		0x001		/* There is data to read.  */
#define POLLPRI		0x002		/* There is urgent data to read.  */
#define POLLOUT		0x004		/* Writing now will not block.  */

/* Event types always implicitly polled for.  These bits need not be set in
   `events', but they will appear in `revents' to indicate the status of
   the file descriptor.  */
#define POLLERR		0x008		/* Error condition.  */
#define POLLHUP		0x010		/* Hung up.  */
#define POLLNVAL	0x020		/* Invalid polling request.  */

std::vector<pollfd> poll_fds;
pollfd server_pollfd;
server_pollfd.fd = sockfd;
server_pollfd.events = POLLIN; // 设置事件
poll_fds.push_back(server_pollfd);
while (true) {
  int ret = poll(poll_fds.data(), poll_fds.size(), -1);
  errif(ret < 0, "poll error");
  if (poll_fds.at(0).revents & POLLIN) {
    // 数据读入事件
    // serverfd可读,即可accept
    sockaddr_in client_addr{};
    socklen_t addr_len = sizeof(client_addr);
    int client_fd = accept(sockfd, (struct sockaddr *)&client_addr,
                           (socklen_t *)&addr_len);
    errif(client_fd == -1, "accept failed");

    pollfd client_pollfd;
    client_pollfd.fd = client_fd;
    client_pollfd.events = POLLIN;
    poll_fds.push_back(client_pollfd);
    std::cout << "New connection, socket fd: " << client_fd
              << ", IP: " << inet_ntoa(client_addr.sin_addr)
              << ", Port: " << ntohs(client_addr.sin_port) << std::endl;
  }
  for (auto it = poll_fds.begin() + 1; it != poll_fds.end();) {
    char bytes_read[1024]{};
    pollfd &client_pollfd = *it;
    size_t read_bytes_len =
        read(client_pollfd.fd, bytes_read, sizeof(bytes_read));
    if (read_bytes_len <= 0) {
      // 关闭
      std::cout << "client closed...\n";
      close(client_pollfd.fd);
      it = poll_fds.erase(it);
    } else {
      // echo
      std::string resp =
          "你好,你的请求是" + std::string(bytes_read, read_bytes_len);
      write(client_pollfd.fd, resp.data(), resp.size());
      ++it;
    }
  }
}
  // 关闭所有客户端连接
  for (const auto &pfd : poll_fds) {
      close(pfd.fd);
  }

#include <sys/epoll.h>

// 创建epoll实例
/* Creates an epoll instance.  Returns an fd for the new instance.
   The "size" parameter is a hint specifying the number of file
   descriptors to be associated with the new instance.  The fd
   returned by epoll_create() should be closed with close().  */
int epoll_create(int size);

/* Same as epoll_create but with an FLAGS parameter.  The unused SIZE
   parameter has been dropped.  */
int epoll_create1(int flags);
// 控制epoll实例
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

// 等待事件
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

struct epoll_event
{
  uint32_t events;	/* Epoll events */
  epoll_data_t data;	/* User data variable */
} __EPOLL_PACKED;

typedef union epoll_data
{
  void *ptr;
  int fd;
  uint32_t u32;
  uint64_t u64;
} epoll_data_t;

int epoll_fd = epoll_create1(0);
 errif(epoll_fd == -1, "epoll creation failed");
 const int MAX_EVENTS = 10;
 epoll_event ev, events[MAX_EVENTS];
 ev.events = POLLIN | EPOLLET; // 水平触发模式
 ev.data.fd = sockfd;
 // 添加服务端fd
 ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sockfd, &ev);
 errif(ret == -1, "ctl failed");
 while (true) {
   // 等待事件
   int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
   errif(nfds == -1, "epoll waut failed");
   if ((events[0].data.fd == sockfd) && (events[0].events & POLLIN)) {
     // accept就绪
     sockaddr_in client_addr;
     socklen_t client_addr_len = sizeof(client_addr);
     int client_fd =
         accept(sockfd, (struct sockaddr *)&client_addr, &client_addr_len);
     epoll_event ev;
     ev.events = EPOLLIN | EPOLLET; // 水平触发模式
     ev.data.fd = client_fd;
     // 将客户端连接加入epoll实例
     ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &ev);
     errif(ret == -1, "ctl failed");
   }

   for (int i = 1; i < MAX_EVENTS; i++) {
     if (events[i].events & POLLIN) {
       int client_fd = events[i].data.fd;
       // read就绪
       char bytes_read[1024]{};
       size_t bytes_read_len = read(client_fd, bytes_read, sizeof(bytes_read));
       if (bytes_read_len <= 0) {
         std::cout << "client connection closed...\n";
         close(client_fd);
         epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, nullptr);
       } else {
         std::string resp =
             "你好,你发送了:" + std::string(bytes_read, bytes_read_len);
         write(client_fd, resp.data(), resp.size());
       }
     }
   }
     close(epoll_fd);