互斥锁不在一个线程内引发的问题

本实验创建了3个进程,为了更好的描述线程之间的并行执行, 让3个线程共用同一个执行函数。每个线程都有5次循环(可以看成5个小任务), 每次循环之间会随机等待1~10s的时间,意义在于模拟每个任务的到达时间是随机的,并没有任何特定的规律。使用互斥锁mutex完成互斥访问

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <pthread.h>
 4
 5 #define THREAD_NUMBER 3         //线程数
 6 #define REPAT_NUMBER 5          //每个线程中的小任务数
 7 #define DELAY_TIME_LEVELS 10.0  //小任务之间的最大时间间隔
 8 pthread_mutex_t mutex;          //定义一格互斥锁的全局变量
 9
10 //线程函数例程
11 void *func(void *arg)
12 {
13         int thrd_num=(int )arg;
14         int delay_time=0;
15         int count=0;
16         int res;
17         //互斥锁上锁
18         res=pthread_mutex_lock(&mutex);
19         if(res!=0){
20                 printf("Thread %d lock failed.\n",thrd_num);
21                 pthread_exit(NULL);
22         }
23         //下面这段代码才是共享区
24         printf("thread %d is starting\n", thrd_num);
25         for(count=0; count<REPAT_NUMBER; count++){
26                 delay_time=(int)(rand()*DELAY_TIME_LEVELS/(RAND_MAX))+1;
27                 sleep(delay_time);
28                 printf("\tthread %d:job %d delay %d\n", thrd_num, count, delay_time);
29         }
30         printf("thread %d finished\n",thrd_num);
31         //互斥锁的解锁留给了主线程
32         pthread_mutex_unlock(&mutex);
33         pthread_exit(NULL);     //线程退出
34 }
35
36 int main(int argc, char const *argv[])
37 {
38         pthread_t thread[THREAD_NUMBER];        //存放线程ID
39         int no,res;
40         void *thrd_ret;
41         srand(time(NULL));
42
43         for(no=0; no<THREAD_NUMBER; no++){
44                 //创建多线程
45                 res=pthread_create(&thread[no],NULL,(void *)func,(void *)no);
46                 if(res!=0){
47                         printf("create thread %d failed.\n", no);
48                         exit(res);
49                 }
50         }
51
52         printf("create thread success\nwaiting for thread to finish...\n");
53         for(no=0; no<THREAD_NUMBER; no++){
54                 //等待线程结束
55                 res=pthread_join(thread[no],&thrd_ret);
56                 if(!res){
57                         printf("thread %d finished\n", no);
58                 }else{
59                         printf("thread %d join failed.\n", no);
60                 }
61                 //互斥锁解锁
62    //           pthread_mutex_unlock(&mutex);
63         }
64         return 0;
65 }

这里要注意32行和62行的解锁,如果使用的是32行注释掉62行,则程序能正常运行

但如果使用的是62行而注释掉32行的话,程序会在某个地方卡住,运行了8次,下面第二种情况只出现了1次。

时间: 2024-12-12 01:12:44

互斥锁不在一个线程内引发的问题的相关文章

10.22进程互斥锁,队列,堆栈,线程

进程互斥锁 让并发变成串行,牺牲了执行效率,保证了数据的安全. 在程序并发执行时,如果需要修改数据就使用互斥锁. 队列 相当于内存中的空间. 可以存放多个数据,必须排队,遵循先进先出的顺序. from multiprocessing import Queue #调用队列类,实例化队列对象q q = Queue(5) #若传参,队列中就可以存放5个数据 q = Queue() #若不传参,则队列中可以存放无限个数据 q.get() #获取数据 q.put() #添加数据,满了就报错 q.empty

25多线程之互斥锁

例子:利用两个子进程从50进行降序输出 int g_num=50; //偶数 void *threadEven(void *lParam) { while(g_num>0) { if(!(g_num&1)) { printf("even:%d\n",g_num); } g_num--; usleep(1); } return NULL; } //奇数 void *threadOdd(void *lParam) { while(g_num>0) { if(g_num&

