当前位置：文档库 › 白话C#：多线程

白话C#：多线程

作者：Autumoon来源：博客园酷勤网收集 2008-06-28

摘要

酷勤网

使用多线程的时候常常需要考虑的并发问题，所以用了lock关键字，当一个线程要操作Contracts 时，它先把Contracts锁起来，就是声明一下：“现在我在操作它，你们谁都不要动，等我弄完了再说。”在lock块结束时被锁定的对象才会被解锁，其它线程才可以去操作它。

系列文章索引：《白话C#》

多线程是程序员面试时常常会面对的问题，对多线程概念的掌握和理解水平，也会被一些老鸟用来衡量一个人的编程实力的重要参考指标。不论是实际工作需要还是为了应付面试，掌握多线程都是程序员职业生涯中一个必须经过的环节。其实当你把“多线程”和你的“职业生涯”联系在一起考虑的时候，就会觉得“多线程”是多么的渺小，对，没有跨越不过的山。不过就算它很渺小，但也有可能改变你的人生轨迹。不用担心，如果你对多线程还不太熟悉，那么我们就一起来看看什么是多线程吧。

跟前几篇的风格一样，我会在开篇的时候举一个现实生活中的例子，通过这个例子来映射一些晦涩枯燥的计算机编程专业知识，在让读者朋友很好地理解理论概念的同时，又避免了阅读教科书时的枯燥感觉。这次我要举的例子是公司。不一定是IT公司，尽量和编程领域远一点儿吧，那就假设是一家搬家公司吧。

假如我们把公司看做是一个进程，那么人就是其中的线程。进程必须得有一个主线程，公司在创业初期往往可能出现一人打天下的现象，但是，至少得有一个人，公司才能运作。公司创业初期，业务还不算太多，往往就是老板一个人身兼数职，一天如果只有1、2趟活儿，应该还是忙得过来的。时间长了，随着业务的发展、口碑地建立，生意越来越兴隆，一个人肯定就忙不过来了。假设一天有5个活儿，老板一个人必须搬完A家才能搬B家，搬到黄昏估计也就搬到C家，D和E家都还在焦急地等待着呢。老板一个人要充当搬运工、司机、业务联系人、法人代表、出纳等众多角色，累死累活公司的规模也上不去，人手不够制约了公司的发展。那么怎么办，很简单，增加人手，用编程的话来说就是“再起个线程”。

我们现在就用代码来描述这样的场景吧，首先，我们准备成立一家搬家公司，于是要准备好将来和客户签的合同书：

1:public class Contract

2: {

3:public string ID { get; private set; }

4:public string From { get; set; }

5:public string To { get; set; }

6:public decimal Fee { get; set; }

8:public Contract()

9: {

10:this.ID = DateTime.Now.ToBinary().ToString().Replace("-", String.Empty);

11: }

12: }

简是简单了点儿，好歹也是份合同，现在我们就去申请注册一家公司，并组建好初创团队，哪怕目前还只有老板一个人：

1:public class HouseMovingCompany

2: {

3:private static HouseMovingCompany _instance = null;

4:public static HouseMovingCompany Instance

5: {

6: get { return (_instance == null ? _instance = new HouseMovingCompany() :

_instance); }

7: }

9:public List Contracts { get; private set; }

10:

11:public HouseMovingCompany()

12: {

13:this.Contracts = new List();

14: }

15:

16:public void MoveHouse()

17: {

18:if (this.Contracts == null || this.Contracts.Count == 0)

19: {

20:return;

21: }

22:

23: Contract contract = contract = this.Contracts[0];

24:this.Contracts.RemoveAt(0);

25:

26:if (!String.IsNullOrEmpty(contract.From)

&& !String.IsNullOrEmpty(contract.To))

27: {

28: Console.WriteLine("Move the house from {0} to {1}.", contract.From, contract.To);

29: }

30:

31: Thread.Sleep(5000);

32: }

33: }

好了，现在公司实体有了，老板就可以开始忙活了：

1:static void Main(string[] args)

2: {

3: HouseMovingCompany.Instance.Contracts.Add(new Contract { From = "WuDaokou", To = "LinDa Road", Fee = 500 });

5:while (HouseMovingCompany.Instance.Contracts.Count > 0)

6: {

7: HouseMovingCompany.Instance.MoveHouse();

8: }

9: }

我们在前面设置了每次搬家耗时5秒钟，咱们把它想象成5个小时。嗯，一天接一个单子，还可以接受，但是随着老板生意日渐兴隆，有时候一天要接3个单子，这就最少要工作15个小时了，还要操心公司的运营等问题，的确忙不过来了，而且照这样算，老板一天不可能完成5个或5个以上的单子，严重制约了公司的发展：

1:static void Main(string[] args)

2: {

3: HouseMovingCompany.Instance.Contracts.Add(new Contract { From = "WuDaokou", To = "LinDa Road", Fee = 500 });

4: HouseMovingCompany.Instance.Contracts.Add(new Contract { From = "XiDan", To = "WangFujing", Fee = 1000 });

5: HouseMovingCompany.Instance.Contracts.Add(new Contract { From = "XiangShan", To = "The Forbidden City", Fee = 10000 });

7:while (HouseMovingCompany.Instance.Contracts.Count > 0)

8: {

9: HouseMovingCompany.Instance.MoveHouse();

10: }

11: }

一天夜里，老板拖着疲倦的身子回到家里，一进门就一头倒在床上，他极力睁着快睁不开的眼睛，努力地对自己说：“不行，我一定要想个办法，不然我会被累死的！”。

其实办法很简单，谁都知道，招聘几个员工，再买几辆车，大家分头行动，不仅分担了工作负担，而且在规模扩大的同时还可以完成更多更大的单子。好，我们现在就借助多线程机制来实现我们的想法：

1:static void Main(string[] args)

