虽然当时中国军人使用的大刀看起来威风凛凛，但实际上在实战时根本就不是日本刺刀和武士刀的对手。西班牙超高税率也成为C罗选择离开马德里的重要原因根据报道，上赛季西甲、西乙俱乐部以及球员、教练等工作人员上交了12.274亿欧元税款，占据西班牙GDP的1%，成为西班牙财政税收的重要来源。

立体声扬声器，逼真音频 立体声效由AKG调校的立体声扬声器为您带来更逼真的音效和更大的音量。案情指出，在2017年12月27日，有路人在西贡水浪窝露天停车场看见博美犬被困在车内，虽有粮食和水，但车窗完全闭上。

理由是在签订合同时，双方均明知闻天公司开发建设的紫杉庄园项目没有预售许可证，根据《最高人民法院关于审理商品房买卖合同纠纷案件适用法律若干问题的解释》第二条及《城市商品房预售管理办法》第六条的规定，双方签订的合同为无效合同，无效合同自始不发生法律效力。文章称，在20世纪60年代和70年代的冷战高峰期，苏联曾经是拥有世界最大武装力量的国家，其国内生产总值占美国的一半，并且拥有遍及整个东欧的势力范围。

如果你正打算对亚马逊进行新一轮的投资或者考虑将部分资金投入到股票市场，巴菲特、马克-库班和托尼-罗宾斯等经验丰富的投资者建议你要慎重投资。如果停下来找资料和攒稿，小说的思路就会中断，所以考虑再三，我说不写了，对方找了另一个作者写。

据了解，台湾于1月1日起扩大购物用塑料袋管制范围，新增七大类行业，包含药妆美妆店及药局、医疗器材行、家电摄影信息及通讯设备零售业、书局及文具零售业、洗衣店业、饮料店业和西点面包店业，都不可免费提供购物用塑料袋。在热播剧《楼外楼》中饰演杭州大商户之女李春贤的秦海璐则认为，“我沉迷于演的过程，至于谁在看，用什么方式看，跟我都没太大关系。

”江西省纪委监委相关负责人介绍，2017年，仅省一级层面，就问责了15个党组织、39名领导干部。浙江24小时-钱江晚报记者 陆芳8月11日下午，由工厂大门影业制片人黄旭峰制作，新锐导演佟晟嘉执导，被业内评价为“填补中国纪录片小人物传记空白”的《大三儿》，在杭州佳映影城举行提前看片。

中新网8月1日电 据台湾《联合报》报道，台湾医学专家1日公布的调查分析表明，机动车交通事故是台湾少儿第一大伤害致死原因，然而，超过1/3的台湾儿童乘坐摩托车没戴安全帽、超过半数乘车没系安全带、超过9成骑或搭乘自行车未戴安全帽，家长应特别留心孩子的交通安全。自动播放开关 自动播放 2017-18赛季英超各队五佳球——水晶宫 正在加载... 腾讯体育讯 北京时间8月11日晚22时，2018-19赛季英超首轮，富勒姆坐镇主场迎战水晶宫，腾讯体育将对这场比赛进行视频直播，敬请到时关注！1、升班马时隔4年返英超首秀：阔别4年，富勒姆终于回到了英超赛场，为了完成保级目标，富勒姆今夏斥资9800万英镑引进了多达12名球员，几乎可以换一支球队，这足可见农场主保级的决心。

解决争议靠裁判员投票，一国一票，简单多数即为通过，总裁判没有投票权，只有当赞成和反对票数相等时，他才有最后裁决权。《星球大战》海报拍得2.64万美元 夹克估价不菲参与这次拍卖的《星球大战：帝国反击战》原版海报（图片来自网络）参考消息网8月3日报道 外媒称，1980年上映的电影《星球大战：帝国反击战》的一份原版海报在美国达拉斯以2.64万美元（1美元约合人民币6.8元——本网注）的价格被拍卖。

5日接受表扬时，陈柏翰坦然地说：“我就是出生在这样的家庭，就要做应该做的事，用平常心……孝顺本来就是应该做的事！”他表示，自己会坚强，最大的心愿就是当个机械工程师，好好打拼与赚钱，有能力时，给家人买间房子，大家住在一起，会很快乐。不过记者也关注到，目前新能源汽车的赛道上有很多强劲的对手，东风标致是否能跑赢，尚待观察。

但在1.5米深的水下浸泡后，Galaxy Note9和S Pen依然可以继续工作。到医院开工资证明，“被保安打成双侧睾丸积液”孙振涛说，眼看仲裁书生效了将近一个月，医院却没有任何动静。

