同步

线程中的局部变量不需要同步；线程内操作的,同时线程外需要用到的,需要同步!

为何不设置两个断点来调试呢，一个在SendMessage后面::EnterCriticalSection(&m_css); 一个在你的主线程等待那里-----------华丽的分割线---------------实际上你根本不用那样做，你可以设置一个event，在子线程完成时激活这个事件，主线程等待这个事件就好了

Android系统中的同步机制是怎样的？Android系统作为目前全球最为流行的操作系统之一，其同步机制是非常重要的一个组成部分。在Android系统中，同步机制的作用是保证多线程程序的正确性，同时也确保数据的一致性和可靠性。本文将深入探讨Android系统中的同步机制是如何实现的。1.互斥锁互斥锁是一种最基础的同步机制，其作用是确保每一时刻只有一个线程访问数据或代码。在Android系统中，互斥锁通过Java中的synchronized关键字来实现。这个关键字可以应用于方法或者代码块，确保同时只有一个线程可以访问当前的方法或代码块。2.可重入锁可重入锁是一种特殊的互斥锁，其不仅可以保证同步访问，同时也支持单个线程多次获取锁。在Java中，ReentrantLock类提供了可重入锁的实现。Android系统也使用这个类来实现可重入锁。3.读写锁读写锁是一种高效的同步机制，其可以允许多线程同时对共享数据读取，但只有在没有其他线程进行写操作的时候才能进行写操作。在Android系统中，读写锁通过ReadWriteLock类来实现。4.信号量信号量是一种用于多线程同步的计数器。其可用于控制同时访问某个资源的线程数量。在Android系统中，可以使用Semaphore类来实现信号量。5.条件变量条件变量是一种用于线程之间通信的同步机制。其可以允许线程等待一个条件的发生，并在条件满足时被唤醒。在Android系统中，Condition类提供了条件变量的实现。总结Android系统中的同步机制是多种多样的，包括互斥锁、可重入锁、读写锁、信号量和条件变量等。这些机制都有其适用的场景和优缺点。在编写多线程程序时，需要根据实际情况选择合适的同步机制来保证程序正确性和数据可靠性。

　　ThreadLocal是解决线程安全问题一个很好的思路，它通过为每个线程提供一个独立的变量副本解决了变量并发访问的冲突问题。在很多情况下，ThreadLocal比直接使用synchronized同步机制解决线程安全问题更简单，更方便，且结果程序拥有更高的并发性。　　对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。　　ThreadLocal 并不能替代同步机制，两者面向的问题领域不同。　　1：同步机制是为了同步多个线程对相同资源的并发访问，是为了多个线程之间进行通信的有效方式；　　2：而threadLocal是隔离多个线程的数据共享，从根本上就不在多个线程之间共享变量，这样当然不需要对多个线程进行同步了。　　import java.util.Random;public class ThreadSocpeShareData { static ThreadLocal<Integer> t = new ThreadLocal<Integer>(); public static void main(String[] args) { for(int i=0;i<3;i++){ new Thread(new Runnable() { @Override public void run() { int data = new Random().nextInt(); System.out.println(Thread.currentThread().getName() +" has put "+ data); t.set(data); MyThreadScopeData.getInstance().setName("name" + data); MyThreadScopeData.getInstance().setAge("age"+data); new A().get(); new B().get(); } }).start(); } } static class A{ public void get(){ int data = t.get(); MyThreadScopeData myData = MyThreadScopeData.getInstance(); System.out.println("A " + Thread.currentThread().getName() +" "+ data + myData.getAge() + myData.getName() /*ms.getName()*/); } } static class B{ public void get(){ int data = t.get(); System.out.println("B " + Thread.currentThread().getName()+ " "+ data); } }}class MyThreadScopeData{ private MyThreadScopeData(){} private static ThreadLocal<MyThreadScopeData> map = new ThreadLocal<MyThreadScopeData>(); public static MyThreadScopeData getInstance(){ MyThreadScopeData instance = map.get(); if(instance == null){ instance = new MyThreadScopeData(); map.set(instance); } return instance; }private String name; private String age; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getAge() { return age; } public void setAge(String age) { this.age = age; }}　　事实上，我们向ThreadLocal中set的变量不是由ThreadLocal来存储的，而是Thread线程对象自身保存。当用户调用ThreadLocal对象的set(Object o)时，该方法则通过Thread.currentThread()获取当前线程，将变量存入Thread中的一个Map内，而Map的Key就是当前的ThreadLocal实例。请看源码，这是最主要的两个函数，能看出ThreadLocal与Thread的调用关系：　　public void set(T value) {　　　　Thread t = Thread.currentThread(); 　　　　　ThreadLocalMap map = getMap(t); 　if (map != null) 　　　　　　　map.set(this, value); 　else　　　　　　createMap(t, value); 　} 　ThreadLocalMap getMap(Thread t) { 　return t.threadLocals; 　}　　　public void set(T value) { Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) map.set(this, value); else createMap(t, value); } ThreadLocalMap getMap(Thread t) { return t.threadLocals; }　　具体可以看看里面的源码，不过有一点是可以证实的，就是Threadlocal中 创建的线程副本，可以不调用remove来做清理工作，因为jvm在发现线程的调佣不再使用时，会进行自动的垃圾回收操作，我以前写程序在使用Threadlocal时却是经常的进行使用完成之后的清理工作。（防止占用内存，如果创建的副本数量不是太多的话，可以让虚拟机自动来清除）

早晨，我老早就醒了，习惯地向外望去，却什么也看不清。我匆匆穿上衣服，打开窗户，只见一团团浓雾在四周飘扬。微风吹过，浓雾卷动着像一只只蜗牛地在空中慢悠悠爬来爬去；一会儿又变成了一只只海螺……浓雾真像个百变怪。该上学了，我走下楼来，立刻被浓雾包围了，就像是掉进了奶瓶中，只能看到脚下的一块。我小心地顺着路边向前走着，忽然，听到了熟悉的说话声，后面的脚步声越来越近，就是看不到是谁，直到那人走到我跟前，才发现是赵亮也去上学。在半路上，一轮红日从东方徐徐升起，浓雾像棉絮一样被一层层撕去，渐渐的变成了一层细纱，远处的景物开始朦朦胧胧地出

变量表的可以用于程序的变量在线检测，触摸屏的显示是组态软件里定义的变量相关 这些变量由和PLC 里的变量一一对应