2: {

3: HouseMovingCompany.Instance.Contracts.Add(new Contract { From = "WuDaokou", To = "LinDa Road", Fee = 500 });

4: HouseMovingCompany.Instance.Contracts.Add(new Contract { From = "XiDan", To = "WangFujing", Fee = 1000 });

5: HouseMovingCompany.Instance.Contracts.Add(new Contract { From = "XiangShan", To = "The Forbidden City", Fee = 10000 });

7: Thread thread = null;

9:while (HouseMovingCompany.Instance.Contracts.Count > 0)

10: {

11: thread = new Thread(new ThreadStart(HouseMovingCompany.Instance.MoveHouse)); 12:

13: thread.Start();

14: }

15: }

在这段程序中，我们分头行动，让每项搬家任务都由一个小团队去完成，结果我们发现，现在做三个单子的时间跟做一个单子的时间是一样的，提高了效率也扩大了公司规模。但是，既然引入了新的工作机制，我们在公司内部也不得不做一些小小的调整：

1:public void MoveHouse()

2: {

3:if (this.Contracts == null || this.Contracts.Count == 0)

4: {

5:return;

6: }

8: Contract contract = null;

10:lock (this.Contracts)

11: {

12: contract = this.Contracts[0];

13:this.Contracts.RemoveAt(0);

14: }

15:

16:if(!String.IsNullOrEmpty(contract.From) && !String.IsNullOrEmpty(contract.To)) 17: {

18: Console.WriteLine("Move the house from {0} to {1}.", contract.From, contract.To);

19: }

20:

21: Thread.Sleep(5000);

22: }

调整的只是MoveHouse这个方法内部的一些实现细节。公司接到的单子都保存在Contracts 中，所以搬家的时候需要去拿一个单子然后根据单子上的信息来工作。原先我们只有一个线程在操作Contracts，倒也不觉得什么，现在有多个线程都在对Contracts中的元素进行存取，我们不得不提防一些意外发生。这就是在使用多线程的时候常常需要考虑的并发问题，所以我们用了lock关键字，当一个线程要操作Contracts时，它先把 Contracts锁起来，其实就是声明一下：“现在我在操作它，你们谁都不要动，等我弄完了再说。”在lock块结束时被锁定的对象才会被解锁，其它的线程现在才可以去操作它。

有了多线程机制，你会发现程序可以在更短的时间内完成更多的事情。本文没有将多线程机制中的所有概念面面俱到地列举出来，但是已经向你展示了该如何使用多线程以及什么时候可以考虑使用多线程，其它的一些细节有待你去进一步探索，例如，你可以设置线程的优先级（假设逻辑上跟Fee挂钩，类似于'加急’）等等。

掌握多线程机制，并让它使你的应用程序变得更加强悍吧。

多线程编程的详细说明完整版

VB .NET多线程编程的详细说明作者：陶刚整理：https://www.wendangku.net/doc/e95305557.html, 更新时间：2011-4-1 介绍传统的Visual Basic开发人员已经建立了同步应用程序，在这些程序中事务按顺序执行。尽管由于多个事务多多少少地同时运行使多线程应用程序效率更高，但是使用先前版本的Visual Basic很难建立这类程序。多线程程序是可行的，因为操作系统是多任务的，它有模拟同一时刻运行多个应用程序的能力。尽管多数个人计算机只有一个处理器，但是现在的操作系统还是通过在多个执行代码片断之间划分处理器时间提供了多任务。线程可能是整个应用程序，但通常是应用程序可以单独运行的一个部分。操作系统根据线程的优先级和离最近运行的时间长短给每一个线程分配处理时间。多线程对于时间密集型事务（例如文件输入输出）应用程序的性能有很大的提高。但是也有必须细心的地方。尽管多线程能提高性能，但是每个线程还是需要用附加的内存来建立和处理器时间来运行，建立太多的线程可能降低应用程序的性能。当设计多线程应用程序时，应该比较性能与开销。多任务成为操作系统的一部分已经很久了。但是直到最近Visual Basic程序员才能使用无文档记录特性（undocumented）或者间接使用COM组件或者操作系统的异步部分执行多线程事务。.NET框架组件为开发多线程应用程序，在System.Threading名字空间中提供了全面的支持。本文讨论多线程的好处以及怎样使用Visual Basic .NET开发多线程应用程序。尽管Visual Basic .NET和.NET框架组件使开发多线程应用程序更容易，但是本文作了调整使其适合高级读者和希望从早期Visual Basic转移到Visual Basic .NET的开发人员。多线程处理的优点尽管同步应用程序易于开发，但是它们的性能通常比多线程应用程序低，因为一个新的事务必须等待前面的事务完成后才能开始。如果完成某个同步事务的时间比预想的要长，应用程序可能没有响应。多线程处理可以同时运行多个过程。例如，字处理程序能够在继续操作文档的同时执行拼写检查事务。因为多线程应用程序把程序分解为独立的事务，它们能通过下面的途径充分提高性能： l 多线程技术可以使程序更容易响应，因为在其它工作继续时用户界面可以保持激活。 l 当前不忙的事务可以把处理器时间让给其它事务。 l 花费大量处理时间的事务可以周期性的把时间让给其它的事务。 l 事务可以在任何时候停止。 l 可以通过把单独事务的优先级调高或调低来优化性能。明确地建立多线程应用程序的决定依赖于几个因素。多线程最适合下面的情况：

解决多线程中11个常见问题

并发危险解决多线程代码中的11 个常见的问题 Joe Duffy 本文将介绍以下内容：?基本并发概念 ?并发问题和抑制措施 ?实现安全性的模式?横切概念本文使用了以下技术：多线程、.NET Framework 目录数据争用忘记同步粒度错误读写撕裂无锁定重新排序重新进入死锁锁保护戳记两步舞曲优先级反转实现安全性的模式不变性纯度隔离并发现象无处不在。服务器端程序长久以来都必须负责处理基本并发编程模型，而随着多核处理器的日益普及，客户端程序也将需要执行一些任务。随着并发操作的不断增加，有关确保安全的问题也浮现出来。也就是说，在面对大量逻辑并发操作和不断变化的物理硬件并行性程度时，程序必须继续保持同样级别的稳定性和可靠性。与对应的顺序代码相比，正确设计的并发代码还必须遵循一些额外的规则。对内存的读写以及对共享资源的访问必须使用同步机制进行管制，以防发生冲突。另外，通常有必要对线程进行协调以协同完成某项工作。这些附加要求所产生的直接结果是，可以从根本上确保线程始终保持一致并且保证其顺利向前推进。同步和协调对时间的依赖性很强，这就导致了它们具有不确定性，难于进行预测和测试。这些属性之所以让人觉得有些困难，只是因为人们的思路还未转变过来。没有可供学习的专门API，也没有可进行复制和粘贴的代码段。实际上的确有一组基础概念需要您学习和适应。很可能随着时间的推移某些语言和库会隐藏一些概念，但如果您现在就开始执行并发操作，则不会遇到这种情况。本