所谓“共有产权住房”，是指政府提供政策支持，由建设单位开发建设，销售价格低于同地段、同品质商品住房价格水平，并限定使用和处分权利，实行政府与购房人按份共有产权的政策性商品住房。来自世界各地的美食产品和当地的新鲜农业产品在拱形市场里汇聚，让人领略到舌尖上的世界风味和健康滋味。

我们希望每个开发者都能借助我们的工具获得成功，并期待您在开发旅程中踏出坚实的下一步！原报关单、报检单将合并为“一张大表”进行货物申报，将原报关、报检共229个申报项目精简为105个，对进口、出口货物报关单和进境、出境货物备案清单布局结构进行优化，版式由竖版改为横版，纸质单证采用普通打印方式，取消套打，不再印制空白格式单证。

中国电信、中国移动、中国联通、苹果、富士康、腾讯、华为等纷纷把数据中心、区域总部放在贵州。投资于本行信贷资产证券化产品优先级可以认为是间接投资于本行信贷资产，但由于《办法》只对次级档进行了强调，具体的认定还有待明确。

自2011年以来，中国在南太国家援助资金数量，图自《金融时报》，下同目前，澳大利亚仍是南太平洋地区最大的援助国。公开资料显示，比财是一个直销银行理财比价选择平台，目前覆盖了全国近百家直销银行，1000多款理财产品。

2、P皇9死超鬼GIF来了！BDD四度单杀 有一幕杀人又诛心第四分钟，BDD使用捡拾到的火箭腰带贴近P皇，随后催眠气泡睡到挂上捡到的虚弱，接上飞星乱入和被动平A的伤害，P皇仓促交闪现回塔下，残血状态下被BDD的佐伊闪现越塔挂上点燃单杀。如果在商务密集区建设一些慢充桩，在商场等人口密度大、流动性强的地方建设快充桩，再配合其他场景下的充电设施，基本上就能满足日常使用。

我们计划在今年重点发展以下几个方面：很多开发者都会使用到 ，我们会在其中添加更多测试工具，让开发者能够利用多条内部和外部测试渠道，降低应用在发布时的风险，此外开发者还可以通过分阶段发布 (Staged Rollout) 机制以获取富有价值的早期反馈。??总而言之，社区商业的形式较为灵活，可以根据外部环境以及自身的内在需求来进行改变，从而能够更好地适应市场环境的变化，降低了开发的风险。

在海南从事电动车展招商的一位负责人对记者表示，“电动汽车在海南省政府的扶持和激励下，已经取得一定成效。鼎轩副董事长关铁英认为，与京东合作，将进一步提升金鼎轩的门店库存周转率，达成降本增效，这对于餐饮企业的发展乃至连锁企业的变革都极具意义。

因此在被猫、狗咬伤或抓伤后仍需及时前往犬伤处置门诊处置伤口、接种狂犬病疫苗并按需接种抗狂犬病免疫球蛋白。更加值得注意的是，今年五月厄德高换了一位新的经纪人，新经纪人科瓦尔梅曾效力于西甲皇家社会，在西班牙联赛中广有人脉。

其中招商蛇口于2006年就开业了其位于深圳的首 个社区配套级产品线——花园城；万科则于2011年底开业了首 个社区商业项目——万科红生活广场。同时，7月底国常会以及政治局会议的召开，都确认了对信用紧缩格局的修正，在积极的财政政策以及加大基础设施领域补短板力度下，信用将进入改善阶段。

        进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，即进程空间或（虚空间）。进程不依赖于线程而独立存在，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。

        线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，线程没有自己的虚拟地址空间，与进程内的其他线程一起共享分配给该进程的所有资源。

        进程在执行过程中拥有独立的内存单元，进程有独立的地址空间，而多个线程共享内存，从而极大地提高了程序的运行效率。

        线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

        进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位。

        线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器,一组寄存器和栈），但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

        线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程包含以下内容：

•  一个指向当前被执行指令的指令指针；
• 一个寄存器值的集合，定义了一部分描述正在执行线程的处理器状态的值

        我们使用Join()方法挂起当前线程，直到调用Join()方法的线程执行完毕。该方法还存在包含参数的重载版本，其中的参数用于指定等待线程结束的最长时间（即超时）所花费的毫秒数。如果线程中的工作在规定的超时时段内结束，该版本的Join()方法将返回一个布尔量True。

