线程和指针

//1.thread

#pragma mark - 线程间共享指针

/*

  两个向量指针，sum字段（持有点积），length字段（定点积函数要用的向量的长度）

  length字段表示线程处理的向量的部分，不是整个向量的长度

 */

pthread_mutex_t mutexSum;//全局区域声明它以充许多个线程访问

typedef struct {

    double *vectorA;

    double *vectorB;

    double sum;

    int length;

}VectorInfo;

/*

 VectorInfo指针和计算点积向量的起始索引

 */

typedef struct {

    VectorInfo *info;

    int beginningIndex;

}Product;

/*

 所有线程会在同一时间对两个向量进行计算，但是它们访问的是向量的不同部分，所以不会有冲突。

 每个线程会计算自己负责的那些向量的各，不过，这个各需要累加到VectorInfo结构体的sum字段上。

 多个线程可能会同时访问sum字段，所以需要用互斥锁保护数据，下面会声明互斥锁。同一时间互斥锁只允许

 一个线程访问受保护的变量，声明互斥锁保护sum变量，在全局区域声明它以充许多个线程访问

 */

void dotProduct(void *prod){

    Product *product = (Product *)prod;

    VectorInfo *vectorInfo = product->info;

    int beginningIndex = product->beginningIndex;

    int endingIndex = beginningIndex +vectorInfo->length;

    

    double total = 0;

    for (int i = beginningIndex; i<endingIndex;i++) {

        total +=(vectorInfo->vectorA[i] *vectorInfo->vectorB[i]);

    }

    

    pthread_mutex_lock(&mutexSum);

    vectorInfo->sum += total;

    pthread_mutex_unlock(&mutexSum);

    

    pthread_exit((void *)0);

}

#define NUM_THREADS 4

void threadExample(){

    VectorInfo vectorInfo;

    double vectorA[]={1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0

    };

    double vectorB[]={1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0

    };

    

    vectorInfo.vectorA = vectorA;

    vectorInfo.vectorB = vectorB;

    vectorInfo.length = 4;

    

    //创建4个元素的线程数组，初始化互斥锁和线程的属性字段

    pthread_t threads[NUM_THREADS];

    

    void *status;

    pthread_attr_t attr;

    

    pthread_mutex_init(&mutexSum,NULL);

    pthread_attr_init(&attr);

    pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_JOINABLE);

    

    int returnValue;

    int threadNumber;

    

    //每次迭代都会创创建一个新的Product实例，会把vectorInfo的地址和一个基于threadNumber得到的唯一索引赋给它。

    //然后创建线程

    for (threadNumber = 0; threadNumber <NUM_THREADS; threadNumber ++) {

        Product *product = (Product *)malloc(sizeof(Product));

        product->beginningIndex = threadNumber *4;

        product->info = &vectorInfo;

        returnValue = pthread_create(&threads[threadNumber], &attr, (void *)dotProduct,(void *)product);

        

        if (returnValue) {

            printf("ERROR,Unable to create thread:%d\n",returnValue);

            exit(-1);

        }

    }

    

  //loop结束，销毁线程属性和互斥锁，for循环确保程序等到4个线程都完成后打印点积

    pthread_attr_destroy(&attr);

    for (int i =0; i<NUM_THREADS; i++) {

        pthread_join(threads[i], &status);

    }

    pthread_mutex_destroy(&mutexSum);

    printf("Dot Product sum:%lf\n",vectorInfo.sum);

    pthread_exit(NULL);

}

//factorial

#pragma mark - 用函数指针支持回调

/*

1.回调定义：如果一个线程的事件导致另一个线程的函数调用。将回调函数的指针传递给线程，

  而函数的某个事件会引发对回调函数的调用，这种方法在GUI应用程序中处理用户线程事件很有用。

2.factorial:阶乘，结果和回调函数指针。用这些数据计算阶乘，把结果保存到result字段，

  调用回调函数，然后结束线程

 */

