埃菲尔铁塔_CV算法

线程池代码分析及延申应用（续二）

代码延申应用

8. 线程池与分布式系统的结合

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

class MthreadPool {
public:
    MthreadPool(int min, int max) : minthread(min), maxthread(max),
        stopthread(false), idlethread(min), currentthread(min),
        startTime(std::chrono::steady_clock::now())
    {
        manager = new std::thread(&MthreadPool::Manager, this);
        counttask = 0;
        addcount = 0;
        totalTaskTime = std::chrono::milliseconds(0);
        taskQueues.resize(max);
        taskQueueConditions.resize(max);
        for (int i = 0; i < max; i++)
        {
            std::thread t(&MthreadPool::Worker, this, i);
            workers.insert(std::make_pair(t.get_id(), std::move(t)));
        }
    }

    ~MthreadPool()
    {
        stopthread = true;
        for (auto& cond : taskQueueConditions) {
            cond.notify_all();
        }
        for (auto& it : workers)
        {
            if (it.second.joinable())
            {
                it.second.join();
            }
        }
        if (manager->joinable())
        {
            manager->join();
        }
        delete manager;
        auto endTime = std::chrono::steady_clock::now();
        activeTime = std::chrono::duration_cast(endTime - startTime);
        logStatistics();
    }

    template
    auto AddTask(F&& f, Args&&... args) 
        -> std::future::type> {
        using return_type = typename std::result_of::type;

        auto task = std::make_shared< std::packaged_task >(
            std::bind(std::forward(f), std::forward(args)...)
        );
        
        std::future res = task->get_future();
        {
            std::lock_guard lock(queueMutex);
            if (stopthread)
                throw std::runtime_error("enqueue on stopped ThreadPool");
            int queueIndex = nextQueueIndex++;
            queueIndex %= maxthread;
            taskQueues[queueIndex].emplace([task]() { (*task)(); });
            addcount++;
        }
        taskQueueConditions[queueIndex].notify_one();
        return res;
    }

    void logStatistics() {
        std::ofstream logFile("thread_pool_stats.log", std::ios::app);
        if (logFile.is_open()) {
            logFile << "Active Time: " << activeTime.count() << " ms" << std::endl;
            logFile << "Total Tasks Added: " << addcount.load() << std::endl;
            logFile << "Total Tasks Completed: " << counttask.load() << std::endl;
            if (counttask.load() > 0) {
                auto avgTaskTime = totalTaskTime.load() / counttask.load();
                logFile << "Average Task Execution Time: " << avgTaskTime.count() << " ms" << std::endl;
            }
            logFile.close();
        }
    }

private:
    int minthread;
    int maxthread;
    std::atomic stopthread;
    std::atomic idlethread;
    std::atomic currentthread;
    std::atomic exithread{ 0 };
    std::atomic counttask;
    std::atomic addcount;
    std::map workers;
    std::thread* manager;
    std::vector>> taskQueues;
    std::mutex queueMutex;
    std::mutex exitidMutex;
    std::vector taskQueueConditions;
    std::atomic nextQueueIndex{0};
    std::vector exit_id;
    std::atomic totalQueueSize{0};
    std::atomic totalTaskTime;
    std::chrono::time_point startTime;
    std::chrono::milliseconds activeTime;

    void Manager(void)
    {
        while (!stopthread.load())
        {
            std::this_thread::sleep_for(std::chrono::seconds(3));
            int idle = idlethread.load();
            int cur = currentthread.load();
            int totalSize = 0;
            {
                std::lock_guard lock(queueMutex);
                for (const auto& queue : taskQueues) {
                    totalSize += queue.size();
                }
                totalQueueSize = totalSize;
            }

            if (idle > cur / 2 && cur > minthread && totalSize < cur / 2)
            {
                exithread.store(2);
                for (auto& cond : taskQueueConditions) {
                    cond.notify_all();
                }
                std::lock_guard lock(exitidMutex);
                for (auto id : exit_id)
                {
                    auto thread = workers.find(id);
                    if (thread != workers.end())
                    {
                        (*thread).second.join();
                        workers.erase(thread);
                    }
                }
                exit_id.clear();
            }
            else if (idle == 0 && cur < maxthread && totalSize > cur * 2)
            {
                std::thread t(&MthreadPool::Worker, this, currentthread);
                workers.insert(std::make_pair(t.get_id(), std::move(t)));
                currentthread++;
                idlethread++;
            }
        }
    }

    void Worker(int queueIndex) {
        while (!stopthread.load()) {
            std::function task;
            {
                std::unique_lock lock(queueMutex);
                taskQueueConditions[queueIndex].wait(lock, [this, queueIndex] {
                    return stopthread || !taskQueues[queueIndex].empty();
                });
                if (stopthread && taskQueues[queueIndex].empty())
                    return;
                if (exithread.load() > 0) {
                    currentthread--;
                    exithread--;
                    idlethread--;
                    std::lock_guard lock(exitidMutex);
                    exit_id.emplace_back(std::this_thread::get_id());
                    return;
                }
                task = std::move(taskQueues[queueIndex].front());
                taskQueues[queueIndex].pop();
                totalQueueSize--;
            }
            idlethread--;
            auto taskStartTime = std::chrono::steady_clock::now();
            try {
                task();
                counttask++;
            } catch (const std::exception& e) {
                std::cerr << "Exception caught in worker thread: " << e.what() << std::endl;
            }
            auto taskEndTime = std::chrono::steady_clock::now();
            auto taskDuration = std::chrono::duration_cast(taskEndTime - taskStartTime);
            totalTaskTime += taskDuration;
            idlethread++;
        }
    }
};

// 分布式任务处理类
class DistributedTaskHandler {
public:
    DistributedTaskHandler(MthreadPool& pool, short port) : pool(pool), acceptor(io_context, asio::ip::tcp::endpoint(asio::ip::tcp::v4(), port)), socket(io_context) {
        startAccept();
    }

    void run() {
        io_context.run();
    }

private:
    MthreadPool& pool;
    asio::io_context io_context;
    asio::ip::tcp::acceptor acceptor;
    asio::ip::tcp::socket socket;

    void startAccept() {
        acceptor.async_accept(socket, [this](std::error_code ec) {
            if (!ec) {
                handleRequest();
            }
            startAccept();
        });
    }