• 一个程序至少有一个进程，一个进程至少有一个线程。
• 线程的划分尺度小于进程，使得多进程程序的并发性高。
• 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
• 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
• 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

        在Java中，每次程序运行至少启动2个线程：一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM实际上就是在操作系统中启动了一个进程。

        Java中，每个线程都有一个调用栈，即使不在程序中创建任何新的线程，线程也在后台运行着。

        当所有用户线程执行完毕的时候，JVM自动关闭。但是守候线程却不独立于JVM，守候线程一般是由操作系统或者用户自己创建的。

1. Thread类也实现了Runnable接口，因此，从Thread类继承的类的实例也可以作为target传入这个构造方法。
2. 直接实现Runnable接口类的实例。

        注意：对Java来说，run()方法没有任何特别之处。像main()方法一样，它只是新线程知道调用的方法名称（和签名）。因此，在Runnable上或者Thread上调用run方法是合法的。但并不启动新的线程。

        1、线程的名字，一个运行中的线程总是有名字的，名字有两个来源，一个是虚拟机自己给的名字，一个是你自己的定的名字。在没有指定线程名字的情况下，虚拟机总会为线程指定名字，并且主线程的名字总是mian，非主线程的名字不确定。

        4、在上面的代码中，只能保证：每个线程都将启动，每个线程都将运行直到完成。一系列线程以某种顺序启动并不意味着将按该顺序执行。对于任何一组启动的线程来说，调度程序不能保证其执行次序，持续时间也无法保证。

        6、一旦线程启动，它就永远不能再重新启动。只有一个新的线程可以被启动，并且只能一次。一个可运行的线程或死线程可以被重新启动。

        7、线程的调度是JVM的一部分，在一个CPU的机器上上，实际上一次只能运行一个线程。一次只有一个线程栈执行。JVM线程调度程序决定实际运行哪个处于可运行状态的线程。

        众多可运行线程中的某一个会被选中做为当前线程。可运行线程被选择运行的顺序是没有保障的。

        8、尽管通常采用队列形式，但这是没有保障的。队列形式是指当一个线程完成“一轮”时，它移到可运行队列的尾部等待，直到它最终排队到该队列的前端为止，它才能被再次选中。事实上，我们把它称为可运行池而不是一个可运行队列，目的是帮助认识线程并不都是以某种有保障的顺序排列而成一个一个队列的事实。

        9、尽管我们没有无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式。

        要理解线程调度的原理，以及线程执行过程，必须理解线程栈模型。

        线程栈是指某时刻时内存中线程调度的栈信息，当前调用的方法总是位于栈顶。线程栈的内容是随着程序的运行动态变化的，因此研究线程栈必须选择一个运行的时刻（实际上指代码运行到什么地方)。

        线程的状态转换是线程控制的基础。线程状态总的可以分为五大状态。用一个图来描述如下：

        2、可运行状态：当线程有资格运行，但调度程序还没有把它选定为运行线程时线程所处的状态。当start()方法调用时，线程首先进入可运行状态。在线程运行之后或者从阻塞、等待或睡眠状态回来后，也返回到可运行状态。

        3、运行状态：线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。

        4、等待/阻塞/睡眠状态：这是线程有资格运行时它所处的状态。实际上这个三状态组合为一种，其共同点是：线程仍旧是活的，但是当前没有条件运行。换句话说，它是可运行的，但是如果某件事件出现，他可能返回到可运行状态。

        5、死亡态：当线程的run()方法完成时就认为它死去。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。线程一旦死亡，就不能复生。如果在一个死去的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

        线程睡眠的原因：线程执行太快，或者需要强制进入下一轮，因为Java规范不保证合理的轮换。

        例如，在前面的例子中，将一个耗时的操作改为睡眠，以减慢线程的执行。可以这么写：

        这样，线程在每次执行过程中，总会睡眠3毫秒，睡眠了，其他的线程就有机会执行了。

        2、线程睡眠到期自动苏醒，并返回到可运行状态，不是运行状态。sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始执行。

1.  * 一个计数器，计数到100，在每个数字之间暂停1秒，每隔10个数字输出一个字符串 

        要理解yield()，必须了解线程的优先级的概念。线程总是存在优先级，优先级范围在1~10之间。JVM线程调度程序是基于优先级的抢先调度机制。在大多数情况下，当前运行的线程优先级将大于或等于线程池中任何线程的优先级。但这仅仅是大多数情况。

        注意：当设计多线程应用程序的时候，一定不要依赖于线程的优先级。因为线程调度优先级操作是没有保障的，只能把线程优先级作用作为一种提高程序效率的方法，但是要保证程序不依赖这种操作。

        当线程池中线程都具有相同的优先级，调度程序的JVM实现自由选择它喜欢的线程。这时候调度程序的操作有两种可能：一是选择一个线程运行，直到它阻塞或者运行完成为止。二是时间分片，为池内的每个线程提供均等的运行机会。

        线程优先级为1~10之间的正整数，JVM从不会改变一个线程的优先级。然而，1~10之间的值是没有保证的。一些JVM可能不能识别10个不同的值，而将这些优先级进行每两个或多个合并，变成少于10个的优先级，则两个或多个优先级的线程可能被映射为一个优先级。

         yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

        结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

