学习记录——day25 多线程编程 临界资源 临界区 竞态 线程的同步互斥机制（用于解决竟态）

已于 2024-08-02 17:27:03 修改
阅读量709 收藏 26
点赞数 15
文章标签： 学习
于 2024-08-02 17:14:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64918301/article/details/140863040
版权

目录

​编辑

一、多进程与多线程对比

二、 临界资源   临界区   竞态

 例1：临界资源 实现 输入输出

 例2：对临界资源 进行 减减 

例子3：临界资源抢占使用

三、线程的同步互斥机制（用于解决竟态）

3.1基本概念

3.2线程互斥

1、在C语言中，线程的互斥通过互斥锁来完成

2、互斥锁：本质上是一种临界资源，但互斥锁在同一时刻只能被一个线程使用，当一个线程试图去锁定另一个线程锁定的互斥所时，该线程会阻塞等待，直到使用互斥锁的线程解锁了该互斥锁

3、互斥锁的相关API

 4、对例3进行  互斥

3.3死锁

 3.4线程同步        

3.5线程同步 无名信号量

3.6 线程同步 条件变量

一、多进程与多线程对比

二、 临界资源   临界区   竞态

 例1：临界资源 实现 输入输出

#include <myhead.h>
#define N 2

char buf[128] = "";//临界资源

// 定义线程体1  使用临界资源的代码 称为临界区
void *task1(void *arg)
{
    while (1) // 输入信息
    {
        printf("输入：");
        fgets(buf, sizeof(buf), stdin);
        buf[strlen(buf) - 1] = 0;
    }
}

// 定义线程体2  使用临界资源的代码 称为临界区
void *task2(void *arg)
{
    while (1) // 循环输出信息
    {
        usleep(500000); // 500000us  0.5s  执行一次
        printf("buf = %s\n", buf);
        bzero(buf, sizeof(buf));
    }
}
int main(int argc, char const *argv[])
{
    // 创建两个任务
    pthread_t tid1, tid2;

    if (pthread_create(&tid1, NULL, task1, NULL) != 0)
    {
        printf("task1 error");
        return -1;
    }
    if (pthread_create(&tid2, NULL, task2, NULL) != 0)
    {
        printf("task2 error");
        return -1;
    }

    // 主程序
    printf("tid1 = %#lx, tid2 = %#lx\n", tid1, tid2);

    // 阻塞回收线程资源
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}

 例2：对临界资源 进行 减减 

#include <myhead.h>
#define N 2

int num  = 520;//临界资源

// 定义线程体1  使用临界资源的代码 称为临界区
void *task1(void *arg)
{
    while (1) // 输入信息
    {
        if (num > 0)
        {
            num--;
            printf("task1 执行一次，剩余%d次\n",num);
            usleep(1000);
        }else
        {
            printf("task1 执行结束\n");
            break;
        }
        
    }
    pthread_exit(EXIT_SUCCESS);
}

// 定义线程体2  使用临界资源的代码 称为临界区
void *task2(void *arg)
{
    while (1) // 输入信息
    {
        if (num > 0)
        {
            num--;
            printf("task2 执行一次，剩余%d次\n",num);
            usleep(1000);
        }else
        {
            printf("task2 执行结束\n");
            break;
        }
        
    }
    pthread_exit(EXIT_SUCCESS);
}
int main(int argc, char const *argv[])
{
    // 创建两个任务
    pthread_t tid1, tid2;

    if (pthread_create(&tid1, NULL, task1, NULL) != 0)
    {
        printf("task1 error");
        return -1;
    }
    if (pthread_create(&tid2, NULL, task2, NULL) != 0)
    {
        printf("task2 error");
        return -1;
    }

    // 主程序
    printf("tid1 = %#lx, tid2 = %#lx\n", tid1, tid2);

    // 阻塞回收线程资源
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}

例子3：临界资源抢占使用

#include <myhead.h>
#define N 2

int num  = 520;//临界资源