typedef struct _factorialData{

    int number;

    int result;

    void (*callBack)(struct_factorialData *);

}FactorialData;

void factorial(void *agrs){

    FactorialData *factorialData = (FactorialData*)agrs;

    void(*callBack)(FactorialData*);

    

    int number = factorialData->number;

    callBack = factorialData->callBack;

    

    int num = 1;

    for (int i =1; i<=number; i++) {

        num *= i;

    }

    

    factorialData->result = num;

    callBack(factorialData);

    pthread_exit(NULL);

    

}

void startThread(FactorialData *data){

    pthread_t thread_id;

    int thread = pthread_create(&thread_id,NULL,(void *(*)(void *))factorial, (void *)data);

    if (thread) {

        printf("ERROR,Unable to create thread:%d\n",thread);

        exit(-1);

    }

}

void callBackFunction(FactorialData *factorialData){

    printf("Factorial is %d \n",factorialData->result);

}

void initThread(){

    FactorialData *datas = (FactorialData *)malloc(sizeof(FactorialData));

    

    if (!datas) {

        printf("Faild to allocate memory\n");

        return  ;

    }

    datas->number = 8;

    datas->callBack =callBackFunction;

    

    startThread(datas);

    

    sleep(2000);//为所有线程正常结束提供足够的时间

}

//2.pointer alias

/*

 指针的别名，如果两个指针引用同一内存地址，我们称一个指针是另一个指针的别名。别名并不罕见，不过可能会引发一些问题

 强别名：它不允许一种类型的指针成为另一种类型的指针的别名

 

 Ｃ是类型语言，在声明变量时就得为其指定类型，可以存在不同类型的多个变量

 有时可能需要把一种类型转换成另一种类型，这一般是通过类型转换实现的，不过也可能使用联合体，类型双关就是指这种绕开

 类型系统的技术

 如果转换涉及指针，可能会产生严重的问题。为了说明这种技术，函数会判断一个浮点数是否为正，

 这个可以正确工作，也不会涉及别名，因为没有用到指针

 */

typedef union _conversion{

    float fNum;

    unsigned int uiNum;

}Conversion;

int isPositivel(float number){

    Conversion conversion ={.fNum = number};

    return (conversion.uiNum & 0x80000000)==0;

}

float number = 3.25f;

unsigned int *ptrValue = (unsigned int *)&number;

unsigned int result = (*ptrValue & 0x80000000) == 0;

NSLog(@"result = %d",result);

/*3.

 restric关键字可以在声明指针时告诉编译器这个指针没有别名，这样就允许编译器产生更高效的代码。

  很多情况下这是通过缓存指针实现的，不过，编译器也可以选择不优化代码，如果用了别名，那么执代码会导致

  未定义行为，编译器不会因为破坏强别名假设而提供任何警告信息

 

 volatile关键字可以阻止运行时系统使用寄存器暂存端口值，每次访问端口都需要系统读写端口，而不是从寄存器中读

  取一个可能已经过期的值。

  如把所有变量声明为volatile,会阻碍编译器进行所有类型的优化

*/

void add(int size,double *restrict arr1,const double *restrict arr2){

    for (int i =0; i<size ; i++) {

        arr1[i] += arr2[i];

    }

}

    

/*4.判断机器的字节序,如在Intel PC上输出，这是小字节序架构，内存中分配：

    //100:78

    //101:56

    //102:34

    //103:12

*/

int num = 0x12345678;

char *pc = (char *)&num;

for (int i =0; i<4; i++) {

   NSLog(@"%p:%02x",pc,(unsignedchar)*pc++);

}

int main(int argc,constchar * argv[]) {

    threadExample();

    initThread();   

    double vector1[] = {1.1,2.2,3.3,4.4};

    double vector2[] = {1.1,2.2,3.3,4.4};

    double *vector3 = vector2;

    add(4,vector1,vector2);

    NSLog(@"%d",isPositivel(-3.2));

    return 0;

}