精华内容
下载资源
问答
  • 我想用C实现一个多线程的端口扫描,对每个ip都创建100个线程; 在main里for循环中创建线程,打印出来的参数(arg->min_port,arg->max_port)是没问题的, 但是在线程函数里打印出传进去的参数时,min_port与max_port...
  • Linux C语言多线程函数参数传入

    千次阅读 2019-02-15 00:20:55
    线程中函数参数由结构体指针传入 #include <pthread.h> #include <stdio.h> #include <stdlib.h> typedef struct { char name[20]; int time; int start; int end...

    线程中函数参数由结构体指针传入

    #include <pthread.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct
    {
    	char name[20];
    	int time;
    	int start;
    	int end;
    
    }RaceArg;
    
    void* th_fn(void *arg)
    {
    	RaceArg *r = (RaceArg*)arg;
    	int i;
    	for(i=r->start;i<=r->end;i++)
    	{
    		printf("%s(%lx) running %d\n",
    			r->name, pthread_self(),i);
    		usleep(r->time);
    	}
    }
    
    int main(void)
    {
    	int err;
    	pthread_t rabbit, turtle;
    
    	RaceArg r_a = {"rabbit", (int)(drand48()*10000000), 20, 50};
    
    	RaceArg t_a = {"turtle", (int)(drand48()*10000000), 10, 60};
    
    	if((err = pthread_create(&rabbit, NULL, th_fn, (void*)&r_a))!=0)
    	{
    		perror("pthread_create error");
    	}
    
    	if((err = pthread_create(&turtle, NULL, th_fn, (void*)&t_a))!=0)
    	{
    		perror("pthread_create error");
    	}
    
    
    	pthread_join(rabbit, NULL);
    	pthread_join(turtle, NULL);
    
    	printf("control thread id: %lx\n", pthread_self());
            printf("finished\n");
    
    	return 0;
    }
    
    

     

    展开全文
  • C语言多线程操作

    千次阅读 2019-11-27 22:39:38
    C语言多线程操作 目录 C语言多线程 创建线程 终止线程 注意 信号量机制 参考博文: 返回目录 C语言多线程 多线程是多任务处理的一种特殊形式,多任务处理允许让电脑同时运行两个或两个以上的程序。一般...

    C语言多线程操作

    目录

     


    返回目录

    C语言多线程

    多线程是多任务处理的一种特殊形式,多任务处理允许让电脑同时运行两个或两个以上的程序。一般情况下,两种类型的多任务处理:基于进程和基于线程

    • 基于进程的多任务处理是程序的并发执行。
    • 基于线程的多任务处理是同一程序的片段的并发执行。

    多线程程序包含可以同时运行的两个或多个部分。这样的程序中的每个部分称为一个线程,每个线程定义了一个单独的执行路径。

    本教程假设您使用的是 Linux 操作系统,我们要使用 POSIX 编写多线程 C++ 程序。POSIX Threads 或 Pthreads 提供的 API 可在多种类 Unix POSIX 系统上可用,比如 FreeBSD、NetBSD、GNU/Linux、Mac OS X 和 Solaris。

    返回目录

    创建线程

    下面的程序,我们可以用它来创建一个POSIX 线程:

    #include <pthread.h>
    pthread_create (thread, attr, start_routine, arg)

    在这里,pthread_create 创建一个新的线程,并让它可执行。下面是关于参数的说明:

    C语言多线程操作

    目录

     


    返回目录

    C语言多线程

    多线程是多任务处理的一种特殊形式,多任务处理允许让电脑同时运行两个或两个以上的程序。一般情况下,两种类型的多任务处理:基于进程和基于线程

    • 基于进程的多任务处理是程序的并发执行。
    • 基于线程的多任务处理是同一程序的片段的并发执行。

    多线程程序包含可以同时运行的两个或多个部分。这样的程序中的每个部分称为一个线程,每个线程定义了一个单独的执行路径。

    本教程假设您使用的是 Linux 操作系统,我们要使用 POSIX 编写多线程 C++ 程序。POSIX Threads 或 Pthreads 提供的 API 可在多种类 Unix POSIX 系统上可用,比如 FreeBSD、NetBSD、GNU/Linux、Mac OS X 和 Solaris。

    返回目录

    创建线程

    下面的程序,我们可以用它来创建一个POSIX 线程:

    #include <pthread.h>
    pthread_create (thread, attr, start_routine, arg)

    在这里,pthread_create 创建一个新的线程,并让它可执行。下面是关于参数的说明:

    参数 描述
    thread 指向线程标识符指针。
    attr 一个不透明的属性对象,可以被用来设置线程属性。您可以指定线程属性对象,也可以使用默认值 NULL。
    start_routine 线程运行函数起始地址,一旦线程被创建就会执行。
    arg 运行函数的参数。它必须通过把引用作为指针强制转换为 void 类型进行传递。如果没有传递参数,则使用 NULL。

    创建线程成功时,函数返回 0,若返回值不为 0 则说明创建线程失败。

    返回目录

    终止线程

    使用下面的程序,我们可以用它来终止一个 POSIX 线程:

    #include <pthread.h>
    pthread_exit (status)

    在这里,pthread_exit 用于显式地退出一个线程。通常情况下,pthread_exit() 函数是在线程完成工作后无需继续存在时被调用。

    如果 main() 是在它所创建的线程之前结束,并通过 pthread_exit() 退出,那么其他线程将继续执行。否则,它们将在 main() 结束时自动被终止。

    连接和分离线程

    我们可以使用以下两个函数来连接或分离线程:

    pthread_join (threadid, status) 
    pthread_detach (threadid)

    pthread_join() 子程序阻碍调用程序,直到指定的 threadid 线程终止为止。当创建一个线程时,它的某个属性会定义它是否是可连接的(joinable)或可分离的(detached)。只有创建时定义为可连接的线程才可以被连接。如果线程创建时被定义为可分离的,则它永远也不能被连。pthread_join() 函数来等待线程的完成。

    返回目录

    注意

    pthread库不是Linux系统默认的库,连接时需要使用库libpthread.a, 在使用pthread_create创建线程时,在编译中要加-lpthread参数:

     

      gcc createThread.c -lpthread -o createThread.o
      ./createThread.

    Test 1 无参数传递的线程并发编程实例

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    // 基于线程的并发编程

    // Test_1 createThread

    #include <stdio.h>

    #include <pthread.h>

    /*

     * pthread库不是Linux系统默认的库,连接时需要使用库libpthread.a,

     * 在使用pthread_create创建线程时,在编译中要加-lpthread参数:

     * gcc createThread.c -lpthread -o createThread.o

     * ./createThread.o

     * 加上上面两句以后编译成功,并输出结果

     * */

    #define NUM_Threads 5

     

    // 线程的运行函数

    void *PrintHello(void *arg)

    {

        printf("Hello,World of Thread in C!\n");

        return 0;

    }

     

    int main()

    {

        int i;

        int ret;

        // 定义线程的id变量,多个变量使用数组

        pthread_t tids[NUM_Threads];

     

        for (i=0; i<NUM_Threads; i++)

        {

            // 参数依次是: 创建的线程id,线程参数,调用的函数,传入的函数参数

           ret = pthread_create(&tids[i], NULL, PrintHello, NULL);

           if (ret != 0)

          {

              printf("pthread_create error: error_code = \n");

          }

        }

        // 等各个线程推出后,进程才结束

        pthread_exit(NULL);

     

        return 0;

    }

     

    /*

     * 在CLion(Ubuntu)中输出结果为

    Hello,World of Thread in C!

    Hello,World of Thread in C!

    Hello,World of Thread in C!

    Hello,World of Thread in C!

    Hello,World of Thread in C!

     * */

    Test 2 简单参数传递的线程并发编程实例

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    // 基于线程的并发编程,向线程传递参数1

    // Test_2_createThread

    #include <stdio.h>

    #include <pthread.h>

    #include <stdlib.h>

    #define NUM_Threads 5

     

    // 线程的运行函数

    void *PrintHelloId(void *threadid)

    {

        // 对传入的参数进行强制类型转换,由无类型指针变为整形指针,然后再读取

        int tid = *((int *)threadid);

        printf("Hello,World, Thread %d\n",tid);

        return 0;

    }

     

    int main()

    {

        pthread_t pthreads[NUM_Threads];

        int i, rc;

        // 用数组存储i的数值

        int indexes[NUM_Threads];

     

        for (i=0; i<NUM_Threads; i++)

        {

            printf("main() : 创建线程 %d \n",i);

            indexes[i] = i; // 保存i的数值

            // 在indexes传入参数的时候必须转换为无类型指针

            rc = pthread_create(&pthreads[i], NULL, PrintHelloId, (void *)&indexes[i]);

            if (0 != rc)

            {

                printf("Error: 无法创建线程!\n");

                exit(-1);

            }

        }

     

        pthread_exit(NULL);

        return 0;

    }

     

    /*

     * 在CLion(Ubuntu)中输出结果是

    main() : 创建线程 0

    main() : 创建线程 1

    Hello,World, Thread 0

    main() : 创建线程 2

    Hello,World, Thread 1

    main() : 创建线程 3

    Hello,World, Thread 2

    main() : 创建线程 4

    Hello,World, Thread 3

    Hello,World, Thread 4

     * */

    Test 3 结构体参数传递的线程并发编程实例

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    // 基于线程的并发编程,向线程传递参数2(传递结构体)

    // Test_3_createThread

    #include <stdio.h>

    #include <pthread.h>

    #include <stdlib.h>

    #define NUM_Threads 5

     

    typedef struct thread_data{

        int threadid;

        char message;

    }THDATA,*PTHDATA;

     

    void * PrintHello(void * pthreadid)

    {

        PTHDATA tid = (PTHDATA)pthreadid;

     

        printf("This is Pthread : %d ;info : %c \n",tid->threadid, tid->message);

     

        return 0;

    }

     

    int main(void)

    {

        pthread_t Pthread[NUM_Threads];

        THDATA index[NUM_Threads];

        int i, ret;

     

        for (i = 0; i < NUM_Threads; i++)

        {

            printf("main() : 创建线程 %d \n",i);

            index[i].threadid = i;

            index[i].message = 'A'+i%10;

            ret = pthread_create(&Pthread[i], NULL, PrintHello, (void *)&index[i]);

            if (0 != ret)

            {

                printf("Error: 创建线程失败!\n");

                exit(-1);

            }

        }

        pthread_exit(NULL);

        return 0;

    }

     

    /*

     * 在CLion(Ubuntu)中输出结果是

    main() : 创建线程 0

    main() : 创建线程 1

    This is Pthread : 0 ;info : A

    main() : 创建线程 2

    main() : 创建线程 3

    This is Pthread : 2 ;info : C

    main() : 创建线程 4

    This is Pthread : 3 ;info : D

    This is Pthread : 4 ;info : E

    This is Pthread : 1 ;info : B

     * */

    Test 4 线程的连接编程实例

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    // 基于线程的并发编程,连接或分离线程

    // Test_4_createThread

    // 2019年10月27日14:45:11 尚未完全搞明白

    #include <stdio.h>

    #include <pthread.h>

    #include <stdlib.h>

     

    #define NUM_Pthread 5

     

    void *PrintHello(void * pthreadid)

    {

        int tid = *((int *)pthreadid);

        printf("Sleeping in thread %d ,...exiting \n",tid);

        return 0;

    }

     

    int main(void)

    {

        int i, ret;

        pthread_t Pthread[NUM_Pthread];

        pthread_attr_t attr; // 定义线程属性

        void * status;

        int index[NUM_Pthread];

     

        // 初始化并设置线程为可连接

        pthread_attr_init(&attr);

        pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

     

        for (i=0; i<NUM_Pthread; i++)

        {

            printf("main() : 创建线程 %d \n",i);

            index[i] = i;

            ret = pthread_create(&Pthread[i], NULL, PrintHello, (void *)&index[i]);

        }

     

        // 删除属性,并等待其他线程

        pthread_attr_destroy(&attr);

        for (i=0; i<NUM_Pthread; i++)

        {

            ret = pthread_join(Pthread[i], status);

            if (0 != ret)

            {

                printf("Error: unable to join,%d\n",ret);

                exit(-1);

            }

            printf("main(): complete thread id : %d",i);

            printf(" exiting with status : %p\n",status);

        }

     

        printf("main() : program exiting.\n");

        pthread_exit(NULL);

     

        return 0;

    }

    返回目录

    信号量机制

    Test 5 信号量同步进行写入

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    62

    63

    64

    65

    66

    // 用信号量进行同步

    #include <stdio.h>

    #include <pthread.h>

    #include <stdlib.h>

    #include <string.h>

    #include <unistd.h>

    #include <semaphore.h>

     

    #define Len 100       // 设置输入内容长度

     

    sem_t bin_sem;

    char work_area[Len]; // 存放输入内容

     

    void *Thread_func(void *arg)

    {

        // 等待信号量有大于0的值然后退出

        sem_wait(&bin_sem);

        while (0 != strncmp("end", work_area, 3))

        {

            printf("Input %ld characters\n", strlen(work_area)-1);

        }

        return 0;

    }

     

    int main(void)

    {

        int res;    // 存放命令的返回值

        pthread_t Pthread; // 创建线程

        void *thread_result; // 存放线程处理结果

     

        // 初始化信号量,并设置初始值为0

        res = sem_init(&bin_sem, 0, 0);

        if (0 != res)

        {

            perror("Semaphore initialization failes");

            exit(EXIT_FAILURE);

        }

        // 创建新线程 0

        res = pthread_create(&Pthread, NULL, Thread_func, NULL);

        if (0 != res)

        {

            perror("Thread creation failed");

            exit(EXIT_FAILURE);

        }

        printf("Enter 'end' to finish\n");

        // 当工作区内不是以end开头的字符串,则继续输入

        while (0 != strncmp("end", work_area, 3))

        {

            // 以标准输入获取输入到工作区内

            fgets(work_area, Len, stdin);

            sem_post(&bin_sem);  // 信号量+1

        }

        printf("\n Waiting for thread to finish...\n");

        // 等待线程结束

        res = pthread_join(Pthread, &thread_result);

        if (0 != res)

        {

            perror("Thread join failed");

            exit(EXIT_FAILURE);

        }

        printf("Thread joined\n");

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

        exit(EXIT_SUCCESS);

     

        return 0;

    }

    Test 6 互斥信号量实现对临界资源操作

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    62

    63

    // 用互斥信号量进行同步

    #include <stdio.h>

    #include <pthread.h>

    #include <stdlib.h>

    #include <string.h>

     

    #define Len 3 // 自增计算次数

    #define NUM_Pthread 5 // 设置线程的长度

     

    int count = 1; // 在数据段共享资源,多个进程抢占临界资源

    // 对于临界资源,应该添加互斥锁

    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

     

    void *Thread_func(void *threadid)

    {

        int tid = *((int *)threadid);

        int i, val;

        printf("Pthread ID : %d \n",tid);

     

        for (i=0; i<NUM_Pthread; i++)

        {

            pthread_mutex_lock(&mutex);

            val = count;

            printf("val = %d \n",val++);

            count = val;

            pthread_mutex_unlock(&mutex);

        }

     

        return 0;

    }

     

    int main(void)

    {

        int res;    // 存放命令的返回值

        int i;

        pthread_t Pthread[NUM_Pthread]; // 创建线程

        int index[NUM_Pthread];

     

        for (i=0; i<NUM_Pthread; i++)

        {

            index[i] = i;

            // 创建线程

           res = pthread_create(&Pthread[i], NULL, Thread_func, (void *)&index[i]);

           if (0 != res)

           {

               printf("Error: 创建线程失败!\n");

               exit(-1);

           }

        }

     

        for (i=0; i<NUM_Pthread; i++)

        {

            // 汇合线程

            pthread_join(Pthread[i], NULL);

        }

        printf("count = %d\n",count);

        pthread_exit(NULL);

        return 0;

    }

     

    // 在运行此程序无互斥锁时,我们不仅得到错误的答案,而且每次得到的答案都不相同

    // 分析

    // 当多个对等线程在一个处理器上并发运行时,机器指令以某种顺序完成,每个并发执行定义了线程中指令的某种顺序

     
       
       
       
       

    创建线程成功时,函数返回 0,若返回值不为 0 则说明创建线程失败。

    返回目录

    终止线程

    使用下面的程序,我们可以用它来终止一个 POSIX 线程:

    #include <pthread.h>
    pthread_exit (status)

    在这里,pthread_exit 用于显式地退出一个线程。通常情况下,pthread_exit() 函数是在线程完成工作后无需继续存在时被调用。

    如果 main() 是在它所创建的线程之前结束,并通过 pthread_exit() 退出,那么其他线程将继续执行。否则,它们将在 main() 结束时自动被终止。

    连接和分离线程

    我们可以使用以下两个函数来连接或分离线程:

    pthread_join (threadid, status) 
    pthread_detach (threadid)

    pthread_join() 子程序阻碍调用程序,直到指定的 threadid 线程终止为止。当创建一个线程时,它的某个属性会定义它是否是可连接的(joinable)或可分离的(detached)。只有创建时定义为可连接的线程才可以被连接。如果线程创建时被定义为可分离的,则它永远也不能被连。pthread_join() 函数来等待线程的完成。

    返回目录

    注意

    pthread库不是Linux系统默认的库,连接时需要使用库libpthread.a, 在使用pthread_create创建线程时,在编译中要加-lpthread参数:

     

      gcc createThread.c -lpthread -o createThread.o
      ./createThread.

    Test 1 无参数传递的线程并发编程实例

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    // 基于线程的并发编程

    // Test_1 createThread

    #include <stdio.h>

    #include <pthread.h>

    /*

     * pthread库不是Linux系统默认的库,连接时需要使用库libpthread.a,

     * 在使用pthread_create创建线程时,在编译中要加-lpthread参数:

     * gcc createThread.c -lpthread -o createThread.o

     * ./createThread.o

     * 加上上面两句以后编译成功,并输出结果

     * */

    #define NUM_Threads 5

     

    // 线程的运行函数

    void *PrintHello(void *arg)

    {

        printf("Hello,World of Thread in C!\n");

        return 0;

    }

     

    int main()

    {

        int i;

        int ret;

        // 定义线程的id变量,多个变量使用数组

        pthread_t tids[NUM_Threads];

     

        for (i=0; i<NUM_Threads; i++)

        {

            // 参数依次是: 创建的线程id,线程参数,调用的函数,传入的函数参数

           ret = pthread_create(&tids[i], NULL, PrintHello, NULL);

           if (ret != 0)

          {

              printf("pthread_create error: error_code = \n");

          }

        }

        // 等各个线程推出后,进程才结束

        pthread_exit(NULL);

     

        return 0;

    }

     

    /*

     * 在CLion(Ubuntu)中输出结果为

    Hello,World of Thread in C!

    Hello,World of Thread in C!

    Hello,World of Thread in C!

    Hello,World of Thread in C!

    Hello,World of Thread in C!

     * */

    Test 2 简单参数传递的线程并发编程实例

    + View Code

    Test 3 结构体参数传递的线程并发编程实例

    + View Code

    Test 4 线程的连接编程实例

    + View Code

    返回目录

    信号量机制

    Test 5 信号量同步进行写入

    + View Code

    Test 6 互斥信号量实现对临界资源操作

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    62

    63

    // 用互斥信号量进行同步

    #include <stdio.h>

    #include <pthread.h>

    #include <stdlib.h>

    #include <string.h>

     

    #define Len 3 // 自增计算次数

    #define NUM_Pthread 5 // 设置线程的长度

     

    int count = 1; // 在数据段共享资源,多个进程抢占临界资源

    // 对于临界资源,应该添加互斥锁

    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

     

    void *Thread_func(void *threadid)

    {

        int tid = *((int *)threadid);

        int i, val;

        printf("Pthread ID : %d \n",tid);

     

        for (i=0; i<NUM_Pthread; i++)

        {

            pthread_mutex_lock(&mutex);

            val = count;

            printf("val = %d \n",val++);

            count = val;

            pthread_mutex_unlock(&mutex);

        }

     

        return 0;

    }

     

    int main(void)

    {

        int res;    // 存放命令的返回值

        int i;

        pthread_t Pthread[NUM_Pthread]; // 创建线程

        int index[NUM_Pthread];

     

        for (i=0; i<NUM_Pthread; i++)

        {

            index[i] = i;

            // 创建线程

           res = pthread_create(&Pthread[i], NULL, Thread_func, (void *)&index[i]);

           if (0 != res)

           {

               printf("Error: 创建线程失败!\n");

               exit(-1);

           }

        }

     

        for (i=0; i<NUM_Pthread; i++)

        {

            // 汇合线程

            pthread_join(Pthread[i], NULL);

        }

        printf("count = %d\n",count);

        pthread_exit(NULL);

        return 0;

    }

     

    // 在运行此程序无互斥锁时,我们不仅得到错误的答案,而且每次得到的答案都不相同

    // 分析

    // 当多个对等线程在一个处理器上并发运行时,机器指令以某种顺序完成,每个并发执行定义了线程中指令的某种顺序

    展开全文
  • 介绍Linux下多线程编程的博客:...结合这些知识,自己写了了一个demo,其中实现了多线程传递参数与利用锁进行同步。 #include <stdio.h> #include <pthread.h> #include <uni

    介绍Linux下多线程编程的博客:https://www.cnblogs.com/nfcm/p/7653433.html

    pthread_create传递带参数的函数:https://blog.csdn.net/computerme/article/details/52421928

    结合这些知识,自己写了了一个demo,其中实现了多线程、传递参数与利用锁进行同步。

    #include <stdio.h>
    #include <pthread.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    #define thread_num 8
    
    int num=0;
    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    typedef struct String{
    	char c[20];
    	int len;
    } Str;
    
    void * func_thread(void * arg)
    {
    	Str * para=(Str *)arg;
    	pthread_mutex_lock(&mutex);
        while(num<20){
            printf("this is func_%s,%d!\n",para->c,para->len);
    		num++;
    		pthread_mutex_unlock(&mutex);
    		sleep(1);
    		pthread_mutex_lock(&mutex);
        }
    	pthread_mutex_unlock(&mutex);
    }
     
    int func()
    {
        pthread_t pid[thread_num];
    	void * ps[thread_num];
    	Str arg[8]={{"zero",4},{"one",3},{"two",3},{"three",5},{"four",4},
    		{"five",4},{"six",3},{"seven",5}};
    	int i;
    	for(i=0;i<thread_num;i++)
    		if(pthread_create(pid+i, NULL, func_thread,arg+i))
    			return -1;
    	for(i=0;i<thread_num;i++)
    		pthread_join(pid[i],ps+i);
    	printf("%d\n",num);
    	return 0;
    }
    
    int main()
    {
    	func();
    	return 0;
    }
    //gcc prac1.c -o prac1 -lpthread

    我是在gcc下编译的:gcc demo.c -o demo -lpthread

    展开全文
  • C语言如何实现一个线程通过队列向另一个线程发送数据?C语言如何实现一个线程通过队列向另一个线程发送数据?有相关代码更佳分享到:------解决方案--------------------“更佳”砸下来了——!就看帖主接不接得住。...

    C语言如何实现一个线程通过队列向另一个线程发送数据?

    C语言如何实现一个线程通过队列向另一个线程发送数据? 有相关代码更佳

    分享到:

    ------解决方案--------------------

    “更佳”砸下来了——!就看帖主接不接得住。

    //循环向a函数每次发送200个字节长度(这个是固定的)的buffer,

    //a函数中需要将循环传进来的buffer,组成240字节(也是固定的)的新buffer进行处理,

    //在处理的时候每次从新buffer中取两个字节打印

    #ifdef WIN32

    #pragma warning(disable:4996)

    #endif

    #include 

    #include 

    #include 

    #ifdef WIN32

    #include 

    #include 

    #include 

    #define  MYVOID             void

    #define  vsnprintf          _vsnprintf

    #else

    #include 

    #include 

    #include 

    #define  CRITICAL_SECTION   pthread_mutex_t

    #define  MYVOID             void *

    #endif

    //Log{

    #define MAXLOGSIZE 20000000

    #define MAXLINSIZE 16000

    #include 

    #include 

    #include 

    char logfilename1[]="MyLog1.log";

    char logfilename2[]="MyLog2.log";

    static char logstr[MAXLINSIZE+1];

    char datestr[16];

    char timestr[16];

    char mss[4];

    CRITICAL_SECTION cs_log;

    FILE *flog;

    #ifdef WIN32

    void Lock(CRITICAL_SECTION *l) {

    EnterCriticalSection(l);

    }

    void Unlock(CRITICAL_SECTION *l) {

    LeaveCriticalSection(l);

    }

    void sleep_ms(int ms) {

    Sleep(ms);

    }

    #else

    void Lock(CRITICAL_SECTION *l) {

    pthread_mutex_lock(l);

    }

    void Unlock(CRITICAL_SECTION *l) {

    pthread_mutex_unlock(l);

    }

    void sleep_ms(int ms) {

    usleep(ms*1000);

    }

    #endif

    void LogV(const char *pszFmt,va_list argp) {

    struct tm *now;

    struct timeb tb;

    if (NULL==pszFmt

    ------解决方案--------------------

    0==pszFmt[0]) return;

    vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);

    ftime(&tb);

    now=localtime(&tb.time);

    sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);

    sprintf(timestr,"%02d:%02d:%02d",now->tm_hour     ,now->tm_min  ,now->tm_sec );

    sprintf(mss,"%03d",tb.millitm);

    printf("%s %s.%s %s",datestr,timestr,mss,logstr);

    flog=fopen(logfilename1,"a");

    if (NULL!=flog) {

    fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);

    if (ftell(flog)>MAXLOGSIZE) {

    fclose(flog);

    if (rename(logfilename1,logfilename2)) {

    remove(logfilename2);

    rename(logfilename1,logfilename2);

    }

    } else {

    fclose(flog);

    }

    }

    }

    void Log(const char *pszFmt,...) {

    va_list argp;

    Lock(&cs_log);

    va_start(argp,pszFmt);

    LogV(pszFmt,argp);

    va_end(argp);

    Unlock(&cs_log);

    }

    //Log}

    #define ASIZE    200

    #define BSIZE    240

    #define CSIZE      2

    char Abuf[ASIZE];

    char Cbuf[CSIZE];

    CRITICAL_SECTION cs_HEX ;

    CRITICAL_SECTION cs_BBB ;

    struct FIFO_BUFFER {

    int  head;

    int  tail;

    int  size;

    char data[BSIZE];

    展开全文
  • 下面代码是在多线程中执行的:线程二pthread_t listid_thread[l_size];for (int _i = 0; _i < l_size; _i++){struct ListingInfos listing_infos;//创建线程int temp;if ((temp = pthread_cre...
  • C语言多线程

    2016-12-06 10:29:53
    pthread_create函数  原型:int pthread_create((pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *)... 功能:创建线程(实际上就是确定调用该线程函数的入口点),在线程
  • Linux下c语言多线程编程

    千次阅读 2017-12-07 15:44:55
    转载自https://www.cnblogs.com/chenyadong/archive/2011/10/25/2223610.html Linux下c语言多线程编程
  • 我试图将2个无符号整数传递给C中新创建的线程(使用pthread_create())但是也没有2个整数或结构的数组似乎有效.// In my socket filestruct dimension {unsigned int width;unsigned int height;};unsigned int width,...
  • linux下C语言多线程

    万次阅读 2012-07-25 21:42:03
    下面先来一个实例来感受下linux下C语言多线程编程的乐趣!我们通过创建两个线程来实现对一个数的递加。先不去理会代码的含义,我们先运行linux,在其中编写我们的第一个C语言多线程程序。 #include #include #...
  • c语言多线程返回值以及内存回收的问题 背景 昨天在写一个C语言的多线程小程序,要求不出现内存泄漏,其中用到了valgrind检测内存是否泄漏,这个工具只在面试的时候了解过,并没有用过,这次正好接触到了,觉得比较...
  • 多线程传递参数

    2018-02-10 13:16:12
    转自...lt;iostream&gt;#include &lt;pthread.h&gt; //多线程相关操作头文件,可移植众多平台using namespace std;struct mypara{ int para1; //参数1 ...
  • C语言多线程编程-线程的基本函数

    万次阅读 多人点赞 2017-04-06 22:33:21
    线程操作函数,线程属性控制函数
  • 最近学习需要,接触了C语言多线程,网上搜索到的例子都不太容易理解,很多还是使用C++知识的,特别对于小白来说学习起来更加困难。因此在这里分享一下自己的学习心得,本文只涉及基本的C语言
  • linux下C语言多线程编程实例

    千次阅读 2011-08-15 20:44:01
    linux下C语言多线程编程实例 2007年11月29日 星期四 10:39 学东西,往往实例才是最让人感兴趣的,老是学基础理论,不动手,感觉没有成就感,呵呵。 下面先来一个实例。我们通过创建两个线程来实现对一...
  • _beginThreadex创建多线程解读 一、需要的头文件支持  #include &lt;process.h&gt; // for _beginthread() 需要的设置:ProjectàSetting--&gt;C/C++--&gt;User run-time library 选择Debug...
  • 一.线程创建首先要关联头文件Window.h,需要使用Windows系统的底层方法1.1 线程创建演示://定义一个方法,弹出一个消息框 ... MessageBox(0, "多线程测试", "信息", 0); }//main方法中开启线程 int main(void) {
  • C语言多线程pthread库-互斥锁

    千次阅读 2016-02-01 13:26:30
    C语言多线程pthread库相关函数说明 线程相关操作说明  一 pthread_t  pthread_t在头文件/usr/include/bits/pthreadtypes.h中定义:  typedef unsigned long int pthread_t;  它是一个线程的标识符。 ...
  • 简单实现linux下c语言多线程编程,代码很简单,如下所示: /************************************************************************* &gt; File Name: module.c &gt; Author: xiao5 &gt; ...
  • 编写多线程程序,一个缓冲区,生产、消费两个线程,生产者放入缓冲区一个数字,然后待查。消费者检查数字,偶数除2,直至结果为奇数,结果写回缓冲。生产者、消费者再重复操作,直至缓冲区满。 程序代码如下: #...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,036
精华内容 14,014
关键字:

c语言多线程传递参数

c语言 订阅