// 定义线程体1  使用临界资源的函数 称为临界区
void *task1(void *arg)
{
    while (1) // 输入信息
    {
        if (num > 0)
        {
            num--;
            printf("task1 执行一次，剩余%d次\n",num);
            usleep(1000);
        }else
        {
            printf("task1 执行结束\n");
            break;
        }
        
    }
    pthread_exit(EXIT_SUCCESS);
}

// 定义线程体2  使用临界资源的函数 称为临界区
void *task2(void *arg)
{
    while (1) // 输入信息
    {
        if (num > 0)
        {
            num--;
            printf("task2 执行一次，剩余%d次\n",num);
            usleep(1000);
        }else
        {
            printf("task2 执行结束\n");
            break;
        }
        
    }
    pthread_exit(EXIT_SUCCESS);
}

// 定义线程体1  使用临界资源的函数 称为临界区
void *task3(void *arg)
{
    while (1) // 输入信息
    {
        if (num > 0)
        {
            num--;
            printf("task3 执行一次，剩余%d次\n",num);
            usleep(1000);
        }else
        {
            printf("task3 执行结束\n");
            break;
        }
        
    }
    pthread_exit(EXIT_SUCCESS);
}
int main(int argc, char const *argv[])
{
    // 创建三个任务
    pthread_t tid1, tid2,tid3;

    if (pthread_create(&tid1, NULL, task1, NULL) != 0)
    {
        printf("task1 error");
        return -1;
    }
    if (pthread_create(&tid2, NULL, task2, NULL) != 0)
    {
        printf("task2 error");
        return -1;
    }
    if (pthread_create(&tid3, NULL, task3, NULL) != 0)
    {
        printf("task2 error");
        return -1;
    }

    // 主程序
    printf("tid1 = %#lx, tid2 = %#lx\n", tid1, tid2);

    // 阻塞回收线程资源
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);
    return 0;
}

        由于多个线程共同使用进程的资源，导致，线程在操作上容易出现不安全的状态

        对于例3 减减 含有多步操作 相对耗时 在多个线程对临界资源抢占使用时，会出现某一个线程的 减减 未结束另一个线程的 开始执行，就会导致数据出错。

        该现象称为 竞态

三、线程的同步互斥机制（用于解决竟态）

        如上例3所示，当其中一个线程正在访问全局变量时，可能会出现时间片用完的情况，另一个线程将数据进行更改后，再执行 该线程时，导致数据的不一致。这种现象称竞态，为了解决竞态，引入了同步互斥机制

3.1基本概念

1）竟态：同一个进程的多个线程在访问临界资源时，会出现抢占的现象，导致线程中的数据错误的现象称为竞态

2）临界资源：多个线程共同访问的数据称为临界资源，可以是全局变量、堆区数据、外部文件

3）临界区：访问临界资源的代码段称为临界区

4）粒度：临界区的大小

5）同步：表示多个任务有先后顺序的执行

6）互斥：表示在访问临界区时，同一时刻只能有一个任务，当有任务在访问临界区时，其他任务只能等待

3.2线程互斥

1、在C语言中，线程的互斥通过互斥锁来完成

2、互斥锁：本质上是一种临界资源，但互斥锁在同一时刻只能被一个线程使用，当一个线程试图去锁定另一个线程锁定的互斥所时，该线程会阻塞等待，直到使用互斥锁的线程解锁了该互斥锁

3、互斥锁的相关API

       #include <pthread.h>
       1、创建互斥锁：只需要定义一个pthread_mutex_t类型的变量，就创建了一个互斥锁

       pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER;           //静态初始化一个互斥锁

       2、初始化互斥锁

       int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
       功能：初始化一个互斥锁
       参数1：互斥锁变量的地址
       参数2：互斥锁的属性，一般填NULL，使用系统默认提供的属性
       返回值：总是成功，不会失败（成功返回0）
        
       3、获取锁资源

       int pthread_mutex_lock(pthread_mutex_t *mutex);
       功能：某个线程调用该函数表示获取锁资源（阻塞等待）
       参数：互斥锁的地址
       返回值：成功返回0，失败返回一个错误码
       
       4、释放锁资源

        int pthread_mutex_unlock(pthread_mutex_t *mutex);
       功能：将线程中的锁资源释放
       参数：互斥锁的地址
       返回值：成功返回0，失败返回一个错误码
       
        5、销毁锁资源
       int pthread_mutex_destroy(pthread_mutex_t *mutex);
       功能：销毁程序中的锁资源
       参数：互斥锁地址        

 4、对例3进行  互斥