    void handleRequest() {
        asio::streambuf buffer;
        asio::async_read_until(socket, buffer, '\n', [this, &buffer](std::error_code ec, std::size_t length) {
            if (!ec) {
                std::istream is(&buffer);
                std::string taskData;
                std::getline(is, taskData);
                // 这里简单模拟任务处理，实际应用中需要根据协议解析任务数据
                pool.AddTask([taskData]() {
                    std::cout << "Processing task: " << taskData << std::endl;
                    // 模拟任务执行
                    std::this_thread::sleep_for(std::chrono::seconds(2));
                });
            }
            socket.close();
        });
    }
};

int main() {
    MthreadPool pool(2, 5);
    DistributedTaskHandler handler(pool, 12345);

    std::thread ioThread([&handler]() {
        handler.run();
    });

    // 主线程可以继续做其他事情
    std::this_thread::sleep_for(std::chrono::seconds(10));

    ioThread.join();
    return 0;
}

解释：

分布式任务处理类 DistributedTaskHandler：该类使用了 asio 库来实现网络通信，监听指定端口（这里是 12345），接收远程任务请求。
异步接受连接：startAccept 方法使用 async_accept 异步接受新的连接，当有新连接到来时，调用 handleRequest 方法处理请求。
任务处理：handleRequest 方法使用 async_read_until 异步读取客户端发送的数据，将其作为任务数据。这里简单模拟了任务处理，实际应用中需要根据具体的协议解析任务数据。然后将任务添加到线程池 pool 中执行。
多线程运行：在 main 函数中，创建一个单独的线程来运行 DistributedTaskHandler 的 run 方法，主线程可以继续执行其他任务。

9. 线程池与机器学习任务的结合

在机器学习领域，很多任务可以并行化处理，例如数据预处理、模型训练等。我们可以使用线程池来加速这些任务的执行。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

// 模拟机器学习数据
struct MLData {
    std::vector features;
    double label;
};

class MthreadPool {
    // 线程池类的定义保持不变，此处省略详细代码
};

// 数据预处理函数
void preprocessData(MLData& data) {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_real_distribution<> dis(0.1, 0.9);
    for (auto& feature : data.features) {
        feature *= dis(gen);
    }
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
}

// 模型训练函数
void trainModel(const std::vector& data) {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Model training completed." << std::endl;
}

int main() {
    MthreadPool pool(2, 5);
    std::vector dataset;
    // 生成一些模拟数据
    for (int i = 0; i < 10; ++i) {
        MLData data;
        data.features.resize(10);
        for (int j = 0; j < 10; ++j) {
            data.features[j] = static_cast(i + j);
        }
        data.label = static_cast(i);
        dataset.push_back(data);
    }

    // 并行进行数据预处理
    std::vector> futures;
    for (auto& data : dataset) {
        futures.emplace_back(pool.AddTask(preprocessData, std::ref(data)));
    }

    // 等待所有数据预处理任务完成
    for (auto& future : futures) {
        future.wait();
    }

    // 进行模型训练
    auto trainFuture = pool.AddTask(trainModel, std::ref(dataset));
    trainFuture.wait();

    return 0;
}

解释：

模拟机器学习数据：定义了 MLData 结构体来表示机器学习数据，包含特征向量和标签。
数据预处理：preprocessData 函数模拟了数据预处理过程，对每个特征进行随机缩放，并休眠一段时间模拟处理耗时。
模型训练：trainModel 函数模拟了模型训练过程，休眠一段时间表示训练耗时。
并行处理：在 main 函数中，将数据预处理任务添加到线程池中并行执行，使用 std::future 来管理任务的执行结果。等待所有数据预处理任务完成后，再将模型训练任务添加到线程池中执行。

10. 线程池的安全性增强

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

class MthreadPool {
public:
    MthreadPool(int min, int max) : minthread(min), maxthread(max),
        stopthread(false), idlethread(min), currentthread(min)
    {
        if (min < 0 || max < min) {
            throw std::invalid_argument("Invalid thread pool size parameters");
        }
        manager = new std::thread(&MthreadPool::Manager, this);
        counttask = 0;
        addcount = 0;
        taskQueues.resize(max);
        taskQueueConditions.resize(max);
        for (int i = 0; i < max; i++)
        {
            std::thread t(&MthreadPool::Worker, this, i);
            workers.insert(std::make_pair(t.get_id(), std::move(t)));
        }
    }

    ~MthreadPool()
    {
        stopthread = true;
        for (auto& cond : taskQueueConditions) {
            cond.notify_all();
        }
        for (auto& it : workers)
        {
            if (it.second.joinable())
            {
                it.second.join();
            }
        }
        if (manager->joinable())
        {
            manager->join();
        }
        delete manager;
    }

    template
    auto AddTask(F&& f, Args&&... args) 
        -> std::future::type> {
        using return_type = typename std::result_of::type;

        auto task = std::make_shared< std::packaged_task >(
            std::bind(std::forward(f), std::forward(args)...)
        );
        
        std::future res = task->get_future();
        {
            std::lock_guard lock(queueMutex);
            if (stopthread)
                throw std::runtime_error("enqueue on stopped ThreadPool");
            if (totalQueueSize.load() >= maxQueueSize) {
                throw std::runtime_error("Task queue is full");
            }
            int queueIndex = nextQueueIndex++;
            queueIndex %= maxthread;
            taskQueues[queueIndex].emplace([task]() { (*task)(); });
            addcount++;
            totalQueueSize++;
        }
        taskQueueConditions[queueIndex].notify_one();
        return res;
    }

private:
    const int maxQueueSize = 100;  // 任务队列最大长度
    int minthread;
    int maxthread;
    std::atomic stopthread;
    std::atomic idlethread;
    std::atomic currentthread;
    std::atomic exithread{ 0 };
    std::atomic counttask;
    std::atomic addcount;
    std::map workers;
    std::thread* manager;
    std::vector>> taskQueues;
    std::mutex queueMutex;
    std::mutex exitidMutex;
    std::vector taskQueueConditions;
    std::atomic nextQueueIndex{0};
    std::vector exit_id;
    std::atomic totalQueueSize{0};

