首页 > 其他分享 >20211316郭佳昊 《信息安全系统设计与实现(上)》 第八周学习总结

20211316郭佳昊 《信息安全系统设计与实现(上)》 第八周学习总结

时间:2023-10-29 16:33:05浏览次数:37  
标签:int void 信息安全 线程 郭佳昊 pthread 20211316 include row

一、任务要求

[ 1 ] 知识点归纳以及自己最有收获的内容,选择至少2个知识点利用chatgpt等工具进行苏格拉底挑战,并提交过程截图,提示过程参考下面内容 (4分)
我在学***X知识点,请你以苏格拉底的方式对我进行提问,一次一个问题

核心是要求GPT:请你以苏格拉底的方式对我进行提问

然后GPT就会给你提问,如果不知道问题的答案,可以反问AI:你的理解(回答)是什么?

如果你觉得差不多了,可以先问问GPT:针对我XXX知识点,我理解了吗?

GPT会给出它的判断,如果你也觉得自己想清楚了,可以最后问GPT:我的回答结束了,请对我的回答进行评价总结,让它帮你总结一下。

[ 2 ] 问题与解决思路,遇到问题最先使用chatgpt等AI工具解决,并提供过程截图(3分)

[ 3 ] 实践过程截图,代码链接(2分)

[ 4 ] 其他(知识的结构化,知识的完整性等,提交markdown文档,使用openeuler系统等)(1分)

二、知识点总结

并行计算

并行计算是一种计算方案,它尝试使用多个执行并行算法的处理器更快速地解决问题。

顺序算法与并行算法
  • 顺序算法:用一个begin-end代码块列出,可能包含多个步骤,每个步骤通过单个任务依次执行,所有步骤完成时,算法结束。
  • 并行算法:使用cobegin-coend代码块列出,所有任务并行执行。
并行性与并发性

在单CPU系统中,并发性是通过多任务处理来实现的。

线程

线程的原理

线程是某进程同一地址空间上的独立执行单元

线程的优点
  • 线程创建和切换速度更快
  • 线程的响应速度更快
  • 线程更适合并行计算
线程的缺点
  • 由于地址空间共享,线程需要来自用户的明确同步
  • 许多库函数可能对线程不安全
  • 单CPU系统上,使用线程解决问题实际上比使用顺序程序慢,原因在于运行时创建线程和切换上下文的系统开销

线程操作

线程的执行轨迹与进程类似,线程可以在内核模式或用户模式下执行,在用户模式下,线程在进程的相同地址空间中执行

线程管理函数

创建线程

使用pthread_create()函数创建线程。成功返回0,失败则返回错误代码。
int pthread_create(pthread_t *pthread_id,pthread_attr_t *attr,void *(*func)(void*),void *arg)
参数如下:

  • pthread_id是指向pthread_t类型变量的指针,会被操作系统内核分配的唯一线程ID填充
  • attr是指向另一种不透明数据类型的指针
  • func是要执行的新线程函数的入口地址
  • arg是指向线程函数参数的指针,可写为void *func(void *arg)
线程ID

线程ID是一种不透明的数据类型,取决于实现情况,不直接比较线程ID,可以用pthread_equal()函数进行比较int pthread_equal (pthread_t t1, pthread_t t2)线程不同返回0,否则返回非0。

线程终止

线程函数结束后,线程即终止,或调用int pthread_exit (void *status)进行显式终止,返回0正常终止,否则异常终止。

线程链接

一个线程可以等待另一个线程的终止,通过int pthread_join (pthread_t thread, void **status_ptr)终止线程的退出状态以status_ptr返回。

线程示例程序

用线程计算矩阵的和
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define N 4
int A[N][N], sum[N];
void *func(void *arg)
{
    int j, row;
    pthread_t tid = pthread_self(); // get thread ID number 
    row = (int)arg;	// get row number from arg
    printf("Thread %d [%lu] computes sum of row %d\n", row, tid, row); 
    for (j=0; j<N; j++)
    {
        sum[row] += A[row][j];
    }
    printf("Thread %d [%lu] done sum[%d] = %d\n",row, tid, row, sum[row]);
    pthread_exit((void*)0); // thread exit: 0=normal termination
}