文将介绍需要注意的一些较为常见的挑战，并针对您在软件中如何运用它们给出一些建议。首先我将讨论在并发程序中经常会出错的一类问题。我把它们称为“安全隐患”，因为它们很容易发现并且后果通常比较严重。这些危险会导致您的程序因崩溃或内存问题而中断。当从多个线程并发访问数据时会发生数据争用（或竞争条件）。特别是，在一个或多个线程写入一段数据的同时，如果有一个或多个线程也在读取这段数据，则会发生这种情况。之所以会出现这种问题，是因为Windows 程序（如C++ 和Microsoft .NET Framework 之类的程序）基本上都基于共享内存概念，进程中的所有线程均可访问驻留在同一虚拟地址空间中的数据。静态变量和堆分配可用于共享。请考虑下面这个典型的例子： static class Counter { internal static int s_curr = 0; internal static int GetNext() { return s_curr++; } } Counter 的目标可能是想为GetNext 的每个调用分发一个新的唯一数字。但是，如果程序中的两个线程同时调用GetNext，则这两个线程可能被赋予相同的数字。原因是s_curr++ 编译包括三个独立的步骤： 1.将当前值从共享的s_curr 变量读入处理器寄存器。 2.递增该寄存器。 3.将寄存器值重新写入共享s_curr 变量。按照这种顺序执行的两个线程可能会在本地从s_curr 读取了相同的值（比如42）并将其递增到某个值（比如43），然后发布相同的结果值。这样一来，GetNext 将为这两个线程返回相同的数字，导致算法中断。虽然简单语句s_curr++ 看似不可分割，但实际却并非如此。忘记同步这是最简单的一种数据争用情况：同步被完全遗忘。这种争用很少有良性的情况，也就是说虽然它们是正确的，但大部分都是因为这种正确性的根基存在问题。这种问题通常不是很明显。例如，某个对象可能是某个大型复杂对象图表的一部分，而该图表恰好可使用静态变量访问，或在创建新线程或将工作排入线程池时通过将某个对象作为闭包的一部分进行传递可变为共享图表。当对象（图表）从私有变为共享时，一定要多加注意。这称为发布，在后面的隔离上下文中会对此加以讨论。反之称为私有化，即对象（图表）再次从共享变为私有。对这种问题的解决方案是添加正确的同步。在计数器示例中，我可以使用简单的联锁： static class Counter { internal static volatile int s_curr = 0; internal static int GetNext() { return Interlocked.Increment(ref s_curr);

多线程技术在Android手机开发中的运用

龙源期刊网 https://www.wendangku.net/doc/e95305557.html, 多线程技术在Android手机开发中的运用作者：谢光刘志惠来源：《电子技术与软件工程》2017年第24期摘要在Android手机开发过程中，一般情况下程序是通过一个线程进行工作的，因此当一个任务耗费过长时间，就会造成主程序无响应并对程序运行的顺畅程度造成影响的问题。基于此，本文通过对多线程组成进行介绍，在Android中多线程技术模块与具体实现方式两方面对多线程技术在安卓手机开发中的运用进行探讨，以为关注此问题的人们提供参考。【关键词】多线程技术 Android手机进程线程安卓系统自2007年由谷歌公司开发后，得到了巨大的发展。截至2017年3月，其市场占有率已经达到86.4%，如三星、索尼爱立信、小米、OPPO等手机生产厂商都在使用安卓系统。该系统开源免费、执行效率高，其多线程技术开发应用的研究，对提高手机硬件的利用效率，给用户带来良好试用体验，提高手机厂商的企业竞争力有重要作用。 1 多线程介绍 1.1 进程和线程介绍一般来说，在一定时间内实现多个程序任务执行的程序都会用到“进程”这一概念。进程，即：一个拥有自身独立的内存空间、系统资源的执行程序，其特征为实现内部状态和内部数据的相互独立。线程与进程相似，线程也是一段有一定功能代码组成的流控制。线程的特征为：同类的多个线程可以对内存空间与系统资源进行共享。因此在对资源的占用方面，可以相互切换的线程比进程小很多。一个进程中可以包含诸多线程，此外，主线程对子线程有控制作用，可对子线程启动、停止等动作进行管理。而本文要重点介绍的多线程，指的是单个程序中一起运行的不同线程，不同线程可以执行不一样的任务。其特征是一个程序的多行语句可在某时间同时执行。 1.2 多线程程序消息处理原理当人们启动一个程序时，系统将建立main线程，主要管理如：activity等应用组件，并对UI相关的事件进行处理，比如用户想要按键或使用屏幕进行绘图，线程会对以上事件进行处理，这是UI线程。安卓的线程模型，所有组件均在main线程中，因此用户在程序中下达下载文件、使用数据库等具有高耗时特征的操作时，就会造成UI线程的运行不畅，并出现程序无法响应的问题。这就要求程序员使用多线程技术，在进行安卓多线程编写时，技术人员应注意以下两点：

基于多线程的高性能服务器程序的设计

基于多线程的高性能服务器程序的设计摘要：随着网络应用的迅猛发展，高性能服务器程序越来越凸显出其重要地位。文中基于多线程设计了高性能服务器程序，从而对处理客户端的并发请求问题提出了很好的解决方案。文中首先介绍了IOCP模型的原理，接着分别运用Select 模型和IOCP模型对高性能服务器程序的设计提出了不同的设计方法，通过比较时间、CPU的利用率和内存的使用率等参数，得出IOCP在设计服务器上提供了最佳的系统性能。最后提出了高性能服务器程序的设计方案。关键字：Select 模型；IOCP模型；并发控制；事件；流的控制 1引言目前很多服务器程序都是采用“一对一”处理模式，即一个客户占用一个线程，基于这种模式的服务器程序在框架上设计很简单，但是由于采用的是“一客户/一线程”的模式，所以这种服务器程序对于上千客户的请求连接，其在性能上就显得很低，在系统资源上的开销也很大。由于操作系统必须为大量的线程进行调度，从而会损耗大量的系统资源，另外互斥控制也会显得很困难，死锁发生的频率也会大幅度的增大。现如今高性能服务器程序的设计显得越来越重要，高性能服务器程序的主要作用是能够高效的处理大量并发客户的请求，并且快速及时的处理客户的数据，同时将部分应答信息回传给客户端。要设计好一个性能优良的服务器程序，要考虑很多方面的因素，如CPU的使用率、Memory的开销等。要想做到高效处理并发用户的请求，服务器程序就需要解决两个主要的问题，一是处理并发客户的连接请求，二是对并发数据的处理。要解决这些问题，可以根据处理器内核的数量，来创建等量的工作线程,并结合IOCP（Input／Output Completion Port，IOCP)）模型，以及操作系统的线程调度机制。文中采用多线程并结合IOCP模型对高性能的服务器程序设计进行了深入的探讨。 2 IOCP模型原理 IOCP（I/O Completion Port 输入/输出完成端口）是一种能够合理利用与管理多线程的机制。它是迄今为止Windows平台上最为复杂的一种I/O模型，当应用程序必须一次管理多个套接字时，完成端口模型提供了最好的系统性能，这个模型也提供了最好的伸缩性，非常适合用来处理上百、上千个客户。 IOCP模型提供了一个高效复杂的内核对象，该对象通过指定数量的线程，可

第5章-多线程-补充案例

第五章补充案例案例5-1继承Thread类创建多线程一、案例描述 1、考核知识点编号：00105002 名称：继承Thread类创建多线程 2、练习目标 ?掌握如何通过继承Thread类实现多线程的创建。 ?掌握Thread类中run()方法和start()方法的使用。 3、需求分析在程序开发中，会遇到一个功能需要多个线程同时执行才能完成的情况。这时，可以通过继承线程类Thread，并重写Thread类中的run()方法来实现。为了让初学者熟悉如何创建多线程，在案例中将通过继承Thread类方式创建线程，并实现多线程分别打印0~99的数字的功能。 4、设计思路（实现原理） 1)自定义一个类Demo，使其继承Thread类。 2)在Demo类中重写run()方法，在run()方法内编写一个for循环，循环体内打印：“Demo：” +当前循环次数。 3)编写测试类Example01，在Example01类的main()方法中，创建一个Demo对象，并执行其start()方法，接着编写一个for循环，循环体内打印：“main：”+当前循环次数。