    void Manager(void)
    {
        while (!stopthread.load())
        {
            std::this_thread::sleep_for(std::chrono::seconds(3));
            int idle = idlethread.load();
            int cur = currentthread.load();
            int totalSize = 0;
            {
                std::lock_guard lock(queueMutex);
                for (const auto& queue : taskQueues) {
                    totalSize += queue.size();
                }
                totalQueueSize = totalSize;
            }

            if (idle > cur / 2 && cur > minthread && totalSize < cur / 2)
            {
                exithread.store(2);
                for (auto& cond : taskQueueConditions) {
                    cond.notify_all();
                }
                std::lock_guard lock(exitidMutex);
                for (auto id : exit_id)
                {
                    auto thread = workers.find(id);
                    if (thread != workers.end())
                    {
                        (*thread).second.join();
                        workers.erase(thread);
                    }
                }
                exit_id.clear();
            }
            else if (idle == 0 && cur < maxthread && totalSize > cur * 2)
            {
                std::thread t(&MthreadPool::Worker, this, currentthread);
                workers.insert(std::make_pair(t.get_id(), std::move(t)));
                currentthread++;
                idlethread++;
            }
        }
    }

    void Worker(int queueIndex) {
        while (!stopthread.load()) {
            std::function task;
            {
                std::unique_lock lock(queueMutex);
                taskQueueConditions[queueIndex].wait(lock, [this, queueIndex] {
                    return stopthread || !taskQueues[queueIndex].empty();
                });
                if (stopthread && taskQueues[queueIndex].empty())
                    return;
                if (exithread.load() > 0) {
                    currentthread--;
                    exithread--;
                    idlethread--;
                    std::lock_guard lock(exitidMutex);
                    exit_id.emplace_back(std::this_thread::get_id());
                    return;
                }
                task = std::move(taskQueues[queueIndex].front());
                taskQueues[queueIndex].pop();
                totalQueueSize--;
            }
            idlethread--;
            try {
                task();
                counttask++;
            } catch (const std::exception& e) {
                std::cerr << "Exception caught in worker thread: " << e.what() << std::endl;
                // 可以添加更多异常处理逻辑，如重试任务
            }
            idlethread++;
        }
    }
};

// 示例使用
void sampleTask() {
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    std::cout << "Task completed." << std::endl;
}

int main() {
    try {
        MthreadPool pool(2, 5);
        for (int i = 0; i < 20; ++i) {
            pool.AddTask(sampleTask);
        }
        std::this_thread::sleep_for(std::chrono::seconds(10));
    } catch (const std::exception& e) {
        std::cerr << "Exception in main: " << e.what() << std::endl;
    }
    return 0;
}

解释：

构造函数参数检查：在构造函数中，添加了对最小线程数和最大线程数的检查。如果最小线程数小于 0 或者最大线程数小于最小线程数，会抛出 std::invalid_argument 异常，避免创建无效的线程池。
任务队列边界检查：在 AddTask 方法中，增加了对任务队列总长度的检查。如果任务队列的总长度达到了预设的最大长度 maxQueueSize，会抛出 std::runtime_error 异常，防止任务队列无限增长，导致内存溢出。
异常处理完善：在 Worker 函数的异常处理部分，可以进一步添加重试逻辑，例如对于一些可重试的异常，可以尝试重新执行任务，提高任务执行的成功率。

11. 线程池的跨平台兼容性优化

虽然 C++ 标准库提供了跨平台的线程和同步机制，但在不同的操作系统上，线程的行为和性能可能会有所差异。为了提高线程池的跨平台兼容性和性能，可以根据不同的操作系统进行一些优化。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#ifdef _WIN32
#include 
#else
#include 
#endif

class MthreadPool {
public:
    MthreadPool(int min, int max) : minthread(min), maxthread(max),
        stopthread(false), idlethread(min), currentthread(min)
    {
        if (min < 0 || max < min) {
            throw std::invalid_argument("Invalid thread pool size parameters");
        }
        manager = new std::thread(&MthreadPool::Manager, this);
        counttask = 0;
        addcount = 0;
        taskQueues.resize(max);
        taskQueueConditions.resize(max);
        for (int i = 0; i < max; i++)
        {
            std::thread t(&MthreadPool::Worker, this, i);
            setThreadPriority(t);
            workers.insert(std::make_pair(t.get_id(), std::move(t)));
        }
    }

    ~MthreadPool()
    {
        stopthread = true;
        for (auto& cond : taskQueueConditions) {
            cond.notify_all();
        }
        for (auto& it : workers)
        {
            if (it.second.joinable())
            {
                it.second.join();
            }
        }
        if (manager->joinable())
        {
            manager->join();
        }
        delete manager;
    }

    template
    auto AddTask(F&& f, Args&&... args) 
        -> std::future::type> {
        using return_type = typename std::result_of::type;

        auto task = std::make_shared< std::packaged_task >(
            std::bind(std::forward(f), std::forward(args)...)
        );
        
        std::future res = task->get_future();
        {
            std::lock_guard lock(queueMutex);
            if (stopthread)
                throw std::runtime_error("enqueue on stopped ThreadPool");
            if (totalQueueSize.load() >= maxQueueSize) {
                throw std::runtime_error("Task queue is full");
            }
            int queueIndex = nextQueueIndex++;
            queueIndex %= maxthread;
            taskQueues[queueIndex].emplace([task]() { (*task)(); });
            addcount++;
            totalQueueSize++;
        }
        taskQueueConditions[queueIndex].notify_one();
        return res;
    }

private:
    const int maxQueueSize = 100;  // 任务队列最大长度
    int minthread;
    int maxthread;
    std::atomic stopthread;
    std::atomic idlethread;
    std::atomic currentthread;
    std::atomic exithread{ 0 };
    std::atomic counttask;
    std::atomic addcount;
    std::map workers;
    std::thread* manager;
    std::vector>> taskQueues;
    std::mutex queueMutex;
    std::mutex exitidMutex;
    std::vector taskQueueConditions;
    std::atomic nextQueueIndex{0};
    std::vector exit_id;
    std::atomic totalQueueSize{0};

    void Manager(void)
    {
        while (!stopthread.load())
        {
            std::this_thread::sleep_for(std::chrono::seconds(3));
            int idle = idlethread.load();
            int cur = currentthread.load();
            int totalSize = 0;
            {
                std::lock_guard lock(queueMutex);
                for (const auto& queue : taskQueues) {
                    totalSize += queue.size();
                }
                totalQueueSize = totalSize;
            }

            if (idle > cur / 2 && cur > minthread && totalSize < cur / 2)
            {
                exithread.store(2);
                for (auto& cond : taskQueueConditions) {
                    cond.notify_all();
                }
                std::lock_guard lock(exitidMutex);
                for (auto id : exit_id)
                {
                    auto thread = workers.find(id);
                    if (thread != workers.end())
                    {
                        (*thread).second.join();
                        workers.erase(thread);
                    }
                }
                exit_id.clear();
            }
            else if (idle == 0 && cur < maxthread && totalSize > cur * 2)
            {
                std::thread t(&MthreadPool::Worker, this, currentthread);
                setThreadPriority(t);
                workers.insert(std::make_pair(t.get_id(), std::move(t)));
                currentthread++;
                idlethread++;
            }
        }
    }