int main (int argc, char *argv[])
{
    pthread_t thread[N];	// thread IDs
    int i, j, r, total = 0;
    void *status;
    printf("Main: initialize A matrix\n");

    for (i=0; i<N; i++)
    {
        sum[i] = 0;
        for (j=0; j<N; j++)
        {
            A[i][j] = i*N + j + 1;
            printf("%4d" ,A[i][j]);
        }
    printf("\n");
    }
    printf("Main: create %d threads\n", N);
    for(i=0; i<N; i++)
    {
        pthread_create(&thread[i], NULL, func, (void *)i);
    }
    printf("Main: try to join with threads\n");
    for(i=0; i<N; i++) 
    {
        pthread_join(thread[i], &status);
        printf("Main: joined with %d [%lu]: status=%d\n",i, thread[i], (int)status);
    }
    printf("Main: compute and print total sum:"); 
    for (i=0; i<N; i++)
    {
        total += sum[i];
    }
    printf("tatal = %d\n", total); 
    pthread_exit(NULL);
}

用线程快速排序
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <math.h>
#define N 4
double A[N][N+1]; 
pthread_barrier_t barrier;

int print_matrix()
{
    int i, j;
    printf("----------------------------\n");
    for(i=0; i<N; i++)
    {
        for(j=0; j < N+1; j++) 
            printf("%6.2f	", A[i][j]);

        printf("\n");
    }
}

void *ge(void *arg) // threads function: Gauss elimination
{
    int i, j, prow;
    int myid = (int)arg;
    double temp, factor;
    for(i=0; i<N-1; i++)
    {
        if (i == myid)
        {
            printf("partial pivoting by thread %d on row %d: ", myid, i);
            temp = 0.0; prow = i;
            for (j=i; j<=N; j++)
            {
                if (fabs(A[j][i]) > temp)
                {
                    temp = fabs(A[j][i]); 
                    prow = j;
                }
            }
        
            printf("pivot_row=%d pivot=%6.2f\n", prow, A[prow][i]); 
            if (prow != i)	// swap rows
            {
                for (j=i; j<N+1; j++)
                {
                    temp = A[i][j];
                    A[i][j] = A[prow][j];
                    A[prow][j] = temp;
                }
            }
        }
        // wait for partial pivoting done 
        pthread_barrier_wait(&barrier); 
        for(j=i+1; j<N; j++)
        {
            if (j == myid)
            {
                printf("thread %d do row %d\n", myid, j); 
                factor = A[j][i]/A[i][i]; 
                for (int k=i+1; k<=N; k++)
                    A[j][k] -= A[i][k]*factor;
                A[j][i] = 0.0;
            }     
        }
        // wait for current row reductions to finish 
        pthread_barrier_wait(&barrier);
        if (i == myid)
            print_matrix();
    }
}

int main(int argc, char *argv[])
{
    int i, j;
    double sum;
    pthread_t threads[N];
    printf("main: initialize matrix A[N][N+l] as [A|B]\n");
    for (i=0; i<N; i++)
        for (j=0; j<N; j++)
            A[i][j] = 1.0;
    for (i=0; i<N; i++)
        A[i][N-i-1] = 1.0*N;
    for (i=0; i<N; i++)
    {
        A[i][N] = 2.0*N - 1;
    }
    print_matrix();	// show initial matrix [A|B]

    pthread_barrier_init(&barrier, NULL, N); // set up barrier

    printf("main: create N=%d working threads\n", N);
    for (i=0; i<N; i++)
    { 
        pthread_create(&threads[i], NULL, ge, (void *)i);
    }

    printf("main: wait for all %d working threads to join\n", N);
    for (i=0; i<N; i++)
    {
        pthread_join(threads[i], NULL);
    }

    printf("main: back substitution :");
    for (i=N-1; i>=0; i--)
    {
        sum = 0.0;
        for (j=i+1; j<N; j++)
            sum += A[i][N];
            A[i][N] = (A[i][N]- sum)/A[i][i];
    }
    // print solution
    printf("The solution is :\n");
    for(i=0; i<N; i++)
    {
        printf("%6.2f  ",A[i][N]);
    }
    printf("\n");
}

线程同步

由于线程在进程的同一地址空间中执行,它们共享同一地址空间中的所有全局变量和数据结构,当多个线程试图修改同一共享变量或数据结构时,如果修改结果取决于线程的执行和、顺序,则称之为竞态条件。

互斥量

在Pthread中,锁被称为互斥量,意思是相互排斥,互斥变量用pthread_mutex_t类型声明的,使用前需要初始化

死锁预防