二、案例实现 class Demo extends Thread { public void run() { for (int x = 0; x < 100; x++) { System.out.println("Demo:"+x); } } } public class Example01{ public static void main(String[] args) { Demo d = new Demo(); d.start(); for(int x=0; x<100; x++){ System.out.println("main:"+x); } } } 运行结果如图5-1所示。图5-1运行结果三、案例总结 1、通过继承Thread类，并重写Thread类中的run()方法可以实现多线程。 2、Thread类中，提供的start()方法用于启动新线程，线程启动后，系统会自动调用run()方法。 3、main()方法中有一条主线程在运行。

多线程练习题目

————————————————————————————————作者：————————————————————————————————日期：

多线程? 一、单项 1.下述哪个选项为真?（） A.Eｒror类是一个ＲoｕtiｍeEｘｃｅｐｔiｏn异常Ｂ.任何抛出一个RｏutimeＥxceptioｎ异常的语句必须包含在trｙ块之内 C．任何抛出一个Error对象的语句必须包含在ｔry块之内 D．任何抛出一个Exceｐtiｏｎ异常的语句必须包含在ｔry块之内 2.下列关于Ｊava线程的说法哪些是正确的？( ) Ａ.每一个Java线程可以看成由代码、一个真实的CPＵ以及数据3部分组成Ｂ.创建线程的两种方法,从Thread类中继承的创建方式可以防止出现多父类问题 C.Ｔｈreａd类属于ｊava.uｔil程序包Ｄ.以上说法无一正确 3.哪个关键字可以对对象加互斥锁?( ) A．traｎsient B.ｓyｎchrｏnｉｚed C．seriａliｚe D.static 4.下列哪个方法可用于创建一个可运行的类？(） A．public cｌasｓＸiｍpｌｅmｅｎｔs Ruｎabｌｅ{ pubｌiｃｖoｉd ｒun（) ｛……}} B.public claｓs ＸimpleｍenｔsＴhreａd { puｂlic ｖoid run(){……} } Ｃ. ｐubｌic ｃlass X ｉｍｐlements Thread { ｐublic int run() {……} ｝ D.puｂｌｉcｃlass X implemenｔs Ruｎable { protｅcteｄvoiｄrun（）{……}} 5.下面哪个选项不会直接引起线程停止执行?( ) Ａ.从一个同步语句块中退出来 B．调用一个对象的wａｉt方法 C.调用一个输入流对象的read方法 D.调用一个线程对象的ｓeｔＰrioritｙ方法６.使当前线程进入阻塞状态,直到被唤醒的方法是（) A.resｕme()方法 B.ｗａｉt()方法 C.suspｅｎd()方法D．ｎotify(）方法 7.运行下列程序，会产生的结果是( ) puｂliｃcｌaｓsＸexｔenｄs Ｔhread implemenｔs Runnable ｛ puｂlic ｖｏｉd rｕn(）{ Sｙsｔem.oｕｔ.println(“this is run（)”）； } publｉｃｓtatiｃvoid main(Ｓtring[] args） { Thｒｅad t＝new Ｔｈread（nｅｗX()）；ｔ．sｔart（）;

C++多线程编程入门及范例详解

多线程编程之一——问题提出一、问题的提出编写一个耗时的单线程程序：新建一个基于对话框的应用程序SingleThread，在主对话框IDD_SINGLETHREAD_DIALOG 添加一个按钮，ID为IDC_SLEEP_SIX_SECOND，标题为“延时6秒”，添加按钮的响应函数，代码如下： 1.void CSingleThreadDlg::OnSleepSixSecond() 2.{ 3.Sleep(6000);//延时6秒 4.} 编译并运行应用程序，单击“延时6秒”按钮，你就会发现在这6秒期间程序就象“死机”一样，不在响应其它消息。为了更好地处理这种耗时的操作，我们有必要学习——多线程编程。二、多线程概述进程和线程都是操作系统的概念。进程是应用程序的执行实例，每个进程是由私有的虚拟地址空间、代码、数据和其它各种系统资源组成，进程在运行过程中创建的资源随着进程的终止而被销毁，所使用的系统资源在进程终止时被释放或关闭。线程是进程内部的一个执行单元。系统创建好进程后，实际上就启动执行了该进程的主执行线程，主执行线程以函数地址形式，比如说main或WinMain函数，将程序的启动点提供给Windows 系统。主执行线程终止了，进程也就随之终止。每一个进程至少有一个主执行线程，它无需由用户去主动创建，是由系统自动创建的。用户根据需要在应用程序中创建其它线程，多个线程并发地运行于同一个进程中。一个进程中的所有线程都在该进程的虚拟地址空间中，共同使用这些虚拟地址空间、全局变量和系统资源，所以线程间的通讯非常方便，多线程技术的应用也较为广泛。多线程可以实现并行处理，避免了某项任务长时间占用CPU时间。要说明的一点是，目前大多数的计算机都是单处理器（CPU）的，为了运行所有这些线程，操作系统为每个独立线程安排一些CPU时间，操作系统以轮换方式向线程提供时间片，这就给人一种假象，好象这些线程都在同时运行。由此可见，如果两个非常活跃的线程为了抢夺对CPU的控制权，在线程切换时会消耗很多的CPU资源，反而会降低系统的性能。这一点在多线程编程时应该注意。 Win32SDK函数支持进行多线程的程序设计，并提供了操作系统原理中的各种同步、互斥和临界区等操作。Visual C++6.0中，使用MFC类库也实现了多线程的程序设计，使得多线程编程更加方便。三、Win32API对多线程编程的支持 Win32提供了一系列的API函数来完成线程的创建、挂起、恢复、终结以及通信等工作。下面将选取其中的一些重要函数进行说明。

用多线程同步方法解决生产者-消费者问题(操作系统课设)

. 题目用多线程同步方法解决生产者－消费者问题(Producer-Consumer Problem) 学院计算机科学与技术学院专业软件工程班级姓名指导教师年月日

目录目录 (1) 课程设计任务书 (2) 正文 (2) 1.设计目的与要求 (2) 1.1设计目的 (2) 1.2设计要求 (2) 2.设计思想及系统平台 (2) 2.1设计思想 (2) 2.2系统平台及使用语言 (2) 3.详细算法描述 (3) 4.源程序清单 (5) 5.运行结果与运行情况 (10) 6.调试过程 (15) 7.总结 (15) 本科生课程设计成绩评定表 (16)

课程设计任务书学生姓名：专业班级：指导教师：工作单位：计算机科学与技术学院题目: 用多线程同步方法解决生产者－消费者问题 (Producer-Consumer Problem) 初始条件： 1．操作系统：Linux 2．程序设计语言：C语言 3．有界缓冲区内设有20个存储单元，其初值为0。放入／取出的数据项按增序设定为1－20这20个整型数。要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求） 1．技术要求： 1）为每个生产者／消费者产生一个线程，设计正确的同步算法 2）每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的当前全部内容、当前指针位置和生产者／消费者线程的自定义标识符。 3）生产者和消费者各有两个以上。 4）多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。 2．设计说明书内容要求： 1)设计题目与要求 2)总的设计思想及系统平台、语言、工具等。 3）数据结构与模块说明（功能与流程图） 4）给出用户名、源程序名、目标程序名和源程序及其运行结果。（要注明存储各个程序及其运行结果的主机IP地址和目录。） 5）运行结果与运行情况（提示: （1）有界缓冲区可用数组实现。（2）编译命令可用：cc -lpthread -o 目标文件名源文件名（3）多线程编程方法参见附件。） 3. 调试报告： 1)调试记录 2)自我评析和总结上机时间安排： 18周一~ 五 08：0 － 12：00 指导教师签名：年月日

多线程练习题目

多线程一、单项 1.下述哪个选项为真？( ) A.Error类是一个RoutimeException异常 B.任何抛出一个RoutimeException异常的语句必须包含在try块之内 C．任何抛出一个Error对象的语句必须包含在try块之内 D. 任何抛出一个Exception异常的语句必须包含在try块之内 2.下列关于Java线程的说法哪些是正确的？( ) A.每一个Java线程可以看成由代码、一个真实的CPU以及数据3部分组成 B.创建线程的两种方法，从Thread类中继承的创建方式可以防止出现多父类问题 C.Thread类属于java.util程序包 D.以上说法无一正确 3.哪个关键字可以对对象加互斥锁？( ) A.transient B.synchronized C.serialize D.static 4.下列哪个方法可用于创建一个可运行的类?() A．public class X implements Runable { public void run() {……} } B. public class X implements Thread { public void run() {……} } C. public class X implements Thread { public int run() {……} } D．public class X implements Runable { protected void run() {……} } 5.下面哪个选项不会直接引起线程停止执行？( ) A.从一个同步语句块中退出来 B．调用一个对象的wait方法 C．调用一个输入流对象的read方法 D．调用一个线程对象的setPriority方法 6.使当前线程进入阻塞状态，直到被唤醒的方法是( ) A.resume()方法 B.wait()方法 C.suspend()方法 D.notify()方法 7.运行下列程序，会产生的结果是( ) public class X extends Thread implements Runnable { public void run(){ System.out.println(“this is run()”); } public static void main(String[] args) { Thread t=new Thread(new X()); t.start(); } }

多线程编程实例

编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。函数pthread_create用来创建一个线程，它的原型为：extern int pthread_create __P ((pthread_t *__thread, __const pthread_attr_t *__attr, void *(*__start_routine) (void *), void *__arg)); 第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。当创建线程成功时，函数返回0，若不为0则说明创建线程失败。函数pthread_join用来等待一个线程的结束。函数原型为：extern int pthread_join __P ((pthread_t __th, void **__thread_return)); 第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。这个函数是一个线程阻塞的函数，调用它的函数将一直等待到被等待的线程结束为止，当函数返回时，被等待线程的资源被收回。一个线程的结束有两种途径，一种是象我们上面的例子一样，函数结束了，调用它的线程也就结束了；另一种方式是通过函数pthread_exit来实现。它的函数原型为： extern void pthread_exit __P ((void *__retval)) __attribute__ ((__noreturn__));

最简单的线程程序： /* example.c*/ #include #include void thread(void) { int i; for(i=0;i<3;i++) printf("This is a pthread.\n"); } int main(void) { pthread_t id; int i,ret; ret=pthread_create(&id,NULL,(void *) thread,NULL); if(ret!=0){ printf ("Create pthread error!\n"); exit (1); } for(i=0;i<3;i++) printf("This is the main process.\n"); pthread_join(id,NULL); return (0); } 输出是什么样子？

Java第七单元练习题-Java多线程机制

7Java多线程机制 7.1单项选择题 1. 线程调用了sleep（）方法后，该线程将进入（）状态。 A. 可运行状态 B. 运行状态 C. 阻塞状态 D. 终止状态 2. 关于java线程，下面说法错误的是（） A. 线程是以CPU为主体的行为 B. java利用线程使整个系统成为异步 C. 创建线程的方法有两种：实现Runnable接口和继承Thread类 D. 新线程一旦被创建，它将自动开始运行 3. 在java中的线程模型包含（） A. 一个虚拟处理器 B. CPU执行的代码 C. 代码操作的数据 D. 以上都是 4.在java语言中，临界区可以是一个语句块，或者是一个方法，并用（）关键字标识。 A. synchronized B. include C. import D. Thread 5. 线程控制方法中，yield()的作用是（） A. 返回当前线程的引用 B. 使比其低的优先级线程执行 C. 强行终止线程 D. 只让给同优先级线程运行 6. 线程同步中，对象的锁在（）情况下持有线程返回 A. 当synchronized()语句块执行完后 B. 当在synchronized()语句块执行中出现例外（exception）时 C. 当持有锁的线程调用该对象的wait()方法时 D. 以上都是 7. 在以下（）情况下，线程就进入可运行状态 A. 线程调用了sleep()方法时 B. 线程调用了join()方法时

C. 线程调用了yield()方法时 D. 以上都是 8. java用（）机制实现了进程之间的异步执行 A. 监视器 B. 虚拟机 C. 多个CPU D. 异步调用类的方法中，toString()方法的作用是（） A. 只返回线程的名称 B. 返回当前线程所属的线程组的名称 C. 返回当前线程对象 D. 返回线程的名称语言具有许多优点和特点,下列选项中,哪个反映了Java程序并行机制的特点（） A. 安全性 B. 多线程 C. 跨平台 D. 可移值 11.以下哪个关键字可以用来对对象加互斥锁？（） A. transient B. synchronized C. serialize D. static 12.下面关于进程、线程的说法不正确的是( )。 A．进程是程序的一次动态执行过程。一个进程在其执行过程中，可以产生多个线程——多线程，形成多条执行线索。 B．线程是比进程更小的执行单位，是在一个进程中独立的控制流，即程序内部的控制流。线程本身不能自动运行，栖身于某个进程之中，由进程启动执行。 C．Java多线程的运行与平台无关。 D．对于单处理器系统，多个线程分时间片获取CPU或其他系统资源来运行。对于多处理器系统，线程可以分配到多个处理器中，从而真正的并发执行多任务。 7.2填空题 1.________是java程序的并发机制，它能同步共享数据、处理不同的事件。 2.线程是程序中的一个执行流，一个执行流是由CPU运行程序的代码、__________所形成的，因此，线程被认为是以CPU为主体的行为。 3.线程的终止一般可以通过两种方法实现：自然撤销或者是__________. 4.线程模型在java中是由__________类进行定义和描述的。 5.线程的创建有两种方法：实现_________接口和继承Thread类。 6.多线程程序设计的含义是可以将程序任务分成几个________的子任务。 7.按照线程的模型，一个具体的线程也是由虚拟的CPU、代码与数据组成，其中代码与数据构成了___________,线程的行为由它决定。 8.ava中，新建的线程调用start()方法、如(),将使线程的状态从New(新建状态)转换为 _________。 9.多线程是java程序的________机制，它能同步共享数据，处理不同事件。 10.进程是由代码、数据、内核状态和一组寄存器组成，而线程是表示程序运行状态的

经典多线程的练习题

java中有几种方法可以实现一个线程(jdk5.0之前)？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？答：有两种实现方法，分别是继承Thread类与实现Runnable接口。用synchronized关键字修饰同步方法，反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。 suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。 sl eep() 和wait() 有什么区别? 答：sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。 wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。同步和异步有何异同，在什么情况下分别使用他们？举例说明。答：如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

用多线程同步方法解决生产者-消费者问题(操作系统课设)

题目用多线程同步方法解决生产者－消费者问题(Producer-Consume r Problem) 学院物理学与电子信息工程学院专业电子信息工程班级08电信本一班姓名指导教师 2010 年12 月日

目录目录 0 课程设计任务书 (1) 正文 (3) 1.设计目的与要求 (3) 1.1设计目的 (3) 1.2设计要求 (3) 2.设计思想及系统平台 (3) 2.1设计思想 (3) 2.2系统平台及使用语言 (3) 3.详细算法描述 (4) 4.源程序清单 (7) 5.运行结果与运行情况 (12) 6.调试过程 (16) 7.总结 (16)

课程设计任务书题目: 用多线程同步方法解决生产者－消费者问题 (Producer-Consumer Problem) 初始条件： 1．操作系统：Linux 2．程序设计语言：C语言 3．有界缓冲区内设有20个存储单元，其初值为0。放入／取出的数据项按增序设定为 1－20这20个整型数。要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求） 1．技术要求： 1）为每个生产者／消费者产生一个线程，设计正确的同步算法 2）每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的当前全部内容、当前指针位置和生产者／消费者

线程的自定义标识符。 3）生产者和消费者各有两个以上。 4）多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。 2．设计说明书内容要求： 1)设计题目与要求 2)总的设计思想及系统平台、语言、工具等。 3）数据结构与模块说明（功能与流程图） 4）给出用户名、源程序名、目标程序名和源程序及其运行结果。（要注明存储各个程序及其运行结果的主机IP地址和目录。） 5）运行结果与运行情况（提示: （1）有界缓冲区可用数组实现。（2）编译命令可用：cc -lpthread -o 目标文件名源文件名（3）多线程编程方法参见附件。） 3. 调试报告： 1)调试记录 2)自我评析和总结