    void Worker(int queueIndex) {
        while (!stopthread.load()) {
            std::function task;
            {
                std::unique_lock lock(queueMutex);
                taskQueueConditions[queueIndex].wait(lock, [this, queueIndex] {
                    return stopthread || !taskQueues[queueIndex].empty();
                });
                if (stopthread && taskQueues[queueIndex].empty())
                    return;
                if (exithread.load() > 0) {
                    currentthread--;
                    exithread--;
                    idlethread--;
                    std::lock_guard lock(exitidMutex);
                    exit_id.emplace_back(std::this_thread::get_id());
                    return;
                }
                task = std::move(taskQueues[queueIndex].front());
                taskQueues[queueIndex].pop();
                totalQueueSize--;
            }
            idlethread--;
            try {
                task();
                counttask++;
            } catch (const std::exception& e) {
                std::cerr << "Exception caught in worker thread: " << e.what() << std::endl;
                // 可以添加更多异常处理逻辑，如重试任务
            }
            idlethread++;
        }
    }

    void setThreadPriority(std::thread& t) {
#ifdef _WIN32
        HANDLE handle = t.native_handle();
        SetThreadPriority(handle, THREAD_PRIORITY_NORMAL);
#else
        pthread_t nativeThread = t.native_handle();
        sched_param param;
        param.sched_priority = sched_get_priority_min(SCHED_OTHER);
        pthread_setschedparam(nativeThread, SCHED_OTHER, ¶m);
#endif
    }
};

// 示例使用
void sampleTask() {
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    std::cout << "Task completed." << std::endl;
}

int main() {
    try {
        MthreadPool pool(2, 5);
        for (int i = 0; i < 20; ++i) {
            pool.AddTask(sampleTask);
        }
        std::this_thread::sleep_for(std::chrono::seconds(10));
    } catch (const std::exception& e) {
        std::cerr << "Exception in main: " << e.what() << std::endl;
    }
    return 0;
}

解释：

条件编译：使用 #ifdef _WIN32 进行条件编译，根据不同的操作系统选择不同的线程优先级设置方法。在 Windows 系统上，使用 SetThreadPriority 函数设置线程优先级；在其他系统上，使用 pthread_setschedparam 函数设置线程优先级。
线程优先级设置：在创建每个工作线程时，调用 setThreadPriority 函数设置线程的优先级。这样可以根据不同的操作系统和任务需求，合理调整线程的优先级，提高线程池的性能。