死锁是一个状态,在这种状态下,许多执行实体相互等待,无法继续进行下去

信号量

信号量说是进程同步的一般机制,计数信号量是一种数据结构

struct sem{
   int value;
   struct process *queue
}s

三、苏格拉底挑战

标签:int,void,信息安全,线程,郭佳昊,pthread,20211316,include,row
From: https://www.cnblogs.com/GJH6/p/17795989.html

相关文章

  • [学习笔记]--信息安全
    信息系统安全属性安全属性属性描述保密性最小授权原则,防暴露,信息加密,物理保密完整性安全协议,校验码,密码校验,数字签名,公证可用性综合保障(IP过滤,业务流程控制,路由选择控制,审计跟踪)不可抵赖性数字签名对称加密与非对称加密对称加密:加密和......
  • 《信息安全系统设计与实现》第八周学习笔记
    《信息安全系统设计与实现》第八周学习笔记第四章并发编程并行计算尝试使用多个执行并行算法的处理器更快速的解决问题顺序算法与并行算法顺序算法:所有步骤通过单个任务依次执行,每次执行一个步骤,当所有步骤执行完成时,算法结束。并行算法:cobegin-coend代码块来指定独立......
  • 《信息安全系统设计与实现》学习笔记7
    第四章并发编程并行计算要求解某个问题,先要设计一种算法,描述如何一步步地解决问题,然后用计算机程序以串行指令流的形式实现该算法。在只有一个CPU的情况下,每次只能按顺序执行某算法的一个指令和步骤。但是,基于分治原则(如二又树查找和快速排序等)的算法经常表现出高度的并行性......
  • 《信息安全与设计》第四章学习笔记
    《信息安全与设计》第四章学习笔记第四章并发编程并行计算导论顺序算法与并行算法顺序算法:所有步骤通过单个任务依次执行,每次执行一个步骤,当所有步骤执行完成时,算法结束。并行算法:cobegin-coend代码块来指定独立任务,所有任务都是并行执行的,紧接着代码块的下一个步骤将只在......
  • 《信息安全系统设计与实现》第八周学习笔记
    并行计算导论顺序算法与并行算法并行性与并发性通常,并行算法只识别可并行执行的任务,但是它没有规定如何将任务映射到处理组件。在理想情况下,并行算法中的所有任务都应该同时实时执行CPU系统中,并发性是通过多任务处理来实现的线程线程的原理线程是操作系统能够进行运算......
  • 《信息安全系统设计与实现》第八周学习笔记
    一、课程内容第三章学习1、并行计算是一种计算方案,它尝试使用多个执行并行算法的处理器更快速的解决问题顺序算法与并行算法并行性与并发性并行算法只识别可并行执行的任务。CPU系统中,并发性是通过多任务处理来实现的2、线程线程的原理:某进程同一地址空间上的独立执行单......
  • 20211129《信息安全系统设计与实现》第四章学习笔记
    一、任务内容自学教材第4章,提交学习笔记(10分)1.知识点归纳以及自己最有收获的内容,选择至少2个知识点利用chatgpt等工具进行苏格拉底挑战,并提交过程截图,提示过程参考下面内容(4分)“我在学***X知识点,请你以苏格拉底的方式对我进行提问,一次一个问题”核心是要求GPT:“请你以苏格拉......
  • GB/T 39412-2020《信息安全技术 代码安全审计规范》解析
    ​代码审计标准GB/T39412-2020《信息安全技术代码安全审计规范》是中国国家标准之一,旨在规范信息安全技术领域中代码安全审计的相关流程、技术和方法。该标准适用于指导代码安全审计相关工作,旨在帮助相关安全审计人员更好地识别和评估代码中的安全缺陷,提高软件系统的安全性。......
  • 信息安全系统设计与实现——学习笔记7
    任务详情:自学教材第11章,提交学习笔记Part1知识点归纳&GPT提问知识点归纳Part2问题与解决思路问题gpt解决Part3实践过程截图Part4其他......
  • 信息保密 追朔 信息安全 公司内外 水印 暗水印 盲水印
     公司内部系统一般考虑到信息泄密,都有系统水印和网页水印,文档水印。有些水印看不见,所以别拍照,乱截图随意传播。别给自己找麻烦。培训视频,技术文档,客户文档等都有可能使用了暗水印,不为肉眼所见。 阿里巴巴内网的不可见水印用的是什么算法?https://new.qq.com/rain/a/2022030......