易语言多线程详解

前记：无意中发现的一个关于易语言多线程的讲解，分享给大家，有用得着的看看。其中还提供了关于限制多开的办法，仔细阅读发现吧。（BY挂茶馆）一、关于多线程冲突问题。 3.6版开始增加了多线程支持库，提供对多线程的支持，并通过实现进入许可证机制以避免多线程冲突。多线程是这样一种机制，它允许在程序中并发执行多个指令流，每个指令流都称为一个线程，彼此间互相独立。线程又称为轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这使得线程间的通信远较进程简单。多个线程的执行是并发的，也就是在逻辑上“同时”，而不管是否是物理上的“同时”。如果系统只有一个CPU，那么真正的“同时”是不可能的，但是由于CPU的速度非常快，用户感觉不到其中的区别，因此我们也不用关心它，只需要设想各个线程是同时执行即可。多线程和传统的单线程在程序设计上最大的区别在于，由于各个线程的控制流彼此独立，使得各个线程之间的代码是乱序执行的，由此带来的线程调度，同步等问题，将在下面探讨。由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。多线程也有它不利的一面。任何时候某个应用程序使用的线程多于一个时，如果多个线程在同一时刻试图使用相同的数据或资源，可能出现麻烦。这种情况一旦出现，程序将变得非常复杂并且难以调试。更糟的是多线程代码经常在最初开发时运行良好，在形成产品时却往往失败，原因在于有未被发现的多个线程与相同的数据或资源相互作用的情况。这使得多线程编程非常危险。因此，在编程时需要考虑在多个线程访问同一资源时产生冲突的问题：当一个线程正在访问一个进程对象时，另一个线程要改变该对象，这时可能会产生错误的结果。所以，程序员编程时要解决这种冲突。最简单的避免线程冲突的的方法是使线程之间永远不与相同的数据或资源交互。但这不一定可行，对任何多线程程序来说，避免或最小化共享数据或资源应作为一个目标。二、下面介绍一下在Win32 基础上用API函数进行多线程编程的过程。 1、用Win32函数创建和中止线程 Win32函数库中提供了多线程控制的操作函数，包括创建线程、中止线程、建立互斥区等。首先，在应用程序的主线程或者其它活动线程的适当地方创建新的线程。创建线程的函数如下：HANDLE CreateThread(LPSECURITY_A TTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId ); 其中，参数lpThreadAttributes 指定了线程的安全属性，在Windows 95中被忽略；dwStackSize 指定了线程的堆栈深度；lpStartAddress 指定了线程的起始地址，一般情况为下面的原型函数：DWORD WINAPI ThreadFunc( LPVOID );lpParameter指定了线程执行时传送给线程的32位参数，即上面函数的参数；dwCreationFlags指定了线程创建的特性；lpThreadId 指向一个DWORD 变量，可返回线程ID值。如果创建成功则返回线程的句柄，否则返回NULL。创建了新的线程后，则该线程就开始启动执行了。如果在dwCreationFlags中用了CREA TE_SUSPENDED特性，那么线程并不马上执行，而是先挂起，等到调用ResumeThread 后才开始启动线程，在这个过程中可以调用函数： BOOL SetThreadPriority( HANDLE hThread, int nPriority); 来设置线程的优先权。