C++11堆操作深度解析：std::is_heap与std::is_heap_until原理解析与实践
文章目录堆结构基础与函数接口堆的核心性质函数签名与核心接口std::is_heapstd::is_heap_until实现原理深度剖析std::is_heap的验证逻辑std::is_heap_until的定位策略算法优化细节代码实践与案例分析基础用法演示自定义比较器实现最小堆检查边缘情况处理性能分析与实际应用时间复杂度对比典型应用场景与手动实现的对比注意事项与最佳实践迭代器要求比较器设计C++标
C++ 11 Lambda表达式和min_element()与max_element()的使用_c++ lamda函数 min_element((1) 2401_84976182 程序员 c语言 c++学习
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上CC++开发知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新如果你需要这些资料，可以戳这里获取#include#include#includeusingnamespacestd;boolcmp(int
C++ 11 Lambda表达式和min_element()与max_element()的使用_c++ lamda函数 min_element(
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加戳这里获取一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！intmain(){vectormyvec{3,
冒泡、选择、插入排序：三大基础排序算法深度解析（C语言实现） xienda 算法排序算法数据结构
在算法学习道路上，排序算法是每位程序员必须掌握的基石。本文将深入解析冒泡排序、选择排序和插入排序这三种基础排序算法，通过C语言代码实现和对比分析，帮助读者彻底理解它们的差异与应用场景。算法原理与代码实现1.冒泡排序（BubbleSort）工作原理：通过重复比较相邻元素，将较大元素逐步"冒泡"到数组末尾。voidbubbleSort(intarr[],intn){ for(inti=0;iarr[
Leetcode 148. 排序链表
文章目录前引题目代码（首刷看题解）代码（8.9二刷部分看解析）代码（9.15三刷部分看解析）前引综合性比较强的一道题，要求时间复杂度必须O(logn)才能通过，最适合链表的排序算法就是归并。这里采用自顶向下的方法步骤：找到链表中点（双指针）对两个子链表排序(递归，直到只有一个结点，记得将子链表最后指向nullptr）归并（引入dummy结点）题目Leetcode148.排序链表代码（首刷看题解）c
全面触摸屏输入法设计与实现长野君
本文还有配套的精品资源，点击获取简介：触摸屏输入法是针对触摸设备优化的文字输入方案，包括虚拟键盘、手写、语音识别和手势等多种输入方式。本方案通过提供主程序文件、用户手册、界面截图、示例图、说明文本和音效文件，旨在为用户提供一个完整的、多样的文字输入体验。开发者通过持续优化算法和用户界面，使用户在无物理键盘环境下也能高效准确地进行文字输入。1.触摸屏输入法概述简介在现代信息技术飞速发展的今天，触摸屏
嵌入式系统LCD显示模块编程实践
本文还有配套的精品资源，点击获取简介：本文档提供了一个具有800x480分辨率的3.5英寸液晶显示模块LW350AC9001的驱动程序代码，以及嵌入式系统中使用C/C++语言进行硬件编程的实践指南。该模块的2mm厚度使其适用于空间受限的便携式设备。内容包括驱动程序源代码、硬件控制接口使用方法，以及如何在嵌入式系统中进行图形处理、电源管理与性能优化。1.嵌入式系统原理1.1嵌入式系统概念嵌入式系统是
FPGA小白到项目实战：Verilog+Vivado全流程通关指南（附光学类岗位技能映射）阿牛的药铺算法移植部署 fpga开发 verilog
FPGA小白到项目实战：Verilog+Vivado全流程通关指南（附光学类岗位技能映射）引言：为什么这个FPGA入门路线能帮你快速上岗？本文设计了一条**"Verilog语法→工具链操作→光学项目实战→岗位技能对标"的阶梯式学习路径。不同于泛泛而谈的FPGA教程，我们聚焦光学类产品开发**核心能力（时序接口设计、图像处理算法移植、高速接口应用），通过3个递进式项目（从LED闪烁到图像边缘检测），
PyTorch & TensorFlow速成复习：从基础语法到模型部署实战（附FPGA移植衔接）阿牛的药铺算法移植部署 pytorch tensorflow fpga开发
PyTorch&TensorFlow速成复习：从基础语法到模型部署实战（附FPGA移植衔接）引言：为什么算法移植工程师必须掌握框架基础？针对光学类产品算法FPGA移植岗位需求（如可见光/红外图像处理），深度学习框架是算法落地的"桥梁"——既要用PyTorch/TensorFlow验证算法可行性，又要将训练好的模型（如CNN、目标检测）转换为FPGA可部署的格式（ONNX、TFLite）。本文采用"
【超硬核】JVM源码解读：Java方法main在虚拟机上解释执行 HeapDump性能社区 java 开发语言后端 jvm
本文由HeapDump性能社区首席讲师鸠摩（马智）授权整理发布第1篇-关于Java虚拟机HotSpot，开篇说的简单点开讲Java运行时，这一篇讲一些简单的内容。我们写的主类中的main()方法是如何被Java虚拟机调用到的？在Java类中的一些方法会被由C/C++编写的HotSpot虚拟机的C/C++函数调用，不过由于Java方法与C/C++函数的调用约定不同，所以并不能直接调用，需要JavaC
算法学习笔记：17.蒙特卡洛算法 ——从原理到实战，涵盖 LeetCode 与考研 408 例题
在计算机科学和数学领域，蒙特卡洛算法（MonteCarloAlgorithm）以其独特的随机抽样思想，成为解决复杂问题的有力工具。从圆周率的计算到金融风险评估，从物理模拟到人工智能，蒙特卡洛算法都发挥着不可替代的作用。本文将深入剖析蒙特卡洛算法的思想、解题思路，结合实际应用场景与Java代码实现，并融入考研408的相关考点，穿插图片辅助理解，帮助你全面掌握这一重要算法。蒙特卡洛算法的基本概念蒙特卡
算法学习笔记：15.二分查找 ——从原理到实战，涵盖 LeetCode 与考研 408 例题呆呆企鹅仔算法学习算法学习笔记考研二分查找
在计算机科学的查找算法中，二分查找以其高效性占据着重要地位。它利用数据的有序性，通过不断缩小查找范围，将原本需要线性时间的查找过程优化为对数时间，成为处理大规模有序数据查找问题的首选算法。二分查找的基本概念二分查找（BinarySearch），又称折半查找，是一种在有序数据集合中查找特定元素的高效算法。其核心原理是：通过不断将查找范围减半，快速定位目标元素。与线性查找逐个遍历元素不同，二分查找依赖
LeetCode算法题：电话号码的字母组合吱屋猪_ 算法 leetcode java
题目描述：给定一个仅包含数字2-9的字符串，返回所有它能表示的字母组合。答案可以按任意顺序返回。给出数字到字母的映射如下（与电话按键相同）。注意1不对应任何字母。2->"abc"3->"def"4->"ghi"5->"jkl"6->"mno"7->"pqrs"8->"tuv"9->"wxyz"例如，给定digits="23"，返回["ad","ae","af","bd","be","bf","cd
C++ 设计模式：抽象工厂（Abstract Factory）冀晓武 C++设计模式 c++设计模式抽象工厂模式
链接：C++设计模式链接：C++设计模式-工厂方法链接：C++设计模式-原型模式链接：C++设计模式-建造者模式抽象工厂（AbstractFactory）是一种创建型设计模式，它提供一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。抽象工厂模式通常用于创建一组相关的产品对象，例如不同类型的机器人和它们的配件。1.问题分析在某些情况下，我们需要创建一组相关或相互依赖的对象，但我们
霍夫变换（Hough Transform）算法原来详解和纯C++代码实现以及OpenCV中的使用示例点云SLAM 算法图形图像处理算法 opencv 图像处理与计算机视觉算法直线提取检测目标检测霍夫变换算法
霍夫变换（HoughTransform）是一种经典的图像处理与计算机视觉算法，广泛用于检测图像中的几何形状，例如直线、圆、椭圆等。其核心思想是将图像空间中的“点”映射到参数空间中的“曲线”，从而将形状检测问题转化为参数空间中的峰值检测问题。一、霍夫变换基本思想输入：边缘图像（如经过Canny边缘检测）输出：一组满足几何模型的形状（如直线、圆）关键思想：图像空间中的一个点→参数空间中的一个曲线参数空
用OpenCV标定相机内参应用示例（C++和Python）
下面是一个完整的使用OpenCV进行相机内参标定（CameraCalibration）的示例，包括C++和Python两个版本，基于棋盘格图案标定。一、目标：相机标定通过拍摄多张带有棋盘格图案的图像，估计相机的内参：相机矩阵（内参）K畸变系数distCoeffs可选外参（R,T）标定精度指标（如重投影误差）二、棋盘格参数设置（根据自己的棋盘格设置）：棋盘格角点数：9x6（内角点，9列×6行）；每个
C++设计模式：简单工厂、工厂方法、抽象工厂起个别名 C++算法 c++
1.工厂模式的特点在我们现实生活中，买馒头和自己蒸馒头、去饭店点一份大盘鸡和自己养鸡，杀鸡，做大盘鸡，这是全然不同的两种体验：自己做麻烦，而且有失败的风险，需要自己承担后果。买现成的，可以忽略制作细节，方便快捷并且无风险，得到的肯定是美味的食物。对于后者，就相当于是一个加工厂，通过这个工厂我们就可以得到想要的东西，在程序设计中，这种模式就叫做工厂模式，工厂生成出的产品就是某个类的实例，也就是对象。
Java三年经验程序员技术栈全景指南：从前端到架构，对标阿里美团全栈要求可曾去过倒悬山 java 前端架构
Java三年经验程序员技术栈全景指南：从前端到架构，对标阿里美团全栈要求三年经验是Java程序员的分水岭，技术栈深度决定你成为“业务码农”还是“架构师候选人”。本文整合阿里、美团、滴滴等大厂招聘要求，为你绘制可落地的进阶路线。一、Java核心：从语法糖到JVM底层三年经验与初级的核心差异在于系统级理解，大厂面试常考以下能力：JVM与性能调优内存模型（堆外内存、元空间）、GC算法（G1/ZGC适用场
被动降噪的概念及编程实现 CodeByte 人工智能算法 javascript 编程
被动降噪是指通过编程技术和算法，对输入的数据进行处理，以减少或消除其中的噪声。噪声可以是各种形式的干扰，例如来自传感器、通信信号或其他外部源的干扰。在本文中，我们将探讨被动降噪的意义以及如何使用编程来实现这一目标。被动降噪的意义：噪声对数据的准确性和可靠性产生负面影响。在许多应用领域，例如图像处理、音频处理和信号处理中，噪声的存在可能导致数据质量下降，使得后续的分析和处理变得困难。因此，被动降噪技
传统检测响应慢？陌讯多模态引擎提速90+FPS实战 2501_92473147 算法计算机视觉目标检测
开篇痛点：实时目标检测在安防监控中的核心挑战在安防监控领域，实时目标检测是保障公共安全的关键技术。然而，传统算法如YOLOv5或开源框架MMDetection常面临两大痛点：误报率高（复杂光照或遮挡场景下检测不稳定）和响应延迟（高分辨率视频流处理FPS低于30）。实测数据显示，城市交通监控系统误报率达15%，导致安保资源浪费；客户反馈表明，延迟超100ms时，目标跟踪可能失效。这些问题源于算法泛化
反光衣识别漏检率 30%？陌讯多尺度模型实测优化
在建筑工地、交通指挥等场景中，反光衣是保障作业人员安全的重要装备，对其进行精准识别是智能监控系统的核心功能之一。但传统视觉算法在实际应用中却屡屡碰壁：强光下反光衣易与背景混淆、远距离小目标漏检率高达30%、复杂场景下模型泛化能力不足[实测数据来源：某智慧工地项目2024年Q1日志]。这些问题直接导致安全监控系统预警滞后，给安全生产埋下隐患。一、技术解析：反光衣识别的核心难点与陌讯算法创新反光衣识别
AI音乐模拟器：AIGC时代的智能音乐创作革命 lauo 人工智能 AIGC 开源前端机器人
AI音乐模拟器：AIGC时代的智能音乐创作革命引言：AIGC浪潮下的音乐创作新范式在数字化转型的浪潮中，人工智能生成内容（AIGC）正在重塑各个创意领域。音乐产业作为创意经济的重要组成部分，正经历着前所未有的变革。据最新市场研究数据显示，全球AI音乐市场规模预计将从2023年的5.8亿美元增长到2030年的26.8亿美元，年复合增长率高达24.3%。这一快速增长的市场背后，是AI音乐技术正在打破传
【GESP】C++三级真题 luogu-B4359 [GESP202506 三级] 分糖果 CoderCodingNo GESP c++java 开发语言
GESPC++三级，2025年6月真题，模拟算法，难度★★☆☆☆。本次三级题目个人感觉比较简单。题目题解详见：【GESP】C++三级真题luogu-B4359[GESP202506三级]分糖果|OneCoder【GESP】C++三级真题luogu-B4359[GESP202506三级]分糖果|OneCoderGESPC++三级，2025年6月真题，模拟算法，难度★★☆☆☆。本次三级题目个人感觉比较
C++设计秘籍：为什么所有参数都需类型转换时，非成员函数才是王道？讳疾忌医丶 c++前端开发语言
当所有参数都需要类型转换时，为什么要选择非成员函数？在C++的世界里，有一个看似简单却蕴含深意的设计原则：当所有参数（包括被this指针所指的那个隐式参数）皆须进行类型转换时，请为此采用非成员函数实现。这个原则背后隐藏着C++类型系统的精妙设计，也揭示了成员函数与非成员函数在处理隐式类型转换时的本质差异。想象一下，你正在设计一个数学计算库，需要支持整数与有理数的混合运算。如果你天真地将所有操作都实
【华为机试】HJ61 放苹果不爱熬夜的Coder 算法华为机试 golang 华为 golang 算法面试
文章目录HJ61放苹果描述输入描述输出描述示例1示例2解题思路算法分析问题本质分析状态定义与转移递推关系详解动态规划表构建算法流程图示例推导过程代码实现思路时间复杂度分析关键优化点边界情况处理递归解法对比实际应用场景测试用例分析算法特点数学原理完整题解代码HJ61放苹果描述我们需要将m个相同的苹果放入n个相同的盘子中，允许有的盘子空着不放。求解有多少种不同的分法。输入描述输入两个整数m,n(0B[
LangChain中的向量数据库接口－Weaviate 洪城叮当 langchain 数据库经验分享笔记交互人工智能知识图谱
文章目录前言一、原型定义二、代码解析1、add_texts方法1.1、应用样例2、from_texts方法2.1、应用样例3、similarity_search方法3.1、应用样例三、项目应用1、安装依赖2、引入依赖3、创建对象4、添加数据5、查询数据总结前言 Weaviate是一个开源的向量数据库，支持存储来自各类机器学习模型的数据对象和向量嵌入，并能无缝扩展至数十亿数据对象。它提供存储文档嵌
初始化列表与类型转换（C++） 2401_89195731 c++开发语言
初始化列表和构造函数体在C++中都是用于给类的成员变量赋初值区别：初始化列表是给每个成员变量定义初始化的地方，即使有成员变量没有给它显式在初始化列表初始化，它也会走初始化列表初始化时机初始化列表：在对象创建时，成员变量通过初始化列表被直接初始化，这发生在构造函数体执行之前。构造函数体内赋值：成员变量首先被默认初始化，然后在构造函数体内通过赋值语句进行赋值。性能差异初始化列表：通常更高效，因为它避免
list的一些特性（C++） 2401_89195731 c++开发语言
C++STL库中的std::list是一个带头双向循环链表，使用之前需要包头文件，它和vector的使用高度类似。构造list支持多种构造方式默认构造函数：创建一个空的列表。拷贝构造函数：从另一个相同类型的列表创建一个新的列表。范围构造函数：从一对迭代器指定的范围内复制元素到新的列表中。初始值列表构造函数：使用初始化列表（initializerlist）创建一个包含指定元素的列表。填充构造函数：创
.NET中的安全性之数字签名、数字证书、强签名程序集、反编译 hezudao25 NET .net assembly 加密算法 reference header
本文将探讨数字签名、数字证书、强签名程序集、反编译等以及它们在.NET中的运用（一些概念并不局限于.NET在其它技术、平台中也存在）。1.数字签名数字签名又称为公钥数字签名，或者电子签章等，它借助公钥加密技术实现。数字签名技术主要涉及公钥、私钥、非对称加密算法。1.1公钥与私钥公钥是公开的钥匙，私钥则是与公钥匹配的严格保护的私有密钥；私钥加密的信息只有公钥可以解开，反之亦然。在VisualStud
QML与C++相互调用函数并获得返回值 cpp_learners QML c++QML qt
这篇博客主要讲解在qml端如何直接调用c++的函数并获得返回值，在c++端如何直接调用qml的函数并获得返回值；主要以map或者jsonobject、list或者jsonarray为主！其他单个类型，常见的类型，例如QString、int等，就不演示了；一通百通。目录1准备工作1.1C++端1.2QML端2qml端直接调用c++端函数3c++端直接调用qml端函数3.1调用qml的qmlFuncO
jQuery 键盘事件keydown ,keypress ,keyup介绍 107x js jquery keydown keypress keyup
本文章总结了下些关于jQuery 键盘事件keydown ,keypress ,keyup介绍，有需要了解的朋友可参考。一、首先需要知道的是： 1、keydown() keydown事件会在键盘按下时触发. 2、keyup() 代码如下复制代码 $('input').keyup(funciton(){
AngularJS中的Promise bijian1013 JavaScript AngularJS Promise
一.Promise Promise是一个接口，它用来处理的对象具有这样的特点：在未来某一时刻（主要是异步调用）会从服务端返回或者被填充属性。其核心是，promise是一个带有then()函数的对象。为了展示它的优点，下面来看一个例子，其中需要获取用户当前的配置文件： var cu
c++ 用数组实现栈类 CrazyMizzz 数据结构 C++
#include<iostream> #include<cassert> using namespace std; template<class T, int SIZE = 50> class Stack{ private: T list[SIZE];//数组存放栈的元素 int top;//栈顶位置 public: Stack(
java和c语言的雷同麦田的设计者 java 递归 scaner
软件启动时的初始化代码，加载用户信息2015年5月27号从头学java二 1、语言的三种基本结构：顺序、选择、循环。废话不多说，需要指出一下几点： a、return语句的功能除了作为函数返回值以外，还起到结束本函数的功能，return后的语句不会再继续执行。 b、for循环相比于whi
LINUX环境并发服务器的三种实现模型被触发 linux
服务器设计技术有很多，按使用的协议来分有TCP服务器和UDP服务器。按处理方式来分有循环服务器和并发服务器。 1 循环服务器与并发服务器模型在网络程序里面，一般来说都是许多客户对应一个服务器，为了处理客户的请求，对服务端的程序就提出了特殊的要求。目前最常用的服务器模型有： ·循环服务器：服务器在同一时刻只能响应一个客户端的请求 ·并发服务器：服
Oracle数据库查询指令肆无忌惮_ oracle数据库
20140920 单表查询 -- 查询************************************************************************************************************ -- 使用scott用户登录 -- 查看emp表 desc emp
ext右下角浮动窗口知了ing JavaScript ext
第一种 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/
浅谈REDIS数据库的键值设计矮蛋蛋 redis
http://www.cnblogs.com/aidandan/ 原文地址：http://www.hoterran.info/redis_kv_design 丰富的数据结构使得redis的设计非常的有趣。不像关系型数据库那样，DEV和DBA需要深度沟通，review每行sql语句，也不像memcached那样，不需要DBA的参与。redis的DBA需要熟悉数据结构，并能了解使用场景。
maven编译可执行jar包 alleni123 maven
http://stackoverflow.com/questions/574594/how-can-i-create-an-executable-jar-with-dependencies-using-maven <build> <plugins> <plugin> <artifactId>maven-asse
人力资源在现代企业中的作用百合不是茶 HR 企业管理
//人力资源在在企业中的作用人力资源为什么会存在，人力资源究竟是干什么的人力资源管理是对管理模式一次大的创新，人力资源兴起的原因有以下点：工业时代的国际化竞争，现代市场的风险管控等等。所以人力资源在现代经济竞争中的优势明显的存在，人力资源在集团类公司中存在着明显的优势(鸿海集团)，有一次笔者亲自去体验过红海集团的招聘，只知道人力资源是管理企业招聘的当时我被招聘上了，当时给我们培训的人
Linux自启动设置详解 bijian1013 linux
linux有自己一套完整的启动体系，抓住了linux启动的脉络，linux的启动过程将不再神秘。阅读之前建议先看一下附图。本文中假设inittab中设置的init tree为： /etc/rc.d/rc0.d /etc/rc.d/rc1.d /etc/rc.d/rc2.d /etc/rc.d/rc3.d /etc/rc.d/rc4.d /etc/rc.d/rc5.d /etc
Spring Aop Schema实现 bijian1013 java spring AOP
本例使用的是Spring2.5 1.Aop配置文件spring-aop.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmln
【Gson七】Gson预定义类型适配器 bit1129 gson
Gson提供了丰富的预定义类型适配器，在对象和JSON串之间进行序列化和反序列化时，指定对象和字符串之间的转换方式， DateTypeAdapter public final class DateTypeAdapter extends TypeAdapter<Date> { public static final TypeAdapterFacto
【Spark八十八】Spark Streaming累加器操作（updateStateByKey) bit1129 update
在实时计算的实际应用中，有时除了需要关心一个时间间隔内的数据，有时还可能会对整个实时计算的所有时间间隔内产生的相关数据进行统计。比如：对Nginx的access.log实时监控请求404时，有时除了需要统计某个时间间隔内出现的次数，有时还需要统计一整天出现了多少次404，也就是说404监控横跨多个时间间隔。 Spark Streaming的解决方案是累加器，工作原理是，定义
linux系统下通过shell脚本快速找到哪个进程在写文件 ronin47
一个文件正在被进程写我想查看这个进程文件一直在增大找不到谁在写使用lsof也没找到这个问题挺有普遍性的，解决方法应该很多，这里我给大家提个比较直观的方法。 linux下每个文件都会在某个块设备上存放，当然也都有相应的inode, 那么透过vfs.write我们就可以知道谁在不停的写入特定的设备上的inode。幸运的是systemtap的安装包里带了inodewatch.stp，位
java-两种方法求第一个最长的可重复子串 bylijinnan java 算法
import java.util.Arrays; import java.util.Collections; import java.util.List; public class MaxPrefix { public static void main(String[] args) { String str="abbdabcdabcx";
Netty源码学习-ServerBootstrap启动及事件处理过程 bylijinnan java netty
Netty是采用了Reactor模式的多线程版本，建议先看下面这篇文章了解一下Reactor模式： http://bylijinnan.iteye.com/blog/1992325 Netty的启动及事件处理的流程，基本上是按照上面这篇文章来走的文章里面提到的操作，每一步都能在Netty里面找到对应的代码其中Reactor里面的Acceptor就对应Netty的ServerBo
servelt filter listener 的生命周期 cngolon filter listener servelt 生命周期
1. servlet 当第一次请求一个servlet资源时，servlet容器创建这个servlet实例，并调用他的 init(ServletConfig config)做一些初始化的工作，然后调用它的service方法处理请求。当第二次请求这个servlet资源时，servlet容器就不在创建实例，而是直接调用它的service方法处理请求，也就是说
jmpopups获取input元素值 ctrain JavaScript
jmpopups 获取弹出层form表单首先，我有一个div，里面包含了一个表单，默认是隐藏的，使用jmpopups时，会弹出这个隐藏的div，其实jmpopups是将我们的代码生成一份拷贝。当我直接获取这个form表单中的文本框时，使用方法：$('#form input[name=test1]').val()；这样是获取不到的。我们必须到jmpopups生成的代码中去查找这个值，$(
vi查找替换命令详解 daizj linux 正则表达式替换查找 vim
一、查找查找命令 /pattern<Enter> ：向下查找pattern匹配字符串 ?pattern<Enter>：向上查找pattern匹配字符串使用了查找命令之后，使用如下两个键快速查找： n：按照同一方向继续查找 N：按照反方向查找字符串匹配 pattern是需要匹配的字符串，例如： 1: /abc<En
对网站中的js,css文件进行打包 dcj3sjt126com PHP 打包
一，为什么要用smarty进行打包 apache中也有给js,css这样的静态文件进行打包压缩的模块，但是本文所说的不是以这种方式进行的打包，而是和smarty结合的方式来把网站中的js,css文件进行打包。为什么要进行打包呢，主要目的是为了合理的管理自己的代码。现在有好多网站，你查看一下网站的源码的话，你会发现网站的头部有大量的JS文件和CSS文件，网站的尾部也有可能有大量的J
php Yii: 出现undefined offset 或者 undefined index解决方案 dcj3sjt126com undefined
在开发Yii 时，在程序中定义了如下方式： if($this->menuoption[2] === 'test')，那么在运行程序时会报：undefined offset:2，这样的错误主要是由于php.ini 里的错误等级太高了，在windows下错误等级
linux 文件格式（1） sed工具 eksliang linux linux sed工具 sed工具 linux sed详解
转载请出自出处： http://eksliang.iteye.com/blog/2106082 简介 sed 是一种在线编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（pattern space），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾
Android应用程序获取系统权限 gqdy365 android
引用如何使Android应用程序获取系统权限第一个方法简单点，不过需要在Android系统源码的环境下用make来编译： 1. 在应用程序的AndroidManifest.xml中的manifest节点
HoverTree开发日志之验证码 hvt .net C#asp.net hovertree webform
HoverTree是一个ASP.NET的开源CMS，目前包含文章系统，图库和留言板功能。代码完全开放，文章内容页生成了静态的HTM页面，留言板提供留言审核功能，文章可以发布HTML源代码，图片上传同时生成高品质缩略图。推出之后得到许多网友的支持，再此表示感谢！留言板不断收到许多有益留言，但同时也有不少广告，因此决定在提交留言页面增加验证码功能。ASP.NET验证码在网上找，如果不是很多，就是特别多
JSON API：用 JSON 构建 API 的标准指南中文版 justjavac json
译文地址：https://github.com/justjavac/json-api-zh_CN 如果你和你的团队曾经争论过使用什么方式构建合理 JSON 响应格式，那么 JSON API 就是你的 anti-bikeshedding 武器。通过遵循共同的约定，可以提高开发效率，利用更普遍的工具，可以是你更加专注于开发重点：你的程序。基于 JSON API 的客户端还能够充分利用缓存，
数据结构随记_2 lx.asymmetric 数据结构笔记
第三章栈与队列一．简答题 1. 在一个循环队列中，队首指针指向队首元素的前一个位置。 2.在具有n个单元的循环队列中，队满时共有 n-1 个元素。 3. 向栈中压入元素的操作是先移动栈顶指针&n
Linux下的监控工具dstat 网络接口 linux
1) 工具说明dstat是一个用来替换 vmstat,iostat netstat,nfsstat和ifstat这些命令的工具, 是一个全能系统信息统计工具. 与sysstat相比, dstat拥有一个彩色的界面, 在手动观察性能状况时, 数据比较显眼容易观察; 而且dstat支持即时刷新, 譬如输入dstat 3, 即每三秒收集一次, 但最新的数据都会每秒刷新显示. 和sysstat相同的是,
C 语言初级入门--二维数组和指针 1140566087 二维数组 c/c++指针
/* 二维数组的定义和二维数组元素的引用二维数组的定义：当数组中的每个元素带有两个下标时，称这样的数组为二维数组； (逻辑上把数组看成一个具有行和列的表格或一个矩阵); 语法：类型名数组名[常量表达式1][常量表达式2] 二维数组的引用：引用二维数组元素时必须带有两个下标，引用形式如下：例如： int a[3][4]; 引用：
10点睛Spring4.1-Application Event wiselyman application
10.1 Application Event Spring使用Application Event给bean之间的消息通讯提供了手段应按照如下部分实现bean之间的消息通讯继承ApplicationEvent类实现自己的事件实现继承ApplicationListener接口实现监听事件使用ApplicationContext发布消息

线程池代码分析及延申应用（续二）

代码延申应用

8. 线程池与分布式系统的结合

9. 线程池与机器学习任务的结合

10. 线程池的安全性增强

11. 线程池的跨平台兼容性优化

你可能感兴趣的:(机器学习,算法,人工智能,计算机视觉,c++)