#include <myhead.h>
#define N 2

int num = 520; // 临界资源

// 创建一个互斥锁
pthread_mutex_t mutex;

// 定义线程体1  使用临界资源的代码 称为临界区
void *task1(void *arg)
{
    while (1) // 输入信息
    {
        // 上锁  获取锁资源
        pthread_mutex_lock(&mutex);

        if (num > 0)
        {
            num--;
            printf("task1 执行一次，剩余%d次\n", num);
            usleep(1000);
        }
        else
        {
            printf("task1 执行结束\n");
            // 解锁 释放锁资源
            pthread_mutex_unlock(&mutex); // 结束前解锁 避免死锁
            break;
        }
        // 解锁 释放锁资源
        pthread_mutex_unlock(&mutex);
    }
    pthread_exit(EXIT_SUCCESS);
}

// 定义线程体2  使用临界资源的代码 称为临界区
void *task2(void *arg)
{
    while (1) // 输入信息
    {
        // 上锁  获取锁资源
        pthread_mutex_lock(&mutex);

        if (num > 0)
        {
            num--;
            printf("task2 执行一次，剩余%d次\n", num);
            usleep(1000);
        }
        else
        {
            printf("task2 执行结束\n");
            // 解锁 释放锁资源
            pthread_mutex_unlock(&mutex); // 避免死锁
            break;
        }
        // 解锁 释放锁资源
        pthread_mutex_unlock(&mutex);
    }
    pthread_exit(EXIT_SUCCESS);
}

// 定义线程体3  使用临界资源的函数 称为临界区
void *task3(void *arg)
{
    while (1) // 输入信息
    {
        // 上锁  获取锁资源
        pthread_mutex_lock(&mutex);

        if (num > 0)
        {
            num--;
            printf("task3 执行一次，剩余%d次\n", num);
            usleep(1000);
        }
        else
        {
            printf("task3 执行结束\n");
            // 解锁 释放锁资源
            pthread_mutex_unlock(&mutex); // 避免死锁
            break;
        }
        // 解锁 释放锁资源
        pthread_mutex_unlock(&mutex);
    }
    pthread_exit(EXIT_SUCCESS);
}
int main(int argc, char const *argv[])
{
    //初始化锁
    pthread_mutex_init(&mutex, NULL);

    // 创建三个任务
    pthread_t tid1, tid2, tid3;

    if (pthread_create(&tid1, NULL, task1, NULL) != 0)
    {
        printf("task1 error");
        return -1;
    }
    if (pthread_create(&tid2, NULL, task2, NULL) != 0)
    {
        printf("task2 error");
        return -1;
    }
    if (pthread_create(&tid3, NULL, task3, NULL) != 0)
    {
        printf("task2 error");
        return -1;
    }

    // 主程序
    printf("tid1 = %#lx, tid2 = %#lx\n", tid1, tid2);

    // 阻塞回收线程资源
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);

    // 销毁锁资源
    pthread_mutex_destroy(&mutex);
    return 0;
}

3.3死锁

1、概念：在多线程编程中，死锁是一种情况，其中两个或多个线程被永久阻塞，因为每个线程都在等待其他线程释放它们需要的资源。在C语言中，这通常涉及互斥锁(mutexes)，当多个互斥锁被不同的线程以不同的顺序获取时，很容易发生死锁。

2、产生条件：

1） 互斥条件：资源不能被多个线程共享，只能被一个线程在任一时刻所使用。
2） 持有和等待条件：一个线程至少持有一个资源，并且正在等待获取一个当前被其他线程持有的资源。
3.）不可抢占条件：资源不能被强制从一个线程抢占到另一个线程，线程必须自愿释放它的资源。
4.）循环等待条件：存在一个线程（或多个线程）的集合{P1, P2, ..., Pn}，其中P1正在等待P2持有的资源，P2正在等待P3持有的资源，依此类推，直至Pn正在等待P1持有的资源。