用多线程同步方法解决生产者-消费者问题

目录 1.需求分析 (1) 1.1 课程设计题目 (1) 1.2 课程设计任务 (1) 1.3 课程设计原理 (1) 1.4 课程设计要求 (1) 1.5 实验环境 (1) 2. 概要设计 (2) 2.1 课程设计方案概述 (2) 2.2 课程设计流程图 (2) 3.详细设计 (3) 3.1 主程序模块 (3) 3.2 生产者程序模块 (4) 3.3 消费者程序模块 (5) 4.调试中遇到的问题及解决方案 (5) 5.运行结果 (6) 6.实验小结 (7) 参考文献 (7) 附录：源程序清单 (7)

1.需求分析 1.1 课程设计题目用多线程同步方法解决生产者－消费者问题 1.2 课程设计任务（1）每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的全部内容、当前指针位置和生产者／消费者线程的标识符。（2）生产者和消费者各有两个以上。（3）多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。 1.3 课程设计原理生产者和消费者问题是从操作系统中的许多实际同步问题中抽象出来的具有代表性的问题，它反映了操作系统中典型的同步例子，生产者进程(进程由多个线程组成)生产信息，消费者进程使用信息，由于生产者和消费者彼此独立，且运行速度不确定，所以很可能出现生产者已产生了信息而消费者却没有来得及接受信息这种情况。为此，需要引入由一个或者若干个存储单元组成的临时存储区（即缓冲区），以便存放生产者所产生的信息，解决平滑进程间由于速度不确定所带来的问题。 1.4 课程设计要求 (1)有界缓冲区内设有20个存储单元，放入／取出的数据项设定为1~20这20个整型数。 (2)每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的全部内容、当前指针位置和生产者／消费者线程的标识符。 (3)生产者和消费者各有两个以上。 (4)多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。 1.5 实验环境系统平台：LINUX 开发语言：C 开发工具：PC机一台