小学六年级下册同步作文1 　　从幼儿起，书就悄悄进入我的生活，成为我生命中不可缺少的一部分。打开尘封的记忆时光开始倒流，我似乎回到了我的幼年时代。 　　那时，年幼无知的我，便经常跟爸爸妈妈去书城，让爸爸妈妈买一些故事书，每天晚上由妈妈讲给我听，通常，一个故事我都要听好几遍。那时，年幼的我，便经常为善良的白雪公主而感伤，为虚心的乌龟而大声叫好……也正是从那时起我爱上了书，书也成为我生命中不可缺少的一部分，当上了我形影不离的知心朋友。 　　自从上了三年级我们学习了作文以后，爸爸妈妈就给我买来了好多作文选，让我从中受到启发。我从此以后便爱上了作文书。不久，从《小学生优秀作文》中我懂得了写作文不能硬搬硬套，要灵活应用；一天，妈妈有事出去了，叫我如果下雨就收衣服。我拿着一本作文书津津有味地读着，在书里遨游着，完全忘记了自己，忘记了周围，忘记了所有。当我看见一篇描写家乡景物的文章时真如身临其境一般，一条清澈见底的小溪在身边潺潺的流淌着。小溪两边的垂柳随风飘荡着，婀娜多姿，美不胜收。一群六七岁的孩子在小溪里寻找着小鱼小虾，好像我也是他们中的一份子，一切是那么的美…… 　　妈回来了，走到阳台去了，衣服已经湿得能拧出水了，我依然在看书，“啊，怎么啦？衣服怎么湿透了！容容，你是怎么搞的？”这时我才恍然大悟，“我，我……我忘记了。”我挠着头说。弄得妈妈哭笑不得：“你呀！看书看呆了！”我不好意思地笑了笑。 　　我爱书，但无论怎样的好书，都能给你带来感观于心灵的愉悦。犹如夏日里的一杯冰水，彻骨的寒冷过后便是无比的清凉。 小学六年级下册同步作文2 　　生存，这个看似普通的词语，蕴含了深刻的道理。雄鹰只有学会飞行的本领，才能在蔚蓝的天空上自由翱翔。花种只有不断地吸吮大地的营养，才能开出姹紫嫣红的花朵。鱼儿只有掌握生存的法则，才能徜徉无边无际的大海；就像我们一样，只有认真学习知识，并且能学以自用，才能学会生存。 　　暑假里的一天，我和往常一样独自在家里做作业。记不清做了多久，感觉肚子有些饿，我决定热一热早上未吃完的饺子。经过几分钟的微波炉，我将热好的饺子摆到桌子上，拿出调料，开始吃了。吃完之后，洗碗时不知道是开水的时候用力过猛，还是因为水管老旧的原因。洗着洗着突然听到砰地一声，接着就是流水的哗哗声，然后就感觉裤脚湿了。什么情况？我急忙打开下面的柜子。下水管的软管烂了，水哗哗的淌着，柜子里到处是水，漏水了！我赶忙用盆接住；看着快变成游泳馆的家，看着又要快接满水的盆，我的心狂跳不止，脑子里一片空白：怎么办？怎么办？爸爸妈妈都不在家；再不让它停止，我家可就真成游泳馆了！焦急中，我不断想着办法。对了！我突然想起爸爸说过，如果家里漏水了可以把总闸关了，这样它就不会再漏了。想到这，我立马拉开柜子门，握住总闸手柄，用力把它关了起来。“呼。”我舒了一口气，水总算停了。提到嗓子眼的心，也会到了心窝。刚才真是吓死我了，不过幸好是有惊无险。我坐到椅子上休息，小猫花花似乎也被吓到了，跳到了桌子上，望着我叫个不停。“好了，”我安慰似的摸摸它柔软的毛，“水已经停了哦。”不过，水倒是停了，那还有留下来的呢。我有些颓废的看着已经蔓延到客厅的水，无奈的叹了口气，拿起拖把把它们一点一点赶进卫生间。经过一个半小时的努力，水被我拖完了，还有毛巾开了一遍。现在的地板，啧啧，焕然一新，一尘不染。就在我欣赏着自己的杰作时，花花迈着她优雅的猫步回来了。“花花你给我站住！”看着地板上一朵朵可爱的梅花，让我哭笑不得。 　　在人的生活中，多多少少要经历风雨，但是在困难面前，又有多少人会放弃，多少人会坚持。如果蜡烛怕燃烧，它就不会照亮我们。如果我们向困难低头，就永远学不会生存。 小学六年级下册同步作文3 　　我想每个人在成长的过程中都会为自己的理想做过决定。我也是这样的。 　　当我在上幼儿园的时候，每天天不亮，就有一个胖胖的身影忙碌着，这就是我亲爱的`妈妈，她是一名幼儿园老师。妈妈每天早出晚归，很辛苦。有时候我很羡慕妈妈班上的小朋友，因为妈妈对他们又温柔又体贴，但是对我却很严厉。有一天，老师问我：“你长大想干什么？”我说：“我想做幼儿园的园长，这样妈妈就可以不用上班，天天在家照顾我就行了。我给她发工资。” 　　不久我进入了小学，我先前决定的理想改变了。因为我最敬佩的张老师出现了，她对我们和蔼可亲，就像妈妈一样。我特别喜欢听她读课文，简直就像一个播音员一样。有一天，老师问我：“你长大想干什么？”我说：“我想做一名小学语文老师，因为我可以站在讲台上威风地给我的学生讲课。” 　　当我决定这个理想不久，一件突如其来的事改变了我的决定。 　　我那勤劳，善良的外婆生病了，而且是一个大病，是一个永远也治不好的病；当外婆手术的那天，放学之后，爸爸把我接到医院，一走进病房，我整个人就傻了。只见外婆双眼紧闭衰弱的躺在白色的病床上，身上到处插得都是管子，床头还有各种仪器不停的在闪动。一旁的妈妈和姨妈双眼通红。顿时，我的眼泪也“哗哗”的流了下来；在回家的路上，我对爸爸说：“我决定改变我的理想。”爸爸说：“那你决定长大想干什么了啊？”我斩钉截铁地说“我决定当一名医生，发明一种新药，让外婆早点康复。让妈妈和姨妈不再伤心。等你们老了，我也可以随时的为你们检查身体，知道你们是不是健康？”爸爸说“那你要为你的决定努力学习。” 　　这次我决定的理想，永远也不改变了，我会努力实现的。 小学六年级下册同步作文4 　　春节是中国一个隆重，盛大的传统节日，每一个角落都充满欢笑，每一个地方都洋溢着幸福。 　　美丽的四川省有着独特的春节。 　　程度人在春节第一天是不吃米饭的，在他们看来，“饭”与“犯”读音相似，为了避讳，家家都会吃抄手，吃汤圆，吃米线。过小年时才可以吃团圆饭，并且在这天，孩子，大人，老人，要放一“双”鞭炮，磕头，烧香。这春节过得够“传统”。 　　有趣的山东人的春节更是别有特色；家家吃完团圆饭后，要在自家锅上摆它几个馒头，这叫“余头”。初五的晚上，学生要到老师家给老师百年，向孔子神像拈香祭拜，再由老师出题即兴做一篇文章，然后由老师将这篇文章焚烧，这叫做“文曲星会”。这春节够“有趣”。 　　我亲爱的老家湖北，过春节更是热闹非凡。在除夕的前一个月，家家都要杀猪，宰鸡，因为在除夕夜，要喝汤，吃猪肉，家里的男人通常要吃鸡爪，象征着“新年抓财”，家中的孩子都要吃翅膀，象征着“展翅高飞”，家中的老人吃鸡骨头，象征着“出人头地”。大年初二一早，大人就要为孩子煮上“荷包蛋”，意思是说：包金包金，得金得银；初三，便到处去了，放一卷鞭炮，在门处喊道：“来拜年咯！”主人就会出门迎接，在主人家中吃了饭，再去别家拜年。这春节够“精彩”。 　　这精彩、有趣、传统的春节带给我们无限的开心、满足。 小学六年级下册同步作文5 　　在我的生活中最让我觉得紧张和刺激的就是第一次干一些事情。它们像我成长宝库中的一粒粒金子，每一滴都有它们不同的价值。都是我值得回忆的点点滴滴。而我这次要说的是我第一次在跳蚤市场当推销员。 　　最后一次跳蚤市场了，再怎么说也要为班级做点贡献呢。我怀着这样的心情参加了活动。在带来的卖品被一扫而光后，我有了一丝得意和喜悦，希望我的第一次推销任务也能顺顺利利；但很快，我就出现状况了，客户少了起来，我开始总结原因了，原来，我不懂得讨价还价，一直死咬着定价不放，这也让一些定价较为昂贵的物品卖不出去，也让买者人数大大减少。于是，在与战友们讨论了一番后，我决定开始与客户进行适当的讨价还价，必需顾客第一，也要接受他们的一些讨价还价，不过，有一些保存很好的实用物品不到万不得已还是不能妥协的，甚至卖的好的还可以翻倍提价，比如一些又厚又新的笔记本就可以从一元五角升到三元，而对人们生活帮助不大的物品，甚至有点浪费的，比如一些如跳绳，布偶，洋娃娃等过时用品则尽可能降低价格，在努力的成功重新标价后，客户的人数果然迅速提升。 　　但是，毕竟是第一次，还有问题需要解决，这也堪称当时最棘手的问题，那就是书的销量不好，说实在的，卖不出去的都是一些画册，现在的小学生一般都不看画册，这个时候，就需要挑选客户了，我们的目标就是有孩子，但是孩子小，还不识字的妈妈们。因为这个年龄段的孩子只能看画册。要说人海茫茫，找到这样的人还真是大海捞针，好不容易找到一位推婴儿车的妇女，我们费尽周折的推销，给宝宝讲画册中三只小猪的故事，把小宝宝逗得咯咯直笑，妈妈也笑着买下了我们手中的书。啊！真是不容易啊！ 　　将货物推销完毕后，我已累得大汗淋漓。第一次做难免有些瑕疵和不到位，不过，我认为他们都是美丽的。 小学六年级下册同步作文6 　　人人都有理想，都有自己奋斗的目标，都有自己可盼的成绩。我也有理想，那就是医生。 　　医生是救死扶伤的，医生是默默无闻的，医生是为人民服务的。医生认为：“人的一生就好像在排队，死神从每个人的身边走过，如果他在你的身边停下来，那就代表你有生命危险。而医生的任务就是把死神从你身边推走，让你安全。我要做一民优秀的医生，让世界少一份失去亲人的痛苦。 　　在我的心目中，医生这个职业是伟大的，是无私的。医生就是人们心中的白衣天使，所谓的白衣天使不仅是为人们治病的，也是为人民服务的，为人民的健康和生命着想的；医生救人是默默无闻的医生有时为了手术，饭都可以不吃。 　　汶川大地震的时候，医生们不分昼夜的救人，夜以继日的工作，尽全力不让死神带走一个人。而在这期间，医生们基本上没有喝一口水和吃一口饭，他们都毫无怨言。可见医生们是多么辛苦和无比的拼命！ 　　我应该在生活中吸取经验，知识在学习上我认真听课，积极发言。等长大后，将用这些知识为人们服务，我不能遇到困难和挫折就退缩，要有不怕困难，不怕失败，从哪里跌到就从哪里爬起来的精神。要记住：“只要功夫深，铁杵磨成针”。 　　人人都有理想，都有奋斗的目标，都有自己经过磨练得到的成绩。人生的道路上不可能没有挫折，记住：“失败乃成功之母！”我一定会去追求我的理想，实现我的理想！所以，如果我穿上白大衣，成为一名白衣天使的话，我一定会用我所学到的知识来挽救更多人的性命。 小学六年级下册同步作文7 　　马上就要过端午节了，大家都开始忙活起来了。妈妈和奶奶先把泡好的糯米拿出来，然后开始清洗干净粽子叶，便准备开始做粽子了。 　　“妈，我还不会包粽子呢，您能不能教我包粽子啊？”我恳求道。“行，反正包粽子还是蛮简单的，我就教你吧！”妈妈爽快的答应了我的请求。“不过，刚开始包很困难，你必须耐心点儿。诺，首先把粽子叶捆成一个圆锥形；记住，一定要捆的很紧，这样才不会漏出米来。再把糯米放下去，如果你喜欢吃红枣粽子，也可以在里面放几颗小红枣进去一起煮；然后再用一片粽子叶把装糯米的口盖住。接着用一条细绳或割叶青把粽子绑紧来，就完成了！”妈妈仔细地对我说。 　　不知道为什么，在妈妈面前的“乖乖女”粽子，在我面前又变成“调皮蛋”了，不管怎么弄，它都不听我的话，气得我真想大骂它一顿。最后，我费了九牛二虎之力，终于在妈妈的帮助下，“不成功则成仁”地包了一个粽子，虽然看起来并不雅观，不过，这是我包的最好的一个了。 　　到了端午节这一天，妈妈给我带上了五线绳，并嘱咐我一定不要折掉或坏掉，只有在端午节后的第一场雨下了，才可以摘下来。据说五彩绳代表五色龙，可以降伏妖魔，驱走疾病。早上忙完之后，今天的主角登场了——白嫩嫩的粽子蘸上白糖，又甜又黏，又白又香，好吃极了！ 　　五月五，端午节，吃粽子，龙舟戏水喜气洋洋……我爱家乡的端午节！ 小学六年级下册同步作文8 　　童年像一个美丽的宝盒，里面装满了许许多多珍贵的回忆。其中有一段回忆令我最难以忘怀。 　　记得那是我5岁的时候去外婆家。几个小伙伴想找点新花样玩。我就回房间，从妈妈包里拿出5元钱，冲出来对小伙伴们说：“我想到了一个好主意，我们来种钱玩吧！”“好呀！”伙伴们欢呼道。“怎么种呢？”一个小伙伴问。“看我的吧！”我又回房间拿出一把小铁铲，在土里挖了一个小坑，把钱塞进坑里，再把土盖上；我拍拍手说：“你们看，好了。大人们说种瓜得瓜，种豆得豆，那我们种钱不也能得到钱吗？”伙伴们听了恍然大悟，纷纷学着我的样子做起来。 　　我没有把这件事告诉妈妈，希望几天以后给她一个大惊喜。可是一天，两天，三天……我日日夜夜给它浇水，它却连芽都没有长出来。一个星期过去了，我忍不住扒开土一看，它不但没有结更多的钱，反而还烂在土里了，我坐在地上哇哇大哭。“怎么了，宝贝？”妈妈关心地问。我哭哭啼啼地说：“我把钱种在土里，都没有长钱，还烂在土里了。呜……”“哈哈！”妈妈不禁笑了出来，“钱怎么能种呢？”“大人们不是说种瓜得瓜，种豆得豆吗？”“那可不一样。”妈妈说，“钱要靠自己的劳动得来的，你的双手就是天生的肥料啊，只有你用双手辛勤劳动，才会得到很多钱。”我似懂非懂地点了点头。 　　那时傻傻的我做了件傻傻的事，至今令我难忘。 小学六年级下册同步作文9 　　书籍，是人类进步的阶梯。它可以使愚者变得博学多才，使我不断的充实自己。给我带来了无穷的乐趣。 　　从我很小的时候，我就拥有了许多图画书，我一有空儿，就常常扎再“书海”里，虽然当时的我连一个字也不认识，但翻着那些精美的图画，就猜到了八九分，一个又一个美丽多彩的故事在脑海中心生。随着年龄的增长，我喜欢的书也越来越多，类型也都不同。从图画书到故事书，从故事书到星际科幻，又从星际科幻到自然文学，又从自然文学到世界名着，每本书都给我带来了无穷的欢乐。像《十万个为什么》让我知道了一个又一个的知识，《中华五千年》让我明白了古代王朝的兴衰，《一百个中国名人》让我了解了名人的生活与他们的事迹，一本又一本，无数的知识，让我时时倘洋其中。 　　但我最喜欢的还是名着类的：《鲁滨逊漂流记》，这本书主要写了：鲁滨逊因乘船事故，流落到荒无人烟的荒岛。同伴们都被淹死了，只有他一个人九死一生活了下来；为了生存，他不得不想办法自救，并学习生存的技能，独自在荒岛上生活了二十八年二个月十九天，竟然靠自己的双手将荒岛变成了“世外桃源”，还勇敢的救了一个土着人“星期五”这本书的精彩内容让我时时陶醉，它让我明白了：如果遇到困难，却没有人来帮助，那就要乐观地接受现实，改变现状。 　　书籍，给我带来了无穷的欢乐，我要不断的充实自己，把自己的视野增加，让自己的知识增长。

楼上正解，试试吧

java中多线程的实现方法有两种：1.直接继承thread类；2.实现runnable接口；同步的实现方法有五种：1.同步方法；2.同步代码块；3.使用特殊域变量(volatile)实现线程同步；4.使用重入锁实现线程同步；5.使用局部变量实现线程同步 。其中多线程实现过程中需注意重写或者覆盖run()方法，而对于同步的实现方法中使用较常使用的是利用synchronized编写同步方法和代码块。

Linux内核设计与实现 十、内核同步方法 手把手教Linux驱动5-自旋锁、信号量、互斥体概述 == 基础概念： == 并发 ：多个执行单元同时进行或多个执行单元微观串行执行，宏观并行执行 竞态 ：并发的执行单元对共享资源（硬件资源和软件上的全局变量）的访问而导致的竟态状态。 临界资源 ：多个进程访问的资源 临界区 ：多个进程访问的代码段 == 并发场合： == 1、单CPU之间进程间的并发 :时间片轮转，调度进程。 A进程访问打印机，时间片用完，OS调度B进程访问打印机。 2、单cpu上进程和中断之间并发 ：CPU必须停止当前进程的执行中断; 3、多cpu之间 4、单CPU上中断之间的并发 == 使用偏向： == ==信号量用于进程之间的同步，进程在信号量保护的临界区代码里面是可以睡眠的（需要进行进程调度），这是与自旋锁最大的区别。== 信号量又称为信号灯，它是用来协调不同进程间的数据对象的，而最主要的应用是共享内存方式的进程间通信。本质上，信号量是一个计数器，它用来记录对某个资源（如共享内存）的存取状况。它负责协调各个进程，以保证他们能够正确、合理的使用公共资源。它和spin lock最大的不同之处就是：无法获取信号量的进程可以睡眠，因此会导致系统调度。 1、==用于进程与进程之间的同步== 2、==允许多个进程进入临界区代码执行，临界区代码允许睡眠；== 3、信号量本质是==基于调度器的==，在UP和SMP下没有区别；进程获取不到信号量将陷入休眠，并让出CPU； 4、不支持进程和中断之间的同步 5、==进程调度也是会消耗系统资源的，如果一个int型共享变量就需要使用信号量，将极大的浪费系统资源== 6、信号量可以用于多个线程，用于资源的计数（有多种状态） ==信号量加锁以及解锁过程：== sema_init(&sp->dead_sem, 0); / 初始化 / down(&sema); 临界区代码 up(&sema); ==信号量定义：== ==信号量初始化：== ==dowm函数实现：== ==up函数实现：== 信号量一般可以用来标记可用资源的个数。 举2个生活中的例子： ==dowm函数实现原理解析：== （1）down 判断sem->count是否 > 0，大于0则说明系统资源够用，分配一个给该进程，否则进入__down(sem); （2）__down 调用__down_common(sem, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);其中TASK_UNINTERRUPTIBLE=2代表进入睡眠，且不可以打断；MAX_SCHEDULE_TIMEOUT休眠最长LONG_MAX时间； （3）list_add_tail(&waiter.list, &sem->wait_list); 把当前进程加入到sem->wait_list中； （3）先解锁后加锁; 进入__down_common前已经加锁了，先把解锁，调用schedule_timeout(timeout)，当waiter.up=1后跳出for循环；退出函数之前再加锁； Linux内核ARM构架中原子变量的底层实现研究 rk3288 原子操作和原子位操作 原子变量适用于只共享一个int型变量； 1、原子操作是指不被打断的操作，即它是最小的执行单位。 2、最简单的原子操作就是一条条的汇编指令(不包括一些伪指令，伪指令会被汇编器解释成多条汇编指令) ==常见函数：== ==以atomic_inc为例介绍实现过程== 在Linux内核文件archarmincludeasmatomic.h中。 执行atomic_read、atomic_set这些操作都只需要一条汇编指令，所以它们本身就是不可打断的。 需要特别研究的是atomic_inc、atomic_dec这类读出、修改、写回的函数。 所以atomic_add的原型是下面这个宏： atomic_add等效于： result（%0） tmp（%1） (v->counter)（%2） (&v->counter)（%3） i（%4） 注意：根据内联汇编的语法，result、tmp、&v->counter对应的数据都放在了寄存器中操作。如果出现上下文切换，切换机制会做寄存器上下文保护。 （1）ldrex %0, [%3] 意思是将&v->counter指向的数据放入result中，并且（分别在Local monitor和Global monitor中）设置独占标志。 （2）add %0, %0, %4 result = result + i （3）strex %1, %0, [%3] 意思是将result保存到&v->counter指向的内存中， 此时 Exclusive monitors会发挥作用，将保存是否成功的标志放入tmp中。 （4） teq %1, #0 测试strex是否成功（tmp == 0 ？？） （5）bne 1b 如果发现strex失败，从（1）再次执行。 Spinlock 是内核中提供的一种比较常见的锁机制，==自旋锁是“原地等待”的方式解决资源冲突的==，即，一个线程获取了一个自旋锁后，另外一个线程期望获取该自旋锁，获取不到，只能够原地“打转”（忙等待）。由于自旋锁的这个忙等待的特性，注定了它使用场景上的限制 —— 自旋锁不应该被长时间的持有（消耗 CPU 资源），一般应用在==中断上下文==。 1、spinlock是一种死等机制 2、信号量可以允许多个执行单元进入，spinlock不行，一次只能允许一个执行单元获取锁，并且进入临界区，其他执行单元都是在门口不断的死等 3、由于不休眠，因此spinlock可以应用在中断上下文中； 4、由于spinlock死等的特性，因此临界区执行代码尽可能的短； ==spinlock加锁以及解锁过程：== spin_lock(&devices_lock); 临界区代码 spin_unlock(&devices_lock); ==spinlock初始化== ==进程和进程之间同步== ==本地软中断之间同步== ==本地硬中断之间同步== ==本地硬中断之间同步并且保存本地中断状态== ==尝试获取锁== == arch_spinlock_t结构体定义如下： == == arch_spin_lock的实现如下： == lockval（%0） newval（%1） tmp（%2） &lock->slock（%3） 1 << TICKET_SHIFT（%4） （1）ldrex %0, [%3] 把lock->slock的值赋值给lockval；并且（分别在Local monitor和Global monitor中）设置独占标志。 （2）add %1, %0, %4 newval =lockval +（1<<16）; 相当于next+1； （3）strex %2, %1, [%3] newval =lockval +（1<<16）; 相当于next+1； 意思是将newval保存到 &lock->slock指向的内存中， 此时 Exclusive monitors会发挥作用，将保存是否成功的标志放入tmp中。 （4） teq %2, #0 测试strex是否成功 （5）bne 1b 如果发现strex失败，从（1）再次执行。 通过上面的分析，可知关键在于strex的操作是否成功的判断上。而这个就归功于ARM的Exclusive monitors和ldrex/strex指令的机制。 （6）while (lockval.tickets.next != lockval.tickets.owner) 如何lockval.tickets的next和owner是否相等。相同则跳出while循环，否则在循环内等待判断； * （7）wfe()和smp_mb() 最终调用#define barrier() asm volatile ("": : :"memory") * 阻止编译器重排，保证编译程序时在优化屏障之前的指令不会在优化屏障之后执行。 == arch_spin_unlock的实现如下： == 退出锁时：tickets.owner++ == 出现死锁的情况： == 1、拥有自旋锁的进程A在内核态阻塞了，内核调度B进程，碰巧B进程也要获得自旋锁，此时B只能自旋转。 而此时抢占已经关闭，（单核）不会调度A进程了，B永远自旋，产生死锁。 2、进程A拥有自旋锁，中断到来，CPU执行中断函数，中断处理函数，中断处理函数需要获得自旋锁，访问共享资源，此时无法获得锁，只能自旋，产生死锁。 == 如何避免死锁： == 1、如果中断处理函数中也要获得自旋锁，那么驱动程序需要在拥有自旋锁时禁止中断； 2、自旋锁必须在可能的最短时间内拥有 3、避免某个获得锁的函数调用其他同样试图获取这个锁的函数，否则代码就会死锁；不论是信号量还是自旋锁，都不允许锁拥有者第二次获得这个锁，如果试图这么做，系统将挂起； 4、锁的顺序规则（a) 按同样的顺序获得锁；b) 如果必须获得一个局部锁和一个属于内核更中心位置的锁，则应该首先获取自己的局部锁 ;c) 如果我们拥有信号量和自旋锁的组合，则必须首先获得信号量；在拥有自旋锁时调用down(可导致休眠)是个严重的错误的；） == rw（read/write）spinlock： == 加锁逻辑： 1、假设临界区内没有任何的thread，这个时候任何的读线程和写线程都可以键入 2、假设临界区内有一个读线程，这时候信赖的read线程可以任意进入，但是写线程不能进入； 3、假设临界区有一个写线程，这时候任何的读、写线程都不可以进入； 4、假设临界区内有一个或者多个读线程，写线程不可以进入临界区，但是写线程也无法阻止后续的读线程继续进去，要等到临界区所有的读线程都结束了，才可以进入，可见：==rw（read/write）spinlock更加有利于读线程；== == seqlock（顺序锁）： == 加锁逻辑： 1、假设临界区内没有任何的thread，这个时候任何的读线程和写线程都可以键入 2、假设临界区内没有写线程的情况下，read线程可以任意进入； 3、假设临界区有一个写线程，这时候任何的读、写线程都不可以进入； 4、假设临界区内只有read线程的情况下，写线程可以理解执行，不会等待，可见：==seqlock（顺序锁）更加有利于写线程；== 读写速度 ： CPU > 一级缓存 > 二级缓存 > 内存 ，因此某一个CPU0的lock修改了，其他的CPU的lock就会失效；那么其他CPU就会依次去L1 L2和主存中读取lock值，一旦其他CPU去读取了主存，就存在系统性能降低的风险； mutex用于互斥操作。 互斥体只能用于一个线程，资源只有两种状态（占用或者空闲） 1、mutex的语义相对于信号量要简单轻便一些，在锁争用激烈的测试场景下，mutex比信号量执行速度更快，可扩展 性更好， 2、另外mutex数据结构的定义比信号量小;、 3、同一时刻只有一个线程可以持有mutex 4、不允许递归地加锁和解锁 5、当进程持有mutex时，进程不可以退出。 u2022 mutex必须使用官方API来初始化。 u2022 mutex可以睡眠，所以不允许在中断处理程序或者中断下半部中使用，例如tasklet、定时器等 ==常见操作：== struct mutex mutex_1; mutex_init(&mutex_1); mutex_lock(&mutex_1) 临界区代码； mutex_unlock(&mutex_1) ==常见函数：== =

。感觉我和一楼理解得不太一样……如果要同步赋值的话，可以这样写；int sb(*i){…………；}调用的时候这样：sb(&x);

自从进入21世纪以来，随着人类科技进步，中国的城市与乡村已驶入发展的快车道。无论你是居住在繁华的城市，还是居住在偏僻的乡村，都会感受到时代的气息扑面而来。放眼神州大地，交通网络四通八达，将城市与乡村紧密地连接在一起。触摸城市与感受乡村，会让你从不同的视角观察社会，了解改革开放带来的城乡巨变。当你步入长江三角洲和珠江三角洲，你会惊奇的发现，这里的城市与乡村已经没有多少差别，高楼与平房已经不是区别城市与乡村的标志。高耸的输变电线路，地下的输油管道，现代的高速公路，空中航道、水路航道和铁路大动脉，穿越祖国的东西南北，电灯、电视、电话、电冰箱、手机、互联网、摩托车、汽车早已经走入寻常百姓家。哪里是都市里的村庄，哪里是村庄里的都市，有时让你也难以分辨。 说起华西村的现代化程度，足以令大城市的居民汗颜。早在20年前大邱庄的当家人就坐上了奔驰轿车与外商谈判，当时的老革命有些看不惯，说：你是什麽级别？坐这麽高级别的车？人家回答说：我是农民，没有级别。这是工作需要，车就是投资环境，假如你系着白手巾，坐着驴吉普与老外谈判那成吗？据说，老革命无言以对。其实，随着市场经济的发展，随着改革开放的深入，人们的头脑早已经植入商品经济的理念，所谓"三十亩地一头牛，老婆孩子热炕头"的说法早已过时了。30年前的"旧四大件"，与现在的"新四大件"也无法可比。当青藏铁路通车之际，我们从电视上看到有多少藏族同胞笑逐颜开，他们懂得这是一条黄金之路，会带来多少商机，会带来多少财富？现代化的交通，从时间与空间上拉近了城市与乡村的距离，为你触摸城市与感受乡村提供了最便利的条件。 前几天，我从赤峰乘一辆奥迪车去北京办事，仅用了6个小时就到了。沿途欣赏着窗外的美丽景色，让人心旷神怡。路过茅荆坝时，细雨霏霏，两边青山笼罩在一片轻雾之中，偶见一片又一片黄的粉的红的野花在山谷和山坡上时隐时现，那感觉就是人在画中游。回来时，我们路过密云水库时，看见在路边摆设着卖山杏、桃子、樱桃、野菜的小地摊，禁不住诱惑停下车来，这里可以先尝后买，一番讨价还价后，我们坐在路边的石头上吃起来。那感受与在城里吃就是不一样。听卖主介绍，如果有兴趣你还可以走进离此不远的山里自己亲手采摘，只是价钱略高一些。因忙着赶路没有成行。不过，仍然留在那里的小餐馆吃了一顿农家饭。那是纯天然绿色食品，有刚摘下来的新鲜野菜和新捞上来的鲤鱼，还有玉米饽饽，小米粥。餐厅就在野外，可以一边吃，一边浏览风景。天上飘着白云，时有微风吹过，真是难得的享受。想起北京城里的高楼大厦、车水马龙、熙熙攘攘、人声鼎沸的嘈杂环境，这里真是一片乐土。尽管城乡差别正在大为缩小，当你触摸城市与感受乡村时，那种感同身受也是大不一样的。 写到这，我又想起十年前接待来自北京的一行客人的往事。在内蒙古翁牛特旗境内有一处风景优美的旅游点，叫做布日敦诺尔。这儿既有蓝天，又有碧水；既有沙漠，又有草原。放眼四望，远方的青山环抱着这片神奇的土地，飞扬的思绪把你带进遥远的时代。1998年夏天，时任旗广播电视局局长的我接待了来自中央电台的几位客人。席间，中央台戏剧部主任高坦应赤峰电台晨光之邀，与之对唱了草原情歌《敖包相会》。稍后两位蒙古族少女与一位马头琴歌手应邀进入蒙古包。他们身着节日的盛装，代表主人向北京来的客人敬酒、献歌，并以蒙古族最隆重的礼节向来自远方的朋友献上洁白的哈达。 马头琴歌手，拉起韵味悠长的马头琴，他边拉边唱，如诉如泣的琴声倾吐着一个民族苍凉而又古老的历史和动人的传说。兴趣所至，客人们也捉刀代笔，滥竽充数地拉上一番。 歌声、掌声、琴声、笑声、碰杯声交织在一起，至此，把宴会气氛推向了高潮。 此时，蒙古包外，又下起了蒙蒙细雨，这丝毫也没有冲淡客人们的酒兴，因为下雨天就是留客天嘛! 久居大都市的高坦深有感触地说：草原的天真蓝，草真绿，水真清，人真美，空气真新鲜，只有来到这里，才找到了一种回归自然的感觉。真想再看看草原的夜景是什么样。 雨过天晴，傍晚时分，高主任一行步出蒙古包来到湖边草甸子上。夕阳西下，玫瑰似的晚霞染红了天际，绿茵茵的草地挂满了露珠，恰在此时，东方的天际出现了一道彩虹，赤橙黄绿青蓝紫，谁持彩练当空舞? 对于草原上的人们来说，彩虹的出现是一种吉祥的象征，它预示着风调雨顺，牛羊兴旺；对于远方的客人而言，它又像一座友谊的桥梁，它连接着北京和草原，预示着大家的友谊地久天长。 写到这，我想对读者说，无论时代如何变迁，科技如何进步，当你触摸城市与感受乡村时，那年、那月、那事、那情、那景、那人都是不一样的，对吗？

进程至少包括一个主线程，还有工作线程狭隘的讲：线程通信就是进程范围内主线程与工作线程 或者 工作线程之间的通信进程通信，是进程A（可以理解为主线程） 与 进程B（可以理解为主线程）之间的通信

Linux系统中，实现线程同步的方式大致分为六种，包括：互斥锁、自旋锁、信号量、条件变量、读写锁、屏障。其最常用的线程同步方式就是互斥锁、自旋锁、信号量。1、互斥锁互斥锁本质就是一个特殊的全局变量，拥有lock和unlock两种状态，unlock的互斥锁可以由某个线程获得，当互斥锁由某个线程持有后，这个互斥锁会锁上变成lock状态，此后只有该线程有权力打开该锁，其他想要获得该互斥锁的线程都会阻塞，直到互斥锁被解锁。互斥锁的类型：①普通锁：互斥锁默认类型。当一个线程对一个普通锁加锁以后，其余请求该锁的线程将形成一个等待队列，并在锁解锁后按照优先级获得它，这种锁类型保证了资源分配的公平性。一个线程如果对一个已经加锁的普通锁再次加锁，将引发死锁;对一个已经被其他线程加锁的普通锁解锁，或者对一个已经解锁的普通锁再次解锁，将导致不可预期的后果。②检错锁：一个线程如果对一个已经加锁的检错锁再次加锁，则加锁操作返回EDEADLK;对一个已经被其他线程加锁的检错锁解锁或者对一个已经解锁的检错锁再次解锁，则解锁操作返回EPERM。③嵌套锁：该锁允许一个线程在释放锁之前多次对它加锁而不发生死锁;其他线程要获得这个锁，则当前锁的拥有者必须执行多次解锁操作;对一个已经被其他线程加锁的嵌套锁解锁，或者对一个已经解锁的嵌套锁再次解锁，则解锁操作返回EPERM。④默认锁：一个线程如果对一个已经解锁的默认锁再次加锁，或者对一个已经被其他线程加锁的默认锁解锁，或者对一个解锁的默认锁解锁，将导致不可预期的后果;这种锁实现的时候可能被映射成上述三种锁之一。2、自旋锁自旋锁顾名思义就是一个死循环，不停的轮询，当一个线程未获得自旋锁时，不会像互斥锁一样进入阻塞休眠状态，而是不停的轮询获取锁，如果自旋锁能够很快被释放，那么性能就会很高，如果自旋锁长时间不能够被释放，甚至里面还有大量的IO阻塞，就会导致其他获取锁的线程一直空轮询，导致CPU使用率达到100%，特别CPU时间。3、信号量信号量是一个计数器，用于控制访问有限共享资源的线程数。

信号量强调的是线程（或进程）间的同步：“信号量用在多线程多任务同步的，一个线程完成了某一个动作就通过信号量告诉别的线程，别的线程再进行某些动作（大家都 在sem_wait的时候，就阻塞在那里）。当信号量为单值信号量是，也可以完成一个资源的互斥访问。有名信号量：可以用于不同进程间或多线程间的互斥与同步创建打开有名信号量sem_t *sem_open(const char *name, int oflag);sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value);成功返回信号量指针；失败返回SEM_FAILED，设置errnoname是文件路径名,但不能写成/tmp/a.sem这样的形式,因为在linux下,sem都是在/dev/shm目录下,可写成"/mysem"或"mysem",创建出来的文件都 是"/dev/shm/sem.mysem",mode设置为0666，value设置为信号量的初始值.所需信号灯等已存在条件下指定O_CREAT|O_EXCL却是个错误。关闭信号量，进程终止时，会自动调用它int sem_close(sem_t *sem);成功返回0；失败返回-1，设置errno删除信号量，立即删除信号量名字，当其他进程都关闭它时，销毁它int sem_unlink(const char *name);等待信号量，测试信号量的值，如果其值小于或等于0，那么就等待（阻塞）；一旦其值变为大于0就将它减1，并返回int sem_wait(sem_t *sem);int sem_trywait(sem_t *sem);成功返回0；失败返回-1，设置errno当信号量的值为0时，sem_trywait立即返回，设置errno为EAGAIN。如果被某个信号中断，sem_wait会过早地返回，设置errno为EINTR发出信号量，给它的值加1，然后唤醒正在等待该信号量的进程或线程int sem_post(sem_t *sem);成功返回0；失败返回-1，不会改变它的值，设置errno，该函数是异步信号安全的，可以在信号处理程序里调用它无名信号量，用于进程体内各线程间的互斥和同步,使用如下API(无名信号量,基于内存的信号量)（1）、sem_init功能：用于创建一个信号量，并初始化信号量的值。头文件：函数原型： int sem_init (sem_t* sem, int pshared, unsigned int value);函数传入值： sem:信号量。pshared:决定信号量能否在几个进程间共享。由于目前LINUX还没有实现进程间共享信息量，所以这个值只能取0。（2）其他函数。int sem_wait (sem_t* sem);int sem_trywait (sem_t* sem);int sem_post (sem_t* sem);int sem_getvalue (sem_t* sem);int sem_destroy (sem_t* sem);功能：sem_wait和sem_trywait相当于P操作，它们都能将信号量的值减一，两者的区别在于若信号量的值小于零时，sem_wait将会阻塞进程，而sem_trywait则会立即返回。sem_post相当于V操作，它将信号量的值加一，同时发出唤醒的信号给等待的进程（或线程）。sem_getvalue 得到信号量的值。sem_destroy 摧毁信号量。如果某个基于内存的信号灯是在不同进程间同步的，该信号灯必须存放在共享内存区中，这要只要该共享内存区存在，该信号灯就存在。互斥锁(又名互斥量）强调的是资源的访问互斥：互斥锁是用在多线程多任务互斥的，一个线程占用了某一个资源，那么别的线程就无法访问，直到这个线程unlock，其他的线程才开始可以利用这个资源。比如对全局变量的访问，有时要加锁，操作完了，在解锁。有的时候锁和信号量会同时使用的”也就是说，信号量不一定是锁定某一个资源，而是流程上的概念，比如：有A,B两个线程，B线程要等A线程完成某一任务以后再进行自己下面的步骤，这个任务并不一定是锁定某一资源，还可以是进行一些计算或者数据处理之类。而线程互斥量则是“锁住某一资源”的概念，在锁定期间内，其他线程无法对被保护的数据进行操作。在有些情况下两者可以互换。在linux下, 线程的互斥量数据类型是pthread_mutex_t. 在使用前, 要对它进行初始化:对于静态分配的互斥量, 可以把它设置为PTHREAD_MUTEX_INITIALIZER, 或者调用pthread_mutex_init.对于动态分配的互斥量, 在申请内存(malloc)之后, 通过pthread_mutex_init进行初始化, 并且在释放内存(free)前需要调用pthread_mutex_destroy.原型:int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restric attr);int pthread_mutex_destroy(pthread_mutex_t *mutex);头文件:返回值: 成功则返回0, 出错则返回错误编号.说明: 如果使用默认的属性初始化互斥量, 只需把attr设为NULL. 其他值在以后讲解.首先说一下加锁函数:头文件:int pthread_mutex_lock(pthread_mutex_t *mutex);int pthread_mutex_trylock(pthread_mutex_t *mutex);返回值: 成功则返回0, 出错则返回错误编号.说 明: 具体说一下trylock函数, 这个函数是非阻塞调用模式, 也就是说, 如果互斥量没被锁住, trylock函数将把互斥量加锁, 并获得对共享资源的访问权限; 如果互斥量 被锁住了, trylock函数将不会阻塞等待而直接返回EBUSY, 表示共享资源处于忙状态.再说一下解所函数:头文件:原型: int pthread_mutex_unlock(pthread_mutex_t *mutex);返回值: 成功则返回0, 出错则返回错误编号.条件变量常与互斥锁同时使用，达到线程同步的目的：条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足。在发 送信号时，如果没有线程 等待在该条件变量上，那么信号将丢失；而信号量有计数值，每次信号量post操作都会被记录互斥锁必须是谁上锁就由谁来解锁，而信号量的wait和post操作不必由同一个线程执行。2. 互斥锁要么被锁住，要么被解开，和二值信号量类似3. sem_post是各种同步技巧中，唯一一个能在信号处理程序中安全调用的函数4. 互斥锁是为上锁而优化的；条件变量是为等待而优化的； 信号量既可用于上锁，也可用于等待，因此会有更多的开销和更高的复杂性5. 互斥锁，条件变量都只用于同一个进程的各线程间，而信号量（有名信号量）可用于不同进程间的同步。当信号量用于进程间同步时，要求信号量建立在共享内存区。6. 信号量有计数值，每次信号量post操作都会被记录，而条件变量在发送信号时，如果没有线程在等待该条件变量，那么信号将丢失。读写锁读写锁与互斥量类似，不过读写锁允许更高的并行性。互斥量要么是锁住状态要么是不加锁状态，而且一次只有一个线程可以对其加锁。读写锁可以由三种状态：读模式下加锁状态、写模式下加锁状态、不加锁状态。一次只有一个线程可以占有写模式的读写锁，但是多个线程可以同时占有读模式的读写锁。在读写锁是写加锁状态时，在这个锁被解锁之前，所有试图对这个锁加锁的线程都会被阻塞。当读写锁在读加锁状态时，所有试图以读模式对它进行加锁的线程都可以得到访问权，但是如果线程希望以写模式对此锁进行加锁，它必须阻塞直到所有的线程释放读锁。虽然读写锁的实现各不相同，但当读写锁处于读模式锁住状态时，如果有另外的线程试图以写模式加锁，读写锁通常会阻塞随后的读模式锁请求。这样可以避免读模式锁长期占用，而等待的写模式锁请求一直得不到满足。读写锁非常适合于对数据结构读的次数远大于写的情况。当读写锁在写模式下时，它所保护的数据结构就可以被安全地修改，因为当前只有一个线程可以在写模式下拥 有这个锁。当读写锁在读状态下时，只要线程获取了读模式下的读写锁，该锁所保护的数据结构可以被多个获得读模式锁的线程读取。读写锁也叫做共享-独占锁，当读写锁以读模式锁住时，它是以共享模式锁住的；当他以写模式锁住时，它是以独占模式锁住的。初始化和销毁:#includeint pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);成功则返回0, 出错则返回错误编号.同互斥量以上, 在释放读写锁占用的内存之前, 需要先通过thread_rwlock_destroy对读写锁进行清理工作, 释放由init分配的资源.读和写:#includeint pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);成功则返回0, 出错则返回错误编号.这3个函数分别实现获取读锁, 获取写锁和释放锁的操作. 获取锁的两个函数是阻塞操作, 同样, 非阻塞的函数为:#includeint pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);成功则返回0, 出错则返回错误编号.非阻塞的获取锁操作, 如果可以获取则返回0, 否则返回错误的EBUSY.虽然读写锁提高了并行性，但是就速度而言并不比互斥量快.可能这也是即使有读写锁存在还会使用互斥量的原因，因为他在速度方面略胜一筹。这就需要我们在写程序的时候综合考虑速度和并行性并找到一个折中。比如： 假设使用互斥量需要0.5秒，使用读写锁需要0.8秒。在类似学生管理系统这类软件中，可能百分之九十的时间都是查询操作，那么假如现在突然来个个20个请求，如果使用的是互斥量，那么最后的那个查询请求被满足需要10后。这样，估计没人能受得了。而使用读写锁，应为 读锁能够多次获得。所以所有的20个请求，每个请求都能在1秒左右得到满足。也就是说，在一些写操作比较多或是本身需要同步的地方并不多的程序中我们应该使用互斥量，而在读操作远大于写操作的一些程序中我们应该使用读写锁来进行同步条件变量(condition)条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生。条件本身是由互斥量保护的。线程在改变条件状态前必须首先锁住互斥量，其它线程在获得互斥量之前不会察觉到这种改变，因此必须锁定互斥量以后才能计算条件。条件的检测是在互斥锁的保护下进行的。如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两进程共享可读写的内存，条件变量可以被用来实现这两进程间的线程同步。初始化:条件变量采用的数据类型是pthread_cond_t, 在使用之前必须要进行初始化, 这包括两种方式:静态: 可以把常量PTHREAD_COND_INITIALIZER给静态分配的条件变量.动态: pthread_cond_init函数, 是释放动态条件变量的内存空间之前, 要用pthread_cond_destroy对其进行清理.#includeint pthread_cond_init(pthread_cond_t *restrict cond, pthread_condattr_t *restrict attr);int pthread_cond_destroy(pthread_cond_t *cond);成功则返回0, 出错则返回错误编号.注意：条件变量占用的空间并未被释放。当pthread_cond_init的attr参数为NULL时, 会创建一个默认属性的条件变量; 非默认情况以后讨论.2. 等待条件:#includeint pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restric mutex);int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict timeout);成功则返回0, 出错则返回错误编号.这两个函数分别是阻塞等待和超时等待.等待条件函数等待条件变为真, 传递给pthread_cond_wait的互斥量对条件进行保护, 调用者把锁住的互斥量传递给函数. 函数把调用线程放到等待条件的线程列表上, 然后对互斥量解锁, 这两个操作是原子的. 这样 便关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道, 这样线程就不会错过条件的任何变化.当pthread_cond_wait返回时, 互斥量再次被锁住.pthread_cond_wait函数的返回并不意味着条件的值一定发生了变化，必须重新检查条件的值。pthread_cond_wait函数返回时，相应的互斥锁将被当前线程锁定，即使是函数出错返回。阻塞在条件变量上的线程被唤醒以后，直到pthread_cond_wait()函数返回之前条件的值都有可能发生变化。所以函数返回以后，在锁定相应的互斥锁之前，必须重新测试条 件值。最好的测试方法是循环调用pthread_cond_wait函数，并把满足条件的表达式置为循环的终止条件。如：pthread_mutex_lock();while (condition_is_false)pthread_cond_wait();pthread_mutex_unlock();阻塞在同一个条件变量上的不同线程被释放的次序是不一定的。注意：pthread_cond_wait()函数是退出点，如果在调用这个函数时，已有一个挂起的退出请求，且线程允许退出，这个线程将被终止并开始执行善后处理函数，而这时和条 件变量相关的互斥锁仍将处在锁定状态。pthread_cond_timedwait函数到了一定的时间，即使条件未发生也会解除阻塞。这个时间由参数abstime指定。函数返回时，相应的互斥锁往往是锁定的，即使是函数出错返回。注意：pthread_cond_timedwait函数也是退出点。超时时间参数是指一天中的某个时刻。使用举例：pthread_timestruc_t to;to.tv_sec = time(NULL) + TIMEOUT;to.tv_nsec = 0;超时返回的错误码是ETIMEDOUT。3. 通知条件:#includeint pthread_cond_signal(pthread_cond_t *cond);int pthread_cond_broadcast(pthread_cond_t *cond);成功则返回0, 出错则返回错误编号.这两个函数用于通知线程条件已经满足. 调用这两个函数, 也称向线程或条件发送信号. 必须注意, 一定要在改变条件状态以后再给线程发送信号.

Linux 线程同步的三种方法线程的最大特点是资源的共享性，但资源共享中的同步问题是多线程编程的难点。linux下提供了多种方式来处理线程同步，最常用的是互斥锁、条件变量和信号量。一、互斥锁(mutex)通过锁机制实现线程间的同步。初始化锁。在Linux下，线程的互斥量数据类型是pthread_mutex_t。在使用前,要对它进行初始化。静态分配：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;动态分配：int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutex_attr_t *mutexattr);加锁。对共享资源的访问，要对互斥量进行加锁，如果互斥量已经上了锁，调用线程会阻塞，直到互斥量被解锁。int pthread_mutex_lock(pthread_mutex *mutex);int pthread_mutex_trylock(pthread_mutex_t *mutex);解锁。在完成了对共享资源的访问后，要对互斥量进行解锁。int pthread_mutex_unlock(pthread_mutex_t *mutex);销毁锁。锁在是使用完成后，需要进行销毁以释放资源。int pthread_mutex_destroy(pthread_mutex *mutex);[csharp] view plain copy#include <cstdio>#include <cstdlib>#include <unistd.h>#include <pthread.h>#include "iostream"using namespace std;pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;int tmp;void* thread(void *arg){cout << "thread id is " << pthread_self() << endl;pthread_mutex_lock(&mutex);tmp = 12;cout << "Now a is " << tmp << endl;pthread_mutex_unlock(&mutex);return NULL;}int main(){pthread_t id;cout << "main thread id is " << pthread_self() << endl;tmp = 3;cout << "In main func tmp = " << tmp << endl;if (!pthread_create(&id, NULL, thread, NULL)){cout << "Create thread success!" << endl;}else{cout << "Create thread failed!" << endl;}pthread_join(id, NULL);pthread_mutex_destroy(&mutex);return 0;}//编译：g++ -o thread testthread.cpp -lpthread二、条件变量(cond)互斥锁不同，条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程，直到某特殊情况发生为止。通常条件变量和互斥锁同时使用。条件变量分为两部分: 条件和变量。条件本身是由互斥量保护的。线程在改变条件状态前先要锁住互斥量。条件变量使我们可以睡眠等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。条件的检测是在互斥锁的保护下进行的。如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两进程共享可读写的内存，条件变量可以被用来实现这两进程间的线程同步。初始化条件变量。静态态初始化，pthread_cond_t cond = PTHREAD_COND_INITIALIER;动态初始化，int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);等待条件成立。释放锁,同时阻塞等待条件变量为真才行。timewait()设置等待时间,仍未signal,返回ETIMEOUT(加锁保证只有一个线程wait)int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);int pthread_cond_timewait(pthread_cond_t *cond,pthread_mutex *mutex,const timespec *abstime);激活条件变量。pthread_cond_signal,pthread_cond_broadcast（激活所有等待线程）int pthread_cond_signal(pthread_cond_t *cond);int pthread_cond_broadcast(pthread_cond_t *cond); //解除所有线程的阻塞清除条件变量。无线程等待,否则返回EBUSYint pthread_cond_destroy(pthread_cond_t *cond);[cpp] view plain copy#include <stdio.h>#include <pthread.h>#include "stdlib.h"#include "unistd.h"pthread_mutex_t mutex;pthread_cond_t cond;void hander(void *arg){free(arg);(void)pthread_mutex_unlock(&mutex);}void *thread1(void *arg){pthread_cleanup_push(hander, &mutex);while(1){printf("thread1 is running ");pthread_mutex_lock(&mutex);pthread_cond_wait(&cond, &mutex);printf("thread1 applied the condition ");pthread_mutex_unlock(&mutex);sleep(4);}pthread_cleanup_pop(0);}void *thread2(void *arg){while(1){printf("thread2 is running ");pthread_mutex_lock(&mutex);pthread_cond_wait(&cond, &mutex);printf("thread2 applied the condition ");pthread_mutex_unlock(&mutex);sleep(1);}}int main(){pthread_t thid1,thid2;printf("condition variable study! ");pthread_mutex_init(&mutex, NULL);pthread_cond_init(&cond, NULL);pthread_create(&thid1, NULL, thread1, NULL);pthread_create(&thid2, NULL, thread2, NULL);sleep(1);do{pthread_cond_signal(&cond);}while(1);sleep(20);pthread_exit(0);return 0;}[cpp] view plain copy#include <pthread.h>#include <unistd.h>#include "stdio.h"#include "stdlib.h"static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;struct node{int n_number;struct node *n_next;}*head = NULL;static void cleanup_handler(void *arg){printf("Cleanup handler of second thread./n");free(arg);(void)pthread_mutex_unlock(&mtx);}static void *thread_func(void *arg){struct node *p = NULL;pthread_cleanup_push(cleanup_handler, p);while (1){//这个mutex主要是用来保证pthread_cond_wait的并发性pthread_mutex_lock(&mtx);while (head == NULL){//这个while要特别说明一下，单个pthread_cond_wait功能很完善，为何//这里要有一个while (head == NULL)呢？因为pthread_cond_wait里的线//程可能会被意外唤醒，如果这个时候head != NULL，则不是我们想要的情况。//这个时候，应该让线程继续进入pthread_cond_wait// pthread_cond_wait会先解除之前的pthread_mutex_lock锁定的mtx，//然后阻塞在等待对列里休眠，直到再次被唤醒(大多数情况下是等待的条件成立//而被唤醒，唤醒后，该进程会先锁定先pthread_mutex_lock(&mtx);，再读取资源//用这个流程是比较清楚的pthread_cond_wait(&cond, &mtx);p = head;head = head->n_next;printf("Got %d from front of queue/n", p->n_number);free(p);}pthread_mutex_unlock(&mtx); //临界区数据操作完毕，释放互斥锁}pthread_cleanup_pop(0);return 0;}int main(void){pthread_t tid;int i;struct node *p;//子线程会一直等待资源，类似生产者和消费者，但是这里的消费者可以是多个消费者，而//不仅仅支持普通的单个消费者，这个模型虽然简单，但是很强大pthread_create(&tid, NULL, thread_func, NULL);sleep(1);for (i = 0; i < 10; i++){p = (struct node*)malloc(sizeof(struct node));p->n_number = i;pthread_mutex_lock(&mtx); //需要操作head这个临界资源，先加锁，p->n_next = head;head = p;pthread_cond_signal(&cond);pthread_mutex_unlock(&mtx); //解锁sleep(1);}printf("thread 1 wanna end the line.So cancel thread 2./n");//关于pthread_cancel，有一点额外的说明，它是从外部终止子线程，子线程会在最近的取消点，退出//线程，而在我们的代码里，最近的取消点肯定就是pthread_cond_wait()了。pthread_cancel(tid);pthread_join(tid, NULL);printf("All done -- exiting/n");return 0;}三、信号量(sem)如同进程一样，线程也可以通过信号量来实现通信，虽然是轻量级的。信号量函数的名字都以"sem_"打头。线程使用的基本信号量函数有四个。信号量初始化。int sem_init (sem_t *sem , int pshared, unsigned int value);这是对由sem指定的信号量进行初始化，设置好它的共享选项(linux 只支持为0，即表示它是当前进程的局部信号量)，然后给它一个初始值VALUE。等待信号量。给信号量减1，然后等待直到信号量的值大于0。int sem_wait(sem_t *sem);释放信号量。信号量值加1。并通知其他等待线程。int sem_post(sem_t *sem);销毁信号量。我们用完信号量后都它进行清理。归还占有的一切资源。int sem_destroy(sem_t *sem);[cpp] view plain copy#include <stdlib.h>#include <stdio.h>#include <unistd.h>#include <pthread.h>#include <semaphore.h>#include <errno.h>#define return_if_fail(p) if((p) == 0){printf ("[%s]:func error!/n", __func__);return;}typedef struct _PrivInfo{sem_t s1;sem_t s2;time_t end_time;}PrivInfo;static void info_init (PrivInfo* thiz);static void info_destroy (PrivInfo* thiz);static void* pthread_func_1 (PrivInfo* thiz);static void* pthread_func_2 (PrivInfo* thiz);int main (int argc, char** argv){pthread_t pt_1 = 0;pthread_t pt_2 = 0;int ret = 0;PrivInfo* thiz = NULL;thiz = (PrivInfo* )malloc (sizeof (PrivInfo));if (thiz == NULL){printf ("[%s]: Failed to malloc priv./n");return -1;}info_init (thiz);ret = pthread_create (&pt_1, NULL, (void*)pthread_func_1, thiz);if (ret != 0){perror ("pthread_1_create:");}ret = pthread_create (&pt_2, NULL, (void*)pthread_func_2, thiz);if (ret != 0){perror ("pthread_2_create:");}pthread_join (pt_1, NULL);pthread_join (pt_2, NULL);info_destroy (thiz);return 0;}static void info_init (PrivInfo* thiz){return_if_fail (thiz != NULL);thiz->end_time = time(NULL) + 10;sem_init (&thiz->s1, 0, 1);sem_init (&thiz->s2, 0, 0);return;}static void info_destroy (PrivInfo* thiz){return_if_fail (thiz != NULL);sem_destroy (&thiz->s1);sem_destroy (&thiz->s2);free (thiz);thiz = NULL;return;}static void* pthread_func_1 (PrivInfo* thiz){return_if_fail(thiz != NULL);while (time(NULL) < thiz->end_time){sem_wait (&thiz->s2);printf ("pthread1: pthread1 get the lock./n");sem_post (&thiz->s1);printf ("pthread1: pthread1 unlock/n");sleep (1);}return;}static void* pthread_func_2 (PrivInfo* thiz){return_if_fail (thiz != NULL);while (time (NULL) < thiz->end_time){sem_wait (&thiz->s1);printf ("pthread2: pthread2 get the unlock./n");sem_post (&thiz->s2);printf ("pthread2: pthread2 unlock./n");sleep (1);}return;}

条件变量（Condition Variable）是一种同步工具，允许线程暂停执行、进入休眠，直到某些共享资源满足条件。条件变量基本操作如下： 条件锁体现的是一种协作，一个线程完成后通知其他线程开始执行。Condition variable 必须和 mutex 关联，以避免竞争条件。一个线程获取锁后发现条件不满足，暂停线程执行进行等待，其他线程这时可以获取锁，条件满足后，向条件发出信号。 条件锁可用于生产者、消费者模式中状态同步： 当消费者发现没有数据时，等待 condition 变为1。生产者生产了新数据，condition 变为1，通知消费者。 这篇文章将介绍三种条件锁： pthread_cond_t 、 NSCondition 和 NSConditionLock 。 前面两篇文章已介绍过 pthread_mutex_t 和 pthread_mutexattr_t ，这里需额外使用 pthread_cond_t 。 使用 pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr) 初始化条件变量 cond，cond_attr 指定的 condition attribute。如果 cond_attr 为 nil，则使用默认属性。 pthread_cond_t 也可以使用PTHREAD_COND_INITIALIZER常量静态初始化。 如下所示： pthread_cond_signal() 和 pthread_cond_broadcast() 函数用于解除堵塞在条件变量上的线程。 如果多个线程堵塞在 cond，调度器决定唤醒哪个线程。使用 pthread_cond_signal() 、 pthread_cond_broadcast() 唤醒线程后，从 pthread_cond_wait() 和 pthread_cond_timedwait() 返回的线程会尝试持有 mutex。如果没有线程等待 cond，则什么也不发生。 pthread_cond_wait() 和 pthread_cond_timedwait() 函数用于堵塞条件变量。需先使用同一线程锁定 mutex，否则会导致无法预期结果。 解锁 mutex 与在条件变量处挂起线程是原子操作。线程先获取 mutex、后 signal 条件变量，可以避免线程在加锁后、等待条件变量前被唤醒。线程被挂起后不再占用 CPU 时间，直到 signal 条件变量。成功返回后，mutex 被该线程持有。 多个 mutex 并发使用同一个 condition variable 会产生无法预期的结果。也就是当线程等待 condition variable 时， cond 就绑定到了该 mutex。等待结束时，绑定关系终止。 pthread_cond_timedwait() 与 pthread_cond_wait() 类似，只是如果指定时间后还没有 signal、broadcast，就返回错误。 pthread_cond_destroy() 销毁指定cond，销毁后对象成为未初始化状态。销毁后的对象可以使用 pthread_cond_init() 再次初始化，其他方式使用已销毁的对象会产生无法预期的结果。 NSCondition 类是对 pthread_mutex_t 和 pthread_cond_t 的封装，为面向对象的类。 NSCondition 类遵守 NSLocking 协议。 初始化方法如下： GNUstep 中实现如下： signal() 一次唤醒一个线程，可以多次调用唤醒多个线程。 broadcast() 一次唤醒多个线程。 如果没有线程等待cond，则不执行任何操作。为避免竞争条件，应只在 condtion 锁定时调用。 GNUstep 中实现如下： 堵塞当前线程，直到 signal 或到达指定时间。必须先 lock NSCondition 再调用该方法。 GNUstep 中实现如下： NSConditionLock 类是对 pthread_mutex_t 和 pthread_cond_t 的封装，为面向对象的类，方。 NSConditionLock 类遵守 NSLocking 协议。 NSConditionLock 有一个关联值，即condition。在初始化 NSConditionLock 或释放锁时设置。线程会等待锁，直到其为特定值，等待期间不会占用 CPU 时间。借助 NSConditionLock condition值可以实现依赖项，使其按次序执行。 初始化方法如下： GNUstep 中实现如下： 当 NSConditionLock 的condition值与 lock(whenCondition:) 参数的值相同时，加锁成功，否则会堵塞在当前位置。 GNUstep 中实现如下： 释放锁，并设置 condition 值。 现在，上述三个方法按顺序执行。 GNUstep 中实现如下： Demo名称：Synchronization 源码地址： https://github.com/pro648/BasicDemos-iOS/tree/master/Synchronization 参考资料： 欢迎更多指正： https://github.com/pro648/tips 本文地址： https://github.com/pro648/tips/blob/master/sources/线程同步之条件锁.md

先看一下APUE第三版对于条件变量的说明: 条件变量是另一种线程同步机制，它为线程间共享的对象提供了同步的方法。当条件变量配合互斥锁(Mutex)使用时,允许多个线程处在一种自由等待任意条件发生的状态。 条件变量自身由互斥锁(Mutex)保护。线程必须在修改条件状态之前先对其上锁，其他线程不会在获取锁之前被通知到其状态变化，因为只有获取到锁才可以计算条件。 条件变量的数据类型是 pthread_cond_t ，条件变量属性的类型是 pthread_condattr_t ，它们都包含在头文件<pthread.h>中。 条件变量使用之前必须初始化，有两种方法： 需要释放条件变量时，使用pthread_cond_destroy即可。 调用phread_cond_wait或pthread_cond_timewait(以下简称wait函数)可以使当前线程等待某一条件的发生。两者的区别在于后者可以指定等待时间。 调用wait函数时，系统使调用线程进入等待状态后 释放锁 (所以我们必须先加锁后调用wait函数)。在这一步操作中的检查条件和进入等待是 原子操作 ，所以线程不会错过条件的变化。当wait函数返回时，mutex会 再次被加锁 。 其中pthread_cond_timewait中用到的timespec结构定义如下: 需要注意的是,timespec是一个绝对时间，所以在使用前我们需要先取得当前时间，再加上等待时间。例如下面这样： 如果时间到了还没有等到条件变化，函数会对mutex重新加锁并返回一个ETIMEOUT的错误。 当wait函数返回成功时， 需要重新检查条件 ，因为条件有可能已经被其他线程修改。 当条件满足时，可以用这两个函数用来通知其他线程。 pthread_cond_signal会唤醒至少一个等待的线程，而pthread_cond_broadcast会唤醒所有等待的线程。必须注意的是：我们 必须在状态发生变化之后再发送信号给其他线程 。 条件变量的数据类型是 pthread_cond_t ，它主要有两种属性： 设置进程间共享属性： 设置时钟属性： pthread_cond_timewait函数用于在等待条件变量时提供超时功能，不过该函数的超时时间是一个绝对时间。默认使用系统时间，这意味着若修改系统时间，那么超时就不准确：有可能提前返回，也可能要几年才返回。这在某些情况下会导致bug，这时我们可以通过设置条件变量的时钟属性来避免这个问题。下面的例子展示了如何使用这个属性：

要保证线程安全，就必须要线程同步，而在iOS中线程同步的方案有： 在 iOS 中，原子操作可以保证属性在单独的 setter 或者 getter 方法中是线程安全的，但是不能保证多个线程对同一个属性进行读写操作时，可以得到预期的值，也就是原子操作不保证线程安全，例如： 在 Objective-C 中，可以在设置属性的时候，使用 atomic 来设置原子属性，保证属性 setter 、 getter 的原子性操作，底层是在 getter 和 setter 内部使用 os_unfair_lock 加锁 在 Swift 中，原生没有提供原子操作，可以使用 DispatchQueue 的同步函数来达到同样的效果 pthread 表示 POSIX thread ，是 POSIX 标准的 unix 多线程库，定义了一组跨平台的线程相关的API。 pthread_mutex 是一种用 C 语言实现的互斥锁，有单一的拥有者 递归锁是一种特殊互斥锁。递归锁允许单个线程在释放之前多次获取锁，其他线程保持睡眠状态，直到锁的所有者释放锁的次数与获取它的次数相同。递归锁主要在递归迭代中使用，但也可能在多个方法需要单独获取锁的情况下使用。 pthread_mutex 支持递归锁，只要把 attr 的类型改成 PTHREAD_MUTEX_RECURSIVE 即可，它有单一的拥有者 NSRecursiveLock 是以 Objective-C 对象的形式对 pthread_mutex(Recursive) 的封装，它有单一的拥有者 条件锁是一种特殊互斥锁，需要条件变量(condition variable) 来配合。条件变量有点像信号量，提供了线程阻塞与信号机制，因此可以用来阻塞某个线程，并等待某个数据就绪，随后唤醒线程。条件锁是为了解决 生产者-消费者模型 pthread_mutex 配合 pthread_cond_t ，可以实现条件锁，其中 pthread_cond_t 没有拥有者 NSCondition 是以 Objective-C 对象的形式对 pthread_mutex 和 pthread_cond_t 进行了封装， NSCondition 没有拥有者 NSConditionLock 是对 NSCondition 的进一步封装，可以设置条件变量的值。通过改变条件变量的值，可以使任务之间产生依赖关系，达到使任务按照一定的顺序执行，它有单一的拥有者(不确定) 读写锁是一种特殊互斥锁，提供"多读单写"的功能，多个线程可以同时对共享资源进行读取，但是同一时间只能有一条线程对共享资源进行写入 pthread_rwlock 有多个拥有者 性能从高到底分别是： 总结： 苹果官方文档 白夜追凶，揭开iOS锁的秘密 起底多线程同步锁(iOS) 深入理解 iOS 开发中的锁

当把条件变量或互斥量放在共享内存区时，可用于进程间同步。同样的情况还有读写锁，它们都是随进程的持续性。

这是什么呀？要写作文吗？

. 仔细看时，才发现花瓣都是连在一起的。花瓣最底下点缀着姿色的斑点。最上面的花瓣呈深色的紫红，下面是粉色的，由花瓣把颜色过度的恰倒到好处。2. 我左瞧瞧，右看看，发现星空好似水晶棋盘，而星星们则是一颗颗珍珠棋子；再一看，这星空又如一个操场，星星们又成了一个个玩耍，嬉戏的孩子……3. 我发现，我最大的缺点就是缺钱。3. 造 句 网是一部在线造句词典,其宗旨是更快地造出更优质的句子.4. 做梦梦见自己在考试，惊醒.醒来发现自己居然在考试。5. 突然发现几棵鲜艳的花朵挂着白雪，显得更加妩媚艳丽，宛如初披婚纱的少女。6. 夏风是顽皮的。我走到树伯伯身旁，发现他生气地怒吼。哦！原来风打坏了他的树叶，气得他浑身发抖。这会儿，风又跑到哪儿去了呢？瞧！花儿被她打得低头哭泣，草儿也被她挠痒痒，笑得弯下了腰。7. 我们读书越多，就越发现我们是无知的。雪莱 8. 人生没有十全十美，如果你发现错了。重新再来，别人不原谅你，你可以自己原谅自己。千万不要用一个错误去掩盖另一个错误。9. 我观察银杏叶的时候发现，有的叶子还绿油油的，但有的叶子却已经黄了。第二天再看的时候，发现那小小的银杏叶变成了一把把五彩斑斓的小扇子。

【答案】： 一、1、0，2，4，6，8 2、0 5 3、2，4，6，8，10 1，3，5，7，9 4、10 5、186，188，190，192，194 6、2 二、1、√ 2、× 3、√ 4、× 5、× 6、× 7、√ 三、1、23，97，59，285，125 2、78，136，560 3、78，136，5604、560，285，125 5、560 四、1、201，205（答案不唯一） 2、102，502（答案不唯一） 3、250，520（答案不唯一） 五、1、5730，5732，5734，5736，5738 2、5730，5735 3、5730 六、1、2 4 6 8 12 24 2、（1）11 （2）21

【答案】： 一、1、5 7 35 35 5 7 2、24 6 6 24 3、1，2，3，4，6，8，12，24 4、5，10，15，20，25，30（答案不唯一） 5、有限的 1 它本身 6、无限的 它本身 二、1、× 2、× 3、× 4、× 5、√ 6、× 三、1、A 2、C 3、B 4、C 四、19 24 54 6或12

1.人的高贵不是拥有无数的金钱，也不是握有至高的权力，而是拥有纯洁的灵魂。2.黄盖富有战斗经验，观察到曹操的舰船紧紧相连，不便于移动和分散。3.曹操方面：盲目自大，士兵训练不精，在没有完全准备好的情况下发动战争；对所任用将领不信任。周瑜方面：上下一心，众将团结，勇敢，富有战斗经验。