线程的加入join()对线程栈导致的结果是线程栈发生了变化，当然这些变化都是瞬时的。下面给示意图：

        2、调用Thread.yield()：不能保障太多事情，尽管通常它会让当前运行线程回到可运行性状态，使得有相同优先级的线程有机会执行。

        3、调用join()方法：保证当前线程停止执行，直到该线程所加入的线程完成为止。然而，如果它加入的线程没有存活，则当前线程不需要停止。

        4、线程调度程序可以决定将当前运行状态移动到可运行状态，以便让另一个线程获得运行机会，而不需要任何理由。

        线程的同步是为了防止多个线程访问一个数据对象时，对数据造成的破坏。

        从结果发现，这样的输出值明显是不合理的，原因是两个线程不加控制的访问Foo对象并修改其数据所致。

        如果要保持结果的合理性，只需要达到一个目的，就是将对Foo的访问加以限制，每次只能有一个线程在访问。这样就能保证Foo对象中数据的合理性了。

        当程序运行到非静态的synchronized同步方法上时，自动获得与正在执行代码类的当前实例（this实例）有关的锁。获得一个对象的锁也称为获取锁、锁定对象、在对象上锁定或在对象上同步。

        一个对象只有一个锁。所以，如果一个线程获得该锁，就没有其他线程可以获得锁，直到第一个线程释放（或返回）锁。这也意味着任何其他线程都不能进入该对象上的synchronized方法或代码块，直到该锁被释放。

        2）每个对象只有一个锁；当提到同步时，应该清楚在什么上同步？也就是说，在哪个对象上同步？

        4）如果两个线程要执行一个类中的synchronized方法，并且两个线程使用相同的实例来调用方法，那么一次只能有一个线程能够执行方法，另一个需要等待，直到锁被释放。也就是说：如果一个线程在对象上获得一个锁，就没有任何其他线程可以进入（该对象的）类中的任何一个同步方法。

        5）如果线程拥有同步和非同步方法，则非同步方法可以被多个线程自由访问而不受锁的限制。

        7）线程可以获得多个锁。比如，在一个对象的同步方法里面调用另外一个对象的同步方法，则获取了两个对象的同步锁。

        8）同步损害并发性，应该尽可能缩小同步范围。同步不但可以同步整个方法，还可以同步方法中一部分代码块。

        9）在使用同步代码块时候，应该指定在哪个对象上同步，也就是说要获取哪个对象的锁。例如：

四、如果线程不能获得锁会怎么样

        如果线程试图进入同步方法，而其锁已经被占用，则线程在该对象上被阻塞。实质上，线程进入该对象的一种池中，必须在那里等待，直到其锁被释放，该线程再次变为可运行或运行为止。

        1、调用同一个对象中非静态同步方法的线程将彼此阻塞。如果是不同对象，则每个线程有自己的对象的锁，线程间彼此互不干预。

        3、静态同步方法和非静态同步方法将永远不会彼此阻塞，因为静态方法锁定在Class对象上，非静态方法锁定在该类的对象上。

        4、对于同步代码块，要看清楚什么对象已经用于锁定（synchronized后面括号的内容）。在同一个对象上进行同步的线程将彼此阻塞，在不同对象上锁定的线程将永远不会彼此阻塞。

        在多个线程同时访问互斥（可交换）数据时，应该同步以保护数据，确保两个线程不会同时修改更改它。

        如果需要在非静态方法中使用静态字段，或者在静态字段中调用非静态方法，问题将变得非常复杂。

        当一个类已经很好的同步以保护它的数据时，这个类就称为“线程安全的”。

        即使是线程安全类，也应该特别小心，因为操作的线程之间仍然不一定安全。

        举个形象的例子，比如一个集合是线程安全的，有两个线程在操作同一个集合对象，当第一个线程查询集合非空后，删除集合中所有元素的时候。第二个线程也来执行与第一个线程相同的操作，也许在第一个线程查询后，第二个线程也查询出集合非空，但是当第一个执行清除后，第二个再执行删除显然是不对的，因为此时集合已经为空了。