Java 线程锁机制 -Synchronized Lock 互斥锁 读写锁

synchronized 是互斥锁: lock 更广泛,包含了读写锁 读写锁特点: 1)多个读者可以同时进行读2)写者必须互斥(只允许一个写者写,也不能读者写者同时进行)3)写者优先于读者(一旦有写者,则后续读者必须等待,唤醒时优先考虑写者) 互斥锁特点: 一次只能一个线程拥有互斥锁,其他线程只有等待 所谓互斥锁, 指的是一次最多只能有一个线程持有的锁. 在jdk1.5之前, 我们通常使用synchronized机制控制多个线程对共享资源的访问. 而现在, Lock提供了比synchronize

C11线程管理:互斥锁

1.概述 锁类型 c11提供了跨平台的线程同步手段,用来保护多线程同时访问的共享数据. std::mutex,最基本的 Mutex 类,独占的互斥量,不能递归使用. std::time_mutex,带超时的独占互斥量,不能递归使用. std::recursive_mutex,递归互斥量,不带超时功能. std::recursive_timed_mutex,带超时的递归互斥量. lock类型 std::lock_guard,与 Mutex RAII 相关,方便线程对互斥量上锁. std::uniq

Python Threading 线程/互斥锁/死锁/GIL锁

导入线程包 import threading 准备函数线程,传参数 t1 = threading.Thread(target=func,args=(args,)) 类继承线程,创建线程对象 class MyThread(threading.Thread) def run(self): pass if __name__ == "__main__": t = MyThread() t.start() 线程共享全面变量,但在共享全局变量时会出现数据错误问题使用 threading 模块中的

Linux系统编程——线程同步与互斥:互斥锁

为什么需要互斥锁? 在多任务操作系统中,同时运行的多个任务可能都需要使用同一种资源.这个过程有点类似于,公司部门里,我在使用着打印机打印东西的同时(还没有打印完),别人刚好也在此刻使用打印机打印东西,如果不做任何处理的话,打印出来的东西肯定是错乱的. 下面我们用程序模拟一下这个过程,线程一需要打印" hello ",线程二需要打印" world ",不加任何处理的话,打印出来的内容会错乱: #include <stdio.h> #include <

Windows线程同步【3】互斥锁(Mutex)

我们前面讲过的临界区,如同一个小房间,张三进去了,李四就不能进,如果李四要进,必须等张三出来. 今天我们要讲的互斥锁,像一个物件,这个物件只能同时被一个线程持有.如此一来,便可以通过互斥锁来实现线程的同步. 一.创建 创建互斥锁的方法是调用函数CreateMutex: CreateMutex(&sa, bInitialOwner, szName); 第一个参数是一个指向SECURITY_ATTRIBUTES结构体的指针,一般的情况下,可以是nullptr. 第二个参数类型为BOOL,表示互斥锁创

APUE学习笔记——11 线程同步、互斥锁、自旋锁、条件变量

线程同步 同属于一个进程的不同线程是共享内存的,因而在执行过程中需要考虑数据的一致性. 假设:进程有一变量i=0,线程A执行i++,线程B执行i++,那么最终i的取值是多少呢?似乎一定是i=2:其实不然,如果没有考虑线程同步,i的取值可能是1.我们先考虑自加操作的过程:a,首先将内存中i的值copy到寄存器:b,对寄存器中i的copy进行自加:c,将寄存器中自加的结果返回到内存中.回到例子,如果线程A执行完abc三个步骤,线程B在执行者三个步骤,那么结果就应该为2.但是自加不是原子操作,假如执行

线程同步与互斥:互斥锁

为什么需要互斥锁? 在多任务操作系统中,同时运行的多个任务可能都需要使用同一种资源.这个过程有点类似于,公司部门里,我在使用着打印机打印东西的同时(还没有打印完),别人刚好也在此刻使用打印机打印东西,如果不做任何处理的话,打印出来的东西肯定是错乱的. 下面我们用程序模拟一下这个过程,线程一需要打印" hello ",线程二需要打印" world ",不加任何处理的话,打印出来的内容会错乱: [cpp] view plaincopy #include <stdi