并发危险：解决多线程代码中的 11 个常见的问题

并发危险：解决多线程代码中的11 个常见的问题并发危险解决多线程代码中的11 个常见的问题 Joe Duffy 目录数据争用忘记同步粒度错误读写撕裂无锁定重新排序重新进入死锁锁保护戳记两步舞曲优先级反转实现安全性的模式不变性纯度隔离并发现象无处不在。服务器端程序长久以来都必须负责处理基本并发编程模型，而随着多核处理器的日益普及，客户端程序也将需要执行一些任务。随着并发操作的不断增加，有关确保安全的问题也浮现出来。也就是说，在面对大量逻辑并发操作和不断变化的物理硬件并行性程度时，程序必须继续保持同样级别的稳定性和可靠性。与对应的顺序代码相比，正确设计的并发代码还必须遵循一些额外的规则。对内存的读写以及对共享资源的访问必须使用同步机制进行管制，以防发生冲突。另外，通常有必要对线程进行协调以协同完成某项工作。

这些附加要求所产生的直接结果是，可以从根本上确保线程始终保持一致并且保证其顺利向前推进。同步和协调对时间的依赖性很强，这就导致了它们具有不确定性，难于进行预测和测试。这些属性之所以让人觉得有些困难，只是因为人们的思路还未转变过来。没有可供学习的专门 API，也没有可进行复制和粘贴的代码段。实际上的确有一组基础概念需要您学习和适应。很可能随着时间的推移某些语言和库会隐藏一些概念，但如果您现在就开始执行并发操作，则不会遇到这种情况。本文将介绍需要注意的一些较为常见的挑战，并针对您在软件中如何运用它们给出一些建议。首先我将讨论在并发程序中经常会出错的一类问题。我把它们称为“安全隐患”，因为它们很容易发现并且后果通常比较严重。这些危险会导致您的程序因崩溃或内存问题而中断。当从多个线程并发访问数据时会发生数据争用（或竞争条件）。特别是，在一个或多个线程写入一段数据的同时，如果有一个或多个线程也在读取这段数据，则会发生这种情况。之所以会出现这种问题，是因为Windows 程序（如C++ 和Microsoft .NET Framework