是同步的，但是程序还不是线程安全的。

        出现这种事件的原因是，上例中一个线程操作列表过程中无法阻止另外一个线程对列表的其他操作。

        死锁对Java程序来说，是很复杂的，也很难发现问题。当两个线程被阻塞，每个线程在等待另一个线程时就发生死锁。

        实际上，上面这个例子发生死锁的概率很小。因为在代码内的某个点，CPU必须从读线程切换到写线程，所以，死锁基本上不能发生。

        但是，无论代码中发生死锁的概率有多小，一旦发生死锁，程序就死掉。有一些设计方法能帮助避免死锁，包括始终按照预定义的顺序获取锁这一策略。已经超出SCJP的考试范围。

        2、线程同步方法是通过锁来实现，每个对象都有切仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他同步方法。

        3、对于静态同步方法，锁是针对这个类的，锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。

        5、编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。

        7、死锁是线程间相互等待锁锁造成的，在实际中发生的概率非常的小。真让你写个死锁程序，不一定好使，呵呵。但是，一旦程序发生死锁，程序将死掉。

        线程交互是比较复杂的问题，SCJP要求不很基础：给定一个场景，编写代码来恰当使用等待、通知和通知所有线程。

一、线程交互的基础知识

  wait()、notify()、notifyAll()都是Object的实例方法。与每个对象具有锁一样，每个对象可以有一个线程列表，他们等待来自该信号（通知）。线程通过执行对象上的wait()方法获得这个等待列表。从那时候起，它不再执行任何其他指令，直到调用对象的notify()方法为止。如果多个线程在同一个对象上等待，则将只选择一个线程（不保证以何种顺序）继续执行。如果没有线程等待，则不采取任何特殊操作。

        当在对象上调用wait()方法时，执行该代码的线程立即放弃它在对象上的锁。然而调用notify()时，并不意味着这时线程会放弃其锁。如果线程荣然在完成同步代码，则线程在移出之前不会放弃锁。因此，只要调用notify()并不意味着这时该锁变得可用。

二、多个线程在等待一个对象锁时候使用notifyAll()

        在多数情况下，最好通知等待某个对象的所有线程。如果这样做，可以在对象上使用notifyAll()让所有在此对象上等待的线程冲出等待区，返回到可运行状态。

        运行结果表明，程序中有异常，并且多次运行结果可能有多种输出结果。这就是说明，这个多线程的交互程序还存在问题。究竟是出了什么问题，需要深入的分析和思考，下面将做具体分析。

  实际上，上面这个代码中，我们期望的是读取结果的线程在计算线程调用notifyAll()之前等待即可。但是，如果计算线程先执行，并在读取结果线程等待之前调用了notify()方法，那么又会发生什么呢？这种情况是可能发生的。因为无法保证线程的不同部分将按照什么顺序来执行。幸运的是当读取线程运行时，它只能马上进入等待状态----它没有做任何事情来检查等待的事件是否已经发生。 ----因此，如果计算线程已经调用了notifyAll()方法，那么它就不会再次调用notifyAll()，----并且等待的读取线程将永远保持等待。这当然是开发者所不愿意看到的问题。

        通常，解决上面问题的最佳方式是利用某种循环，该循环检查某个条件表达式，只有当正在等待的事情还没有发生的情况下，它才继续等待。

        Java线程调度是Java多线程的核心，只有良好的调度，才能充分发挥系统的性能，提高程序的执行效率。

        这里要明确的一点，不管程序员怎么编写调度，只能最大限度的影响线程执行的次序，而不能做到精准控制。

        线程休眠的目的是使线程让出CPU的最简单的做法之一，线程休眠时候，会将CPU资源交给其他线程，以便能轮换执行，当休眠一定时间后，线程会苏醒，进入准备状态等待执行。

        与线程休眠类似，线程的优先级仍然无法保障线程的执行次序。只不过，优先级高的线程获取CPU资源的概率较大，优先级低的并非没机会执行。

        在一个线程中开启另外一个新线程，则新开线程称为该线程的子线程，子线程初始优先级与父线程相同。

        线程的让步含义就是使当前运行着线程让出CPU资源，但是让给谁不知道，仅仅是让出，线程状态回到可运行状态。

        线程的合并的含义就是将几个并行线程的线程合并为一个单线程执行，应用场景是当一个线程必须等待另一个线程执行完毕才能执行时可以使用join方法。

        守护线程使用的情况较少，但并非无用，举例来说，JVM的垃圾回收、内存管理等线程都是守护线程。还有就是在做数据库应用时候，使用的数据库连接池，连接池本身也包含着很多后台线程，监控连接个数、超时时间、状态等等。

        实际上：JRE判断程序是否执行结束的标准是所有的前台执线程行完毕了，而不管后台线程的状态，因此，在使用后台县城时候一定要注意这个问题。

        线程的同步是Java多线程编程的难点，往往开发者搞不清楚什么是竞争资源、什么时候需要考虑同步，怎么同步等等问题，当然，这些问题没有很明确的答案，但有些原则问题需要考虑，是否有竞争资源被同时改动的问题？

        在本部分之前，请参阅《Java线程：线程的同步与锁》部分，本部分是在此基础上所写的。

        为了演示同步方法的使用，构建了一个信用卡账户，起初信用额为100w，然后模拟透支、存款等多个操作。显然银行账户User对象是个竞争资源，而多个并发操作的是账户方法oper(int x)，当然应该在此方法上加上同步，并将账户的余额设为私有变量，禁止直接访问。