3、例4：死锁示例

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

pthread_mutex_t lock1, lock2;

void* thread1(void* arg) {
    pthread_mutex_lock(&lock1);
    sleep(1); // 确保线程2能锁住lock2
    pthread_mutex_lock(&lock2);
    printf("Thread 1\n");
    pthread_mutex_unlock(&lock2);
    pthread_mutex_unlock(&lock1);
    return NULL;
}

void* thread2(void* arg) {
    pthread_mutex_lock(&lock2);
    sleep(1); // 确保线程1能锁住lock1
    pthread_mutex_lock(&lock1);
    printf("Thread 2\n");
    pthread_mutex_unlock(&lock1);
    pthread_mutex_unlock(&lock2);
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_mutex_init(&lock1, NULL);
    pthread_mutex_init(&lock2, NULL);
    pthread_create(&t1, NULL, thread1, NULL);
    pthread_create(&t2, NULL, thread2, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_mutex_destroy(&lock1);
    pthread_mutex_destroy(&lock2);
    return 0;
}

4、避免死锁的策略：

1.）避免持有和等待：尽可能让线程在开始执行前一次性获取所有必需的资源。
2.）资源排序：规定一个全局顺序来获取资源，并且强制所有线程按这个顺序获取资源。
3.）使用超时：在尝试获取资源时使用超时机制，这样线程在等待过长时间后可以放弃，回退，并重新尝试。
4.）检测死锁并恢复：运行时检测死锁的存在，一旦检测到死锁，采取措施（如终止线程或回滚操作）来解决。

 3.4线程同步        

1、多个线程任务有顺序的执行，由于多个任务有顺序的执行了，那么在同一时刻，对临界资源的访问就只一个线程

2、线程同步文件的经典问题是:生产者消费者问题

        对于该问题而言，需要先执行生产者任务，然后执行消费者任务

3、对于线程同步问题，有两种机制来完成:无名信号量、条件变量

3.5线程同步 无名信号量

1、无名信号量本质上也是一个特殊的临界资源

2、无名信号量中维护了一个value值，该值表示能够申请的资源个数，当该值为0时，申请资源的线程将处于阻塞，直到其他线程将该无名信号量中的value值增加到大于0时即可

3、无名信号量API

1、创建无名信号量：只需要定义一个 sem_t 类型的变量，就创建了一个无名信号量
    sem_t  sem;
2、初始化无名信号量
           #include <semaphore.h>

       int sem_init(sem_t *sem, int pshared, unsigned int value);
       功能：完成对无名信号量的初始化工作
       参数1：要被初始化的无名信号量地址
       参数2：无名信号量适用情况
           0：表示多线程之间
           非0：表示多进程间同步
        参数3：无名信号量的资源初始值
        返回值：成功返回0，失败返回-1并置位错误码

3、申请资源：P操作，将资源减1操作
           #include <semaphore.h>

       int sem_wait(sem_t *sem);
       功能：申请无名信号量中的资源，使得该信号量中的value-1
       参数：无名信号量地址
       返回值：成功返回0，失败返回-1并置位错误码

4、释放资源：V操作，将资源加1操作
               #include <semaphore.h>

       int sem_post(sem_t *sem);
       功能：将无名信号量中的资源加1操作
       参数：无名信号量地址
       返回值：成功返回0，失败返回-1并置位错误码

5、销毁无名信号量
       #include <semaphore.h>

       int sem_destroy(sem_t *sem);
       功能：销毁一个无名信号量
       参数：无名信号量地址
       返回值：成功返回0，失败返回-1并置位错误码

 4、同步  无名信号量 示例

未 使用 无名信号量

#include <myhead.h>

//创建生产者线程
void * task1(void *arg)
{
    int num = 5;
    while (num--)
    {
        printf("%#lx:执行一次生产\n",pthread_self());
        sleep(1);
    }
    pthread_exit(EXIT_SUCCESS);
}

//创建消费者线程
void * task2(void *arg)
{
    int num = 5;
    while (num--)
    {
        printf("%#lx:执行一次消费\n",pthread_self());
    }
    pthread_exit(EXIT_SUCCESS);
}
int main(int argc, char const *argv[])
{
    pthread_t tid1, tid2;
    if (pthread_create(&tid1, NULL, task1, NULL) != 0)
    {
        printf("task1 error");
        return -1;
    }
    if (pthread_create(&tid2, NULL, task2, NULL) != 0)
    {
        printf("task1 error");
        return -1;
    }

    pthread_join(tid2, NULL);
    pthread_join(tid1, NULL);
    return 0;
}

 

 使用 无名信号量

#include <myhead.h>

//1、创建无名学号量
sem_t sem;

//创建生产者线程
void * task1(void *arg)
{
    int num = 5;
    while (num--)
    {
        
        printf("%#lx:执行一次生产\n",pthread_self());
        //4、释放资源 无名信号量资源加1 允许消费者a线程执行
        sem_post(&sem);
    }
    pthread_exit(EXIT_SUCCESS);
}

//创建消费者线程
void * task2(void *arg)
{
    int num = 5;
    while (num--)
    {
        //3、申请资源
        sem_wait(&sem); //阻塞等待  生产者线程释放 无名信号量资源
        //当无名信号量资源 为1时 执行 减1
        //因为 无名信号量 初始资源为0  即便先执行消费者线程也会被阻塞
        printf("%#lx:执行一次消费\n",pthread_self());
    }
    pthread_exit(EXIT_SUCCESS);
}
int main(int argc, char const *argv[])
{
    //2、初始化无名信号量
    sem_init(&sem,0,0);
    //第一个0   表示同步用于多线程间
    //第二e个0  表示无名信号量初始资源为0

    pthread_t tid1, tid2;
    if (pthread_create(&tid1, NULL, task1, NULL) != 0)
    {
        printf("task1 error");
        return -1;
    }
    if (pthread_create(&tid2, NULL, task2, NULL) != 0)
    {
        printf("task1 error");
        return -1;
    }

    pthread_join(tid2, NULL);
    pthread_join(tid1, NULL);

    //5、销毁无名信号量
    sem_destroy(&sem);
    return 0;
}

3.6 线程同步 条件变量

1、条件变量的本质也是一个特殊的临界资源

2、条件变量中维护了一个队列，想要执行的消费者线程，需要先进入等待队列中，等生产者线程进行唤醒后，依次执行。这样就可以做到一个生产者和多个消费者之间的同步，但是消费者和消费者之间在进入等待队列这件事上是互斥的。

3、条件变量的API

1）创建条件变量
    只需要定义一个pthread_cond_t类型的变量，就创建了一个条件变量
    pthread_cond_t  cond;

2）初始化条件变量
       int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
       功能：初始化一个条件变量
       参数1：条件变量的地址
       参数2：条件变量的属性，一般填NULL
       返回值：     成功返回0，失败返回非0错误码
       

3）将消费者线程放入到等待队列中       

       int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
       功能：消费者线程进入等待队列中
       参数1：条件变量的地址
       参数2：互斥锁的地址：因为多个消费者线程在进入等待队列上是竞态的
       返回值：     成功返回0，失败返回非0错误码

4）唤醒消费者线程                                

       int pthread_cond_signal(pthread_cond_t *cond);
       功能：唤醒等待队列中的第一个消费者线程
       参数：条件变量的地址
       返回值： 成功返回0，失败返回非0错误码       

       

       int pthread_cond_broadcast(pthread_cond_t *cond);
       功能：唤醒所有等待队列中的消费者线程
       参数：条件变量的地址
       返回值： 成功返回0，失败返回非0错误码
       

    
5）销毁条件变量           
        int pthread_cond_destroy(pthread_cond_t *cond);
        功能：销毁一个条件变量
        参数：条件变量的地址
        返回值： 成功返回0，失败返回非0错误码

 4、条件变量 示例

#include <myhead.h>

//1、定义一个条件变量
pthread_cond_t cond;

//11、创建互斥锁
pthread_mutex_t mutex;

// 创建生产者线程
void *task1(void *arg)
{
    // int num = 5;
    // while (num--)
    // {
    //     sleep(1);
    //     printf("%#lx:执行一次生产\n", pthread_self());

    //     //4、唤醒消费者线程(单个)
    //     pthread_cond_signal(&cond);
    // }

    sleep(3);

    printf("%#lx:执行5次生产\n", pthread_self());
    pthread_cond_broadcast(&cond);//4、唤醒消费者线程(全部)
    pthread_exit(EXIT_SUCCESS);
}

// 创建消费者线程
void *task2(void *arg)
{
    //33、获取互斥锁
    pthread_mutex_lock(&mutex);

    //3、请求进入等待队列
    pthread_cond_wait(&cond,&mutex);

    printf("%#lx:执行一次消费\n", pthread_self());

    //44、释放互斥锁
    pthread_mutex_unlock(&mutex);

    pthread_exit(EXIT_SUCCESS);
}
int main(int argc, char const *argv[])
{
    //2、初始化统计变量
    pthread_cond_init(&cond,NULL);

    //22、初始化互斥锁
    pthread_mutex_init(&mutex,NULL);

    pthread_t tid1, tid2, tid3, tid4, tid5, tid6;
    if (pthread_create(&tid1, NULL, task1, NULL) != 0)
    {
        printf("task1 error");
        return -1;
    }
    if (pthread_create(&tid2, NULL, task2, NULL) != 0)
    {
        printf("task1 error");
        return -1;
    }
    if (pthread_create(&tid3, NULL, task2, NULL) != 0)
    {
        printf("task1 error");
        return -1;
    }
    if (pthread_create(&tid4, NULL, task2, NULL) != 0)
    {
        printf("task1 error");
        return -1;
    }
    if (pthread_create(&tid5, NULL, task2, NULL) != 0)
    {
        printf("task1 error");
        return -1;
    }
    if (pthread_create(&tid6, NULL, task2, NULL) != 0)
    {
        printf("task1 error");
        return -1;
    }

    //输出每个线程的线程号
    printf("tid2=%#lx tid3=%#lx tid4=%#lx tid5=%#lx tid6=%#lx \n",tid2,tid3,tid4,tid5,tid6);

    pthread_join(tid2, NULL);
    pthread_join(tid1, NULL);
    pthread_join(tid3, NULL);
    pthread_join(tid4, NULL);
    pthread_join(tid5, NULL);
    pthread_join(tid6, NULL);

    //5、销毁条件变量
    pthread_cond_destroy(&cond);

    //55、销毁锁资源
    pthread_mutex_destroy(&mutex);

    return 0;
}

 

子座
关注
  • 15
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
linux线程间的同步与互斥知识点总结
09-14
在Linux系统中，线程间的同步与互斥是多线程编程中至关重要的概念，它们确保了多个线程在并发执行时对共享资源的有效管理和安全访问。本文将深入探讨这两个主题。 首先，线程同步是指通过特定机制协调线程的执行...
day17_线程创建、线程同步、线程状态.pdf
11-02
Java多线程编程基础知识点 本节课主要讲解了Java多线程编程的基础知识，包括线程的概念、线程与进程的区别、多线程的随机性、Java程序的进程中的线程、线程的创建方式、线程的执行流程、线程内存图等。 1. 进程与...
Day 22多线程、线程通信、线程池和Lambda表达式
12-22
线程通信和线程池则是多线程编程中控制并发执行和优化资源分配的关键概念，而Lambda表达式则是一种简化函数式编程的语法结构。 1. **多线程** 多线程是程序设计中并行处理的一种方式。在Java中，可以通过继承`...
深度学习（基于Tensorflow2.0）学习笔记——Day2
01-20
本篇学习笔记主要关注如何在Tensorflow2.0环境下开始深度学习的学习和实践。 【深度学习基础知识回顾】 在开始实战前，对深度学习的基础知识进行回顾是必要的。这包括神经网络的基本概念、反向传播算法、损失函数...
python 08、多任务编程多线程 3-1_进程间通信、同步互斥、threading线程_Day03_AM.mp4
03-09
python 08、多任务编程多线程 3-1_进程间通信、同步互斥、threading线程_Day03_AM.mp4
qmt量化交易策略小白学习笔记第61期【qmt编程之期权行情数据--get_market_data_ex函数】
fanglue3705的博客
09-09 571
获取期权行情数据 获取期权最新数据，首先需要进行数据订阅。完成合约订阅后，用get_market_data_ex函数即可提取相关信息。这个过程包含两大步骤： 第一，通过订阅操作确保能接收到你感兴趣的期权合约的更新； 第二，调用get_market_data_ex函数来实际获取并处理这些订阅到的数据,如果需要用到历史数据或过期合约数据，需要使用download_history_data进行下载。
区块链学习笔记2--区块链技术的形成 以太坊
weixin_61074128的博客
09-10 219
以太坊的定义：以太坊是运行在一个计算机网络中的软件，他确保数据以及智能合约的小程序可以在没有宗信协调者的情况下，被所有网络中的计算机复制和处理。以太坊的改进： 交易速度加快；pow+pos算法，逐步向pos算法过渡；智能合约：不受人为因素影响，没有黑幕；比特币的出现让经济贸易变得简单，而比特币系统的不足，也同样被人诟病。于是出现了致力解决比特币不足的“V神”。以太坊的愿景是创建一个无法停止，抗屏蔽（审查）和自我维持的去中心化世界计算机。比特币的不足：交易速度慢；仅仅完成了货币的去中心化。
sheng的学习笔记-AI-规则学习（rule learning）
coldstarry的专栏
09-09 818
机器学习中的“规则”(rule)通常是指语义明确、能描述数据分布所隐含的客观规律或领域概念、可写成“若……，则……”形式的逻辑规则。​“规则学习”(rule learning)是从训练数据中学习出一组能用于对未见示例进行判别的规则。一条规则形如：在数理逻辑中“文字”专指原子公式(atom)及其否定。与神经网络、支持向量机这样的“黑箱模型”相比，规则学习具有更好的可解释性，能使用户更直观地对判别过程有所了解。另一方面，数理逻辑具有极强的表达能力，绝大多数人类知识都能通过数理逻辑进行简洁的刻画和表达。
Android Fragment 学习备忘
sdaujz的博客
09-08 372
1.fragment的动态添加与管理：
【学习笔记】SSL证书之前向保密
Taki_UP的博客
09-10 480
本篇介绍了密码学中前向保密（Forward Secrecy）的相关内容
9.6学习记录+三场笔试
m0_62956971的博客
09-07 1149
短作业优先。
EmguCV学习笔记 C# 第10章 人脸识别
UruseiBest 的技术专栏
09-05 586
EmguCV是一个基于OpenCV的开源免费的跨平台计算机视觉库,它向C#和VB.NET开发者提供了OpenCV库的大部分功能。10.1 人脸检测 CascadeClassifier类。10.2.2.1 EigenFaceRecgnizer类。10.2.1 LBPHFaceRecgnizer类。10.2 人脸识别 FaceRecgnizer类。教程配套文件及相关说明。
《数字信号处理》学习05-单位冲击响应与系统响应
码到成龚的博客
09-08 1185
一，单位冲激响应二，LTI系统对任意序列的系统响应三，LTI系统的性质​ 在《信号与系统》中，离散时间线性时不变系统用 唯一表征： ：单位冲击响应（或称为单位抽样响应）。输入序列是单位冲击序列，输出序列是初始状态为0时系统的输出。 1，h虽然不是特定单词的缩写，但在信号处理领域的使用已经成为一种约定，代表了系统的单位冲击响应，因此，一般用来代表离散时间LTI系统的单位冲击响应。 2，之所以强调输出序列是在初始状态为0时的系统输出，是因为在“初始状态为0”时输出序列完全基于输入序列和单
Vue响应式进阶常用API学习
weixin_44072254的博客
09-06 860
reactive()的浅层浅层响应式，和reactive()不同，这里没有深层级的转换：一个浅层响应式对象里只有根级别的属性是响应式的。readonly()的浅层作用形式,只有根级别是只读不可更改的，根级别以下的可更改，只是视图不会更新，但值改变了。shallowRef是浅层引用,只会跟踪原始对象的引用,不会跟踪原始对象的属性。创建一个自定义的 ref，显式声明对其依赖追踪和更新触发的控制方式。的副作用，这通常在对浅引用的内部值进行深度变更后使用。代理对象，并返回该代理对象对应的原始对象。
【C++深入学习】日期类函数从无到有实现
Harper.Lee的博客
09-04 1312
本文主要是通过之前所学的类和对象等的知识从无到有地实现一个简单的日期计算机程序！
元学习之如何学习
前行居士
09-06 876
在元学习里面，我们通常会考虑要 让机器自己学习网络的架构，让机器自己学习初始化的参数，让机器自己决定学习率等等，我 们期待它们是可以通过学习算法被学出来的，而不是像机器学习一样我们人为设定的。如果这个分类是好的，那就代表 我们的L的规则是好的，反之如果这个分类是不好的，就代表说这个学习算法是不好的。最后，元学习的第三个任务就是要找一个学习算法，即找一个ϕ让损失越小越好。这个问题是因为我们的训练单位是任务，所以可以用训练的任务里面的测试数据，训练的任 务里面的测试数据是可以在元学习的训练的过程中被使用到的。
语言课学习系统的设计与实现
最新发布
weixin_66784080的博客
09-10 575
摘 要 互联网发展至今，无论是其理论还是技术都已经成熟，而且它广泛参与在社会中的方方面面。它让信息都可以通过网络传播，搭配信息管理工具可以很好地为人们提供服务。针对高校教师成果信息管理混乱，出错率高，信息安全性差，劳动强度大，费时费力等问题，采用语言课学习系统可以有效管理，使信息管理能够更加科学和规范。 语言课学习系统使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理语言课学习系统信息，查看语言课学习系统信息，管理语言课学习系统。 总之，
SSD学习内容记录
陶二先生的专栏
09-10 712
固态硬盘 (SSD) 是基于半导体的 存储设备 ，依靠 闪存 在计算机系统中存储持久数据。在 SSD 中，每个内存芯片均由包含内存单元（也称为页或扇区）的块构建而成，而内存单元又包含内存位。与使用磁铁存储数据的磁性存储（例如 HDD 和软盘驱动器）不同，固态硬盘使用 NAND 芯片，这是一种非易失性存储技术，不需要任何电源来维护数据。HDD 由于盘片旋转和读/写头移动而具有固有的延迟和访问时间，而SSD没有移动部件，因此速度更快。SSD目前已超越HDD ，成为结构化数据 工作量的首选行业标准。
高级算法设计与分析 学习笔记4 二叉查找树
LI_XIAO_XING的博客
09-10 80
后继就是在这棵树中刚好比这个点大一位的节点。如果它有右子树就好办。没有的话，我们就要找让这个节点作为其左子树一部分的第一个节点。比如说13，它没有右子树，而且往上追溯一直都是右子树（都是比它小的）等到头一回发现是左子树的，那就是它的后继。有两个子树的，那就要找其右子树中最小的数（也就是直接后继）来当新的父节点。可以注意到这棵树的性能和初始选择的值很有关系。可以看到后面这种方法更好，虽然都是递归，但后者不需要一直调用函数。这种算法的复杂度显然是等于树高。左子树小于父节点小于右子树。这样可以让树尽量平衡一点。
Java多线程同步与通信解析-临界问题及解决方案
在多线程编程专题中，学习者会接触到如何创建和管理线程，以及如何使用同步机制来控制线程间的交互。此外，还有图形GUI编程、I/O编程和网络编程等高级主题。 Java图形GUI编程主要涉及AWT（Abstract Window Toolkit...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值