多线程总结

最近想将java基础的一些东西都整理整理，写下来，这是对知识的总结，也是一种乐趣。已经拟好了提纲，大概分为这几个主题： java线程安全，java垃圾收集，java并发包详细介绍，java profile和jvm性能调优。慢慢写吧。本人jameswxx原创文章，转载请注明出处，我费了很多心血，多谢了。关于java线程安全，网上有很多资料，我只想从自己的角度总结对这方面的考虑，有时候写东西是很痛苦的，知道一些东西，想用文字说清楚，却不是那么容易。我认为要认识 java线程安全，必须了解两个主要的点：java的内存模型，java的线程同步机制。特别是内存模型，java的线程同步机制很大程度上都是基于内存模型而设定的。从暂时写得比较仓促，后面会慢慢补充完善。浅谈java内存模型不同的平台，内存模型是不一样的，但是jvm的内存模型规范是统一的。java的多线程并发问题最终都会反映在java的内存模型上，所谓线程安全无非要控制多个线程对某个资源的有序访问或修改。java的内存模型，要解决两个主要的问题：可见性和有序性。我们都知道计算机有高速缓存的存在，处理器并不是每次处理数据都是取内存的。JVM定义了自己的内存模型，屏蔽了底层平台内存管理细节，对于java开发人员，要解决的是在jvm内存模型的基础上，如何解决多线程的可见性和有序性。那么，何谓可见性？多个线程之间是不能互相传递数据通信的，它们之间的沟通只能通过共享变量来进行。Java内存模型（JMM）规定了jvm有主内存，主内存是多个线程共享的。当new一个对象的时候，也是被分配在主内存中，每个线程都有自己的工作内存，工作内存存储了主存的某些对象的副本，当然线程的工作内存大小是有限制的。当线程操作某个对象时，执行顺序如下： (1) 从主存复制变量到当前工作内存 (read and load) (2) 执行代码，改变共享变量值 (use and assign) (3) 用工作内存数据刷新主存相关内容 (store and write) JVM规范定义了线程对主存的操作指令：read，load，use，assign，store，write。当一个共享便变量在多个线程的工作内存中都有副本时，如果一个线程修改了这个共享变量，那么其他线程应该能够看到这个被修改后的值，这就是多线程的可见性问题。那么，什么是有序性呢？线程在引用变量时不能直接从主内存中引用,如果线程工作内存中没有该变量,则会从主内存中拷贝一个副本到工作内存中,这个过程为read-load,完成后线程会引用该副本。当同一线程再度引用该字段时,有可能重新从主存中获取变量副本(read-load-use),也有可能直接引用原来的副本 (use),也就是说 read,load,use顺序可以由JVM实现系统决定。线程不能直接为主存中中字段赋值，它会将值指定给工作内存中的变量副本(assign),完成后这个变量副本会同步到主存储区(store- write)，至于何时同步过去，根据JVM实现系统决定.有该字段,则会从主内存中将该字段赋值到工作内存中,这个过程为read-load,完成后线程会引用该变量副本，当同一线程多次重复对字段赋值时,比如： for(int i=0;i<10;i++) a++; 线程有可能只对工作内存中的副本进行赋值,只到最后一次赋值后才同步到主存储区，所以assign,store,weite顺序可以由JVM实现系统决定。假设有一个共享变量x，线程a执行x=x+1。从上面的描述中可以知道x=x+1并不是一个原子操作，它的执行过程如下：