1. 线程A运行结束，增加“20”，当前用户账户余额为：120  
2. 线程F运行结束，增加“21”，当前用户账户余额为：141  
3. 线程D运行结束，增加“-30”，当前用户账户余额为：111  
4. 线程B运行结束，增加“-60”，当前用户账户余额为：51  
5. 线程E运行结束，增加“32”，当前用户账户余额为：83  
6. 线程C运行结束，增加“-80”，当前用户账户余额为：3  

1. 线程F运行结束，增加“21”，当前用户账户余额为：121  
2. 线程D运行结束，增加“-30”，当前用户账户余额为：91  
3. 线程B运行结束，增加“-60”，当前用户账户余额为：31  
4. 线程E运行结束，增加“32”，当前用户账户余额为：63  
5. 线程A运行结束，增加“20”，当前用户账户余额为：3  
6. 线程C运行结束，增加“-80”，当前用户账户余额为：-17  

        很显然，上面的结果是错误的，导致错误的原因是多个线程并发访问了竞争资源u，并对u的属性做了改动。

        通过前文可知，线程退出同步方法时将释放掉方法所属对象的锁，但还应该注意的是，同步方法中还可以使用特定的方法对线程进行调度。这些方法来自于java.lang.Object类。

        结合以上方法，处理多线程同步与互斥问题非常重要，著名的生产者-消费者例子就是一个经典的例子，任何语言多线程必学的例子。

        对于同步，除了同步方法外，还可以使用同步代码块，有时候同步代码块会带来比同步方法更好的效果。

        追其同步的根本的目的，是控制竞争资源的正确的访问，因此只要在访问竞争资源的时候保证同一时刻只能一个线程访问即可，因此Java引入了同步代码快的策略，以提高性能。

        在上个例子的基础上，对oper方法做了改动，由同步方法改为同步代码块模式，程序的执行逻辑并没有问题。

1. 线程B运行结束，增加“-60”，当前用户账户余额为：40  
2. 线程D运行结束，增加“-30”，当前用户账户余额为：10  
3. 线程F运行结束，增加“21”，当前用户账户余额为：31  
4. 线程E运行结束，增加“32”，当前用户账户余额为：63  
5. 线程C运行结束，增加“-80”，当前用户账户余额为：-17  
6. 线程A运行结束，增加“20”，当前用户账户余额为：3  

        同样，在同步程序块内调用yeild方法让出CPU资源也没有意义，因为你占用着锁，其他互斥线程还是无法访问同步程序块。当然与同步程序块无关的线程可以获得更多的执行时间。

        对于多线程程序来说，不管任何编程语言，生产者和消费者模型都是最经典的。就像学习每一门编程语言一样，Hello World！都是最经典的例子。

        实际上，准确说应该是“生产者-消费者-仓储”模型，离开了仓储，生产者消费者模型就显得没有说服力了。

1. 生产者仅仅在仓储未满时候生产，仓满则停止生产。
2. 消费者仅仅在仓储有产品时候才能消费，仓空则等待。
3. 当消费者发现仓储没产品可消费时候会通知生产者生产。
4. 生产者在生产出可消费产品时候，应该通知等待的消费者去消费。

1. 要生产的产品数量80超过剩余库存量60，暂时不能执行生产任务!  
2. 要生产的产品数量80超过剩余库存量60，暂时不能执行生产任务!  

        对于本例，要说明的是当发现不能满足生产或者消费条件的时候，调用对象的wait方法，wait方法的作用是释放当前线程的所获得的锁，并调用对象的notifyAll()方法，通知（唤醒）该对象上其他等待线程，使得其继续执行。这样，整个生产者、消费者线程得以正确的协作执行。

        notifyAll() 方法，起到的是一个通知作用，不释放锁，也不获取锁。只是告诉该对象上等待的线程“可以竞争执行了，都醒来去执行吧”。

  本例仅仅是生产者消费者模型中最简单的一种表示，本例中，如果消费者消费的仓储量达不到满足，而又没有生产者，则程序会一直处于等待状态，这当然是不对的。实际上可以将此例进行修改，修改为，根据消费驱动生产，同时生产兼顾仓库，如果仓不满就生产，并对每次最大消费量做个限制，这样就不存在此问题了，当然这样的例子更复杂，更难以说明这样一个简单模型。

        线程发生死锁可能性很小，即使看似可能发生死锁的代码，在运行时发生死锁的可能性也是小之又小。

        在《Java线程：线程的同步与锁》部分，简述了死锁的概念与简单例子，但是所给的例子是不完整的，这里给出一个完整的例子。

        Java语言包含两种内在的同步机制：同步块（或方法）和 volatile变量。这两种机制的提出都是为了实现代码线程的安全性。其中 Volatile变量的同步性较差（但有时它更简单并且开销更低），而且其使用也更容易出错。

        之所以要单独提出volatile这个不常用的关键字原因是这个关键字在高性能的多线程程序中也有很重要的用途，只是这个关键字用不好会出很多问题。

        要搞清楚这个问题，首先应该明白计算机内部都做什么了。比如做了一个i++操作，计算机内部做了三次处理：读取－修改－写入。

        同样，对于一个long型数据，做了个赋值操作，在32系统下需要经过两步才能完成，先修改低32位，然后修改高32位。

        假想一下，当将以上的操作放到一个多线程环境下操作时候，有可能出现的问题，是这些步骤执行了一部分，而另外一个线程就已经引用了变量值，这样就导致了读取脏数据的问题。

        Sun在Java5中，对Java线程的类库做了大量的扩展，其中线程池就是Java5的新特征之一，除了线程池之外，还有很多多线程相关的内容，为多线程的编程带来了极大便利。为了编写高效稳定可靠的多线程程序，线程部分的新增内容显得尤为重要。

        有关Java5线程新特征的内容全部在java.util.concurrent下面，里面包含数目众多的接口和类，熟悉这部分API特征是一项艰难的学习过程。目前有关这方面的资料和书籍都少之又少，大所属介绍线程方面书籍还停留在java5之前的知识层面上。

        当然新特征对做多线程程序没有必须的关系，在java5之前通用可以写出很优秀的多线程程序。只是代价不一样而已。

        线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多（未死亡）的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。

        在Java5之前，要实现一个线程池是相当有难度的，现在Java5为我们做好了一切，我们只需要按照提供的API来使用，即可享受线程池带来的极大便利。

        Java5的线程池分好多种：固定尺寸的线程池、单任务线程池、可变尺寸连接池、延迟连接池、单任务延迟连接池、自定义线程池。

        对于以上两种连接池，大小都是固定的，当要加入的池的线程（或者任务）超过池最大尺寸时候，则入此线程池需要排队等待。

1. //创建一个单任务执行线程池，它可安排在给定延迟后运行命令或者定期地执行。  

1. keepAliveTime -当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。  

1. 自定义连接池稍微麻烦些，不过通过创建的ThreadPoolExecutor线程池对象，可以获取到当前线程池的尺寸、正在执行任务的线程数、工作队列等等。  

        在Java5之前，线程是没有返回值的，常常为了“有”返回值，破费周折，而且代码很不好写。或者干脆绕过这道坎，走别的路了。现在Java终于有可返回值的任务（也可以叫做线程）了。

1. ReadWriteLock维护了一对相关的锁定，一个用于只读操作，另一个用于写入操作。  

        从上面的输出可以看到，利用锁对象太方便了，比直接在某个不知情的对象上用锁清晰多了。

        但一定要注意的是，在获取了锁对象后，用完后应该尽快释放锁，以便别的等待该锁的线程有机会去执行

        在上文中提到了Lock接口以及对象，使用它，很优雅的控制了竞争资源的安全访问，但是这种锁不区分读写，称这种锁为普通锁。为了提高性能，Java提供了读写锁，在读的地方使用读锁，在写的地方使用写锁，灵活控制，在一定程度上提高了程序的执行效率。

        下面这个例子是在文例子的基础上，将普通锁改为读写锁，并添加账户余额查询的功能，代码如下：

        在实际开发中，最好在能用读写锁的情况下使用读写锁，而不要用普通锁，以求更好的性能。

        Java的信号量实际上是一个功能完毕的计数器，对控制一定资源的消费与回收有着很重要的意义，信号量常常用于多线程的代码中，并能监控有多少数目的线程等待获取资源，并且通过信号量可以得知可用资源的数目等等，这里总是在强调“数目”二字，但不能指出来有哪些在等待，哪些资源可用。

        因此，本人认为，这个信号量类如果能返回数目，还能知道哪些对象在等待，哪些资源可使用，就非常完美了，仅仅拿到这些概括性的数字，对精确控制意义不是很大。目前还没想到更好的用法。

        从结果可以看出，信号量仅仅是对池资源进行监控，但不保证线程的安全，因此，在使用时候，应该自己控制线程的安全访问池资源。

        阻塞队列是Java5线程新特征中的内容，Java定义了阻塞队列的接口java.util.concurrent.BlockingQueue，阻塞队列的概念是，一个指定长度的队列，如果队列满了，添加新元素的操作会被阻塞等待，直到有空位为止。同样，当队列为空时候，请求队列元素的操作同样会阻塞等待，直到有可用元素为止。 

        可以看出，输出到元素19时候，就一直处于等待状态，因为队列满了，程序阻塞了。

        对于阻塞栈，与阻塞队列相似。不同点在于栈是“后入先出”的结构，每次操作的是栈顶，而队列是“先进先出”的结构，每次操作的是队列头。

        从上面结果可以看到，程序并没结束，而是阻塞住了，原因是栈已经满了，后面追加元素的操作都被阻塞了。

        条件变量是Java5线程中很重要的一个概念，顾名思义，条件变量就是表示条件的一种变量。但是必须说明，这里的条件是没有实际含义的，仅仅是个标记而已，并且条件的含义往往通过代码来赋予其含义。

        而在Java5中，一个锁可以有多个条件，每个条件上可以有多个线程等待，通过调用await()方法，可以让线程在该条件下等待。当调用signalAll()方法，又可以唤醒该条件下的等待的线程。有关Condition接口的API可以具体参考JavaAPI文档。

        条件变量比较抽象，原因是他不是自然语言中的条件概念，而是程序控制的一种手段。

        有一个账户，多个用户（线程）在同时操作这个账户，有的存款有的取款，存款随便存，取款有限制，不能透支，任何试图透支的操作都将等待里面有足够存款才执行操作。

        结合先前同步代码知识，举一反三，将此例改为同步代码块来实现，代码如下：

        对比以上三种方式，从控制角度上讲，第一种最灵活，第二种代码最简单，第三种容易犯错。

        所谓的原子量即操作变量的操作是“原子的”，该操作不可再分，因此是线程安全的。

        为何要使用原子变量呢，原因是多个线程对单个变量操作也会引起一些问题。在Java5之前，可以通过volatile、synchronized关键字来解决并发访问的安全问题，但这样太麻烦。

        从运行结果可以看出，虽然使用了原子量，但是程序并发访问还是有问题，那究竟问题出在哪里了？

        这里要注意的一点是，原子量虽然可以保证单个变量在某一个操作过程的安全，但无法保证你整个代码块，或者整个程序的安全性。因此，通常还应该使用锁等同步机制来控制整个程序的安全性。

        这里使用了一个对象锁，来控制对并发代码的访问。不管运行多少次，执行次序如何，最终余额均为21000，这个结果是正确的。

        有关原子量的用法很简单，关键是对原子量的认识，原子仅仅是保证变量操作的原子性，但整个程序还需要考虑线程安全的。

        Java5中，添加了障碍器类，为了适应一种新的设计需求，比如一个大型的任务，常常需要分配好多子任务去执行，只有当所有子任务都执行完成时候，才能执行主任务，这时候，就可以选择障碍器了。

1. [子任务A]开始执行完成了，并通知障碍器已经完成！  
2. [子任务D]开始执行完成了，并通知障碍器已经完成！  
3. [子任务C]开始执行完成了，并通知障碍器已经完成！  
4. [子任务B]开始执行完成了，并通知障碍器已经完成！  
5. [子任务F]开始执行完成了，并通知障碍器已经完成！  
6. [子任务E]开始执行完成了，并通知障碍器已经完成！  
7. [子任务G]开始执行完成了，并通知障碍器已经完成！  

        从执行结果可以看出，所有子任务完成的时候，主任务执行了，达到了控制的目标。