c task执行线程异步操作
在C#4.0之前需要执行一个复杂的异步操作时，只能使用CLR线程池技术来执行一个任务。线程池执行异步任务时,不知道任务何时完成,以及任务的在任务完成后不能获取到返回值。但是在C#4.0中引人了一个的任务
（System.Threading.Tasks命名空间的类型）机制来解决异步操作完成时间和完成后返回值的问题。
1.使用Task类创建并执行简单任务
通过使用Task的构造函数来创建任务，并调用Start方法来启动任务并执行异步操作。创建任务时，必须传递一个Action或Action<Object>类型的委托回调方法，可以选择的传递任务执行时说需要的数据对象等。Task类的构造函数如下：
public Task(Action action);
public Task(Action<object> action, object state);
public Task(Action action, CancellationToken cancellationToken);
public Task(Action action, TaskCreationOptions creationOptions);
public Task(Action<object> action, object state, CancellationToken cancellationToken);
public Task(Action<object> action, object state, TaskCreationOptions creationOptions);
public Task(Action action, CancellationToken cancellationToken, TaskCreationOptions creationOptions);
public Task(Action<object> action, object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions);
示例代码：
1: static void Main(string[] args)
2: {
3: Console.WriteLine("主线程执行业务处理.");
4: //创建任务
5: Task task = new Task(() => {
6: Console.WriteLine("使用System.Threading.Tasks.Task执行异步操作.");
7: for (int i = 0; i < 10; i++)
8: {
9: Console.WriteLine(i);
10: }
11: });
12: //启动任务,并安排到当前任务队列线程中执行任务(System.Threading.Tasks.TaskScheduler)
13: task.Start();
14: Console.WriteLine("主线程执行其他处理");
15: //主线程挂起1000毫秒，等待任务的完成。
16: Thread.Sleep(1000);
17: }
任务调度结果：
2.等待任务的完成并获取返回值
使用任务执行异步操作时，最主要的是要后的任务完成时的返回值。在任务类中有一个实例方法Wait（有许多重载版本）他能等待任务的完成，我们也可以通过Task类的派生类Task<TResult>创建一个异步任务，并指定任务完成时返回值的类型，这样可以通过Task<TResult>的实例对象获取到任务完成后的返回值。创建一个异步任务并执行0到100求和操作返回最后的计算结果，示例代码：
1: static void TaskWait() {
2: //创建任务
3: Task<int> task = new
Task<int>(() =>
4: {
5: int sum = 0;
6: Console.WriteLine("使用Task执行异步操作.");
7: for (int i = 0; i < 100; i++)
8: {
9: sum+=i;
10: }
11: return sum;
12: });
13: //启动任务,并安排到当前任务队列线程中执行任务(System.Threading.Tasks.TaskScheduler)
14: task.Start();
15:
16: Console.WriteLine("主线程执行其他处理");
17: //等待任务的完成执行过程。
18: task.Wait();
19: //获得任务的执行结果
20: Console.WriteLine("任务执行结果：{0}", task.Result.ToString());
21: }
执行结果：
Task类还有一些静态方法，WaitAll用于等待提供的所有System.Threading.Tasks.Task 对象完成执行过程和Wait用于等待提供的任一个System.Threading.Tasks.Task 对象完成执行过程，这两个方法都有一些重载版本。
//等待所有任务完成
public static void WaitAll(params Task[] tasks);
//等待任意一个任务完成
public static int WaitAny(params Task[] tasks);
3.使用ContinueWith方法在任务完成时启动一个新任务
在使用能够Task类的Wait方法等待一个任务时或派生类的Result属性获得任务执行结果都有可能阻塞线程，为了解决这个问题可以使用ContinueWith方法，他能在一个任务完成时自动启动一个新的任务来处理执行结果。
示例代码：
1: static void TaskContinueWith()
2: {
3: //创建一个任务
4: Task<int> task = new
Task<int>(() =>
5: {
6: int sum = 0;
7: Console.WriteLine("使用Task执行异步操作.");
8: for (int i = 0; i < 100; i++)
9: {
10: sum += i;
11: }
12: return sum;
13: });
14: //启动任务,并安排到当前任务队列线程中执行任务(System.Threading.Tasks.TaskScheduler)
15: task.Start();
16: Console.WriteLine("主线程执行其他处理");
17: //任务完成时执行处理。
18: Task cwt = task.ContinueWith(t => { 19: Console.WriteLine("任务完成后的执行结果：{0}", t.Result.ToString());
20: });
21: Thread.Sleep(1000);
22: }
执行结果：
上述示例中任务不是等待完成来显示执行结果，而是使用ContinueWith方法，它能够知道任务在什么时候完成并启动一个新的任务来执行任务完成后的处理。ContinueWith方法具有一些重载版本，这些重载版本允许指定延续任务需要使用的数据、延续任务的工作方式
（System.Threading.Tasks.TaskContinuationOptions的枚举值按位OR运行的结果）等。
4.创建父子任务和任务工厂的使用
通过Task类创建的任务是顶级任务，可以通过使用TaskCreationOptions.AttachedToParent 标识把这些任务与创建他的任务相关联，所有子任务全部完成以后父任务才会结束操作。示例如下：
1: static void ParentChildTask() {
2: Task<string[]> parent = new
Task<string[]>(state => {
3: Console.WriteLine(state);
4: string[] result=new string[2];
5: //创建并启动子任务
6: new Task(() => { result[0]= "我是子任务1。
"; },TaskCreationOptions.AttachedToParent).Start();
7: new Task(() => { result[1] = "我是子任务2。"; },
TaskCreationOptions.AttachedToParent).Start();
8: return result;
9: },"我是父任务，并在我的处理过程中创建多个子任务，所有子任务完成以后我才会结束执行。"); 10: //任务处理完成后执行的操作
11: parent.ContinueWith(t => {
12: Array.ForEach(t.Result,
r=>Console.WriteLine(r));
13: });
14: //启动父任务
15: parent.Start();
16: Console.Read();
17: }
执行结果：
如果需要创建一组具有相同状态的任务时，可以使用TaskFactory类或TaskFactory<TResult>类。这两个类创建一组任务时可以指定任务的CancellationToken、TaskCreationOptions、TaskContinuationOptions和TaskScheduler默认值。示例代码:
1: static void TaskFactoryApply()
2: {
3: Task parent = new Task(() =>
4: {
5: CancellationTokenSource cts = new CancellationTokenSource(5000);
6: //创建任务工厂
7: TaskFactory tf = new TaskFactory(cts.Token, TaskCreationOptions.AttachedToParent, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
8: //添加一组具有相同状态的子任务9: Task[] task = new Task[]{
10: tf.StartNew(() =>
{ Console.WriteLine("我是任务工厂里的第一个任务。"); }), 11: tf.StartNew(() =>
{ Console.WriteLine("我是任务工厂里的第二个任务。"); }), 12: tf.StartNew(() =>
{ Console.WriteLine("我是任务工厂里的第三个任务。"); }) 13: };
14: });
15: parent.Start();
16: Console.Read();
17: }
执行结果：
5.任务内部实现和任务调度
任务内部有一组构成任务状态的属性，标识任务的唯一Id、表示任务的执行状态（TaskStatus）、任务创建时提供的回调函数的引用和传递给回调函数的数据对象AsyncState、对任务创建时的任务调度对象（TaskScheduler）的引用、对父任务的引用以及对执行上下文的引用和ManualResetEventSlim对象的引用。Task类和
Task<TResult>类都实现了标准的释放资源的接口，允许在任务完成处理的时候使用Dispose方法释放资源（关闭ManualResetEventSlim对象实例）。可以使用Task类的CurrentId属性获得正在执行的任务的Id，如果没有任务在执行CurrentId返回值为null，CurrentId是一个int？可空类型
的属性。任务执行的生命周期通过TaskStatus类型的一个值来表示，TaskStatus所包含的值：
public enum TaskStatus
{
Created = 0,
WaitingForActivation = 1,
WaitingToRun = 2,
Running = 3,
WaitingForChildrenToComplete = 4,
RanToCompletion = 5,
Canceled = 6,
Faulted = 7,
}
我们可以通过Task类的Exception属性获得任务在执行过程中的所有异常，Exception是一个AggregateException 类型的属性。Task类提供了IsCanceled、IsCompleted、IsFaulted 属性来获得任务的完成状态。通过ContinueWith、ContinueWhenAll、ContinueWhenAny和FromAsync创建的后续任务都处于WaitingForActivation 状态，这个状态的任务会在父任务完成后自动执行。
在任务内部由TaskScheduler类调度任务的执行，该类是一个抽象类，FCL中从他派生了两个派生类：
ThreadPoolTaskScheduler线程池任务调度器和SynchronizationContextTaskScheduler同步上下文任务调度器。所有任务默认都是采用ThreadPoolTaskScheduler调度任务，他是采用线程池来执行任务，可以通过TaskScheduler 类的静态属性Default获得对默认任务调度器的引用。SynchronizationContextTaskScheduler任务调度器能够用在Window form、WPF等应用程序，他的任务调度是采用的GUI 线程，所以他能同步更新UI组件，可以通过TaskScheduler 类的静态方法FromCurrentSynchronizationContext获得对一个同步上下文任务调度起的引用。
任务调度示例：
1: private void button1_Click(object sender, EventArgs e)
2: {
3: //获得同步上下文任务调度器
4: TaskScheduler
m_syncContextTaskScheduler =
TaskScheduler.FromCurrentSynchronizationContext();
5:
6: //创建任务，并采用默认任务调度器（线程池任务调度器）执行任务
7: Task<int> task = new
Task<int>(() =>
8: {
9: //执行复杂的计算任务。
10: Thread.Sleep(2000);
11: int sum = 0;
12: for (int i = 0; i < 100; i++)
13: {
14: sum += i;
15: }
16: return sum;
17: });
18: var cts=new CancellationTokenSource();
19: //任务完成时启动一个后续任务，并采用同步上下文任务调度器调度任务更新UI组件。
20: task.ContinueWith(t =>
{https://www.doczj.com/doc/0a19027376.html,bel1.Text="采用SynchronizationContextTaskScheduler 任务调度器更新UI。\r\n计算结果是：
"+task.Result.ToString(); },
21:
cts.Token ,TaskContinuationOptions.AttachedToParent,m_sync
ContextTaskScheduler);
22: task.Start();
23: }
执行结果：
本文简单的介绍了使用Task类来执行异步操作以及任务的内部实现与任务调度。在执行复杂异步操作时，可以采用任务来执行，他能更好的知道异步操作在何时完成以及返回异步操作的执行结果。
频道: .NET 标签:c# Task 异步线程
多线程 一．选择题 1.下列说法中错误地一项是（） A.线程就是程序.线程是一个程序地单个执行流 B.多线程是指一个程序地多个执行流.多线程用于实现并发 2.下列哪个一个操作不能使线程从等待阻塞状态进入对象阻塞状态（） A.等待阴塞状态下地线程被()唤 B.等待阻塞状态下地纯种被()中断 C.等待时间到 D.等待阻塞状态下地线程调用()方法 3.下列哪个方法可以使线程从运行状态进入其他阻塞状态（） A. 4.下列说法中错误地一项是（） A.一个线程是一个类地实例 B.线程从传递给纯种地实例()方法开始执行 C.线程操作地数据来自实例 D.新建地线程调用()方法就能立即进入运行状态 5.下列关于类提供地线程控制方法地说法中，错误地一项是（） A.在线程中执行线程地()方法，则线程等待直到执行完成 B.线程通过调用()方法来中断其阻塞状态 C.若线程调用方法()返回值为，则说明正在执行中 D.()方法返回当前线程地引用 6.下列说法中，错误地一项是（） A.对象锁在()语句执行完之后由持有它地线程返还 B.对象锁在()语句中出现异常时由持有它地线程返还 C.当持有锁地线程调用了该对象地()方法时，线程将释放其持有地锁 D.当持有锁地线程调用了该对象地构造方法时，线程将释放其持有地锁 7.下面地哪一个关键字通常用来对对象地加锁，从而使得对对象地访问是排他地 A. 二．填空题 . 在操作系统中，被称做轻型地进程是线程 . 多线程程序设计地含义是可以将一个程序任务分成几个并行地任务 . 在程序中，()方法地实现有两种方式：实现接口和继承类.多个线程并发执行时，各个线程中语句地执行顺序是确定地，但是线程之间地相对执行顺序是不确定地 中地对象锁是一种独占地排他锁 .程序中可能出现一种情况：多个线种互相等待对方持有地锁，而在得到对方地锁之前都不会释放自己地锁，这就是死锁b5E2R。 .线程地优先级是在类地常数和之间地一个值 .处于新建状态地线程可以使用地控制方法是()和(). .一个进程可以包含多个线程 三．简答题
实用文档用心整理 第二章用户接口 一、选择题（全做） 1.操作系统提供给程序员的接口是（） A进程B系统调用C库函数D系统调用和库函数 2.用户在程序中试图读某文件的第100个逻辑块，使用操作系统的 （）接口 A系统调用B图形用户接口C原语D键盘命令 3.用户要在程序一级获得系统帮助，必须通过（）。 A.进程调度 B.作业调度 C.键盘命令 D .系统调用 4.用户的应用程序和应用系统是通过（）提供的支持和服务来使用系统资源完成其操作的。 A点击鼠标B键盘命令C系统调用D图形用户界面 5.用户可以通过（）两种方式来使用计算机。 A命令方式和函数方式B命令方式和系统调用方式
实用文档用心整理 1^1 C命令方式和文件管理方式D设备管理方式和系统调用方式 6.系统调用的目的是（）。 A.请求系统服务 B.终止系统服务 C.申请系统资源 D.释放系统资源 7.系统调用是由操作系统提供的内部调用，它（）。 A.直接通过键盘交互方式使用 B.只能通过用户程序间接使用 C.是命令接口中的命令使用 D.与系统的命令一样 8.操作系统内核与用户程序、应用程序之间的接口是（）。 A. shell命令 B.图形界面 C.系统调用 D. C语言函数 9.当CPU执行操作系统代码时，称处理机处于（）。 A执行态B目态C管态D就绪态 10.为了便于用户直接或间接地控制自己的作业，操作系统向用户提 供了命令接口，该接口又可进一步分为（）。 2
A联机用户接口和脱机用户接口B程序接口和图形接口 C联机用户接口和程序接口D脱机用户接口和图形接口 二、填空题 1.用户在一次解题或一个事务处理过程中要求计算机系统所做工作 的集合称为________ 。 2.所谓系统调用，就是用户在程序中调用 _____ 所提供的一些子功能。 三、简答题 1.脱机命令接口和联机命令接口有什么不同？ 2.处理机为什么要区分核心态和用户态两种操作方式？什么情况下进行两种方式的转换？ 3.简述系统调用与函数调用有什么相同和不同点。 4.区别概念：操作命令与系统调用 5.简述系统调用的实现过程 6.命令接口和图形用户接口分别有什么优缺点？
第二章操作系统 一、单选题 1.在windows中，下列叙述中错误的是（A） A.不支持即插即用 B.可支持鼠标操作 C.桌面上可同时容纳多个窗口 D.可同时运行多个程序 2.在资源管理器中窗口，若希望显示文件的名称、类型、大小等信息，应选择“查看” 菜单中的（C） A.小图标 B.大图标 C.详细资料 D.列表 3．已选定文件夹后，下列操作中能删除该文件夹的是（C） A.在“编辑”菜单中选择“撤销”命令 B.用鼠标左键单击该文件夹 C.在“文件”菜单中选择“删除”命令 D.用鼠标左键双击该文件夹 4.在windows环境中，对磁盘文件进行有效管理的工具是（A）。 A、“资源管理器”或“我的电脑” B、“文件管理器” C、“我的公文包” D、“写字板” 5.在windows开始菜单下的“文档”菜单中存放的是（A） A、最近打开过的文档 B、最近建立的文件夹 C、最近运行过的程序 D、最近建立的文档 6．以下关于windows中快捷方式的说法正确的是（C） A、快捷方式创建好了以后就不能修改 B、快捷方式占用的内存空间非常大 C、快捷方式提供了一种快速访问文件和程序的方法 D、快捷方式不可以由用户自己创建 7.windows桌面的外观设置是在“控制面板”中的（A）属性中设置 A、显示 B、区域设置 C、系统 D、多媒体 8.鼠标是windows环境中的一种重要的（B） A、画图工具 B、输入工具 C、指示工具
D、输出工具 9.下列描述中，正确的是（A） A、激光打印机是非击打式打印机 B、鼠标器是一种即可作输入又可作输出的设备 C、windows是一种应用软件 D、PowerPoint是一种系统软件 10在Windows中“任务栏”的主要作用是（D）。 A、显示系统的所有功能 B、只显示正在后台工作的窗口名 C、只显示当前活动窗口名 D、实现窗口间切换 11.Windows的“桌面”指的是（D）。 A、活动窗口 B、某个窗口 C、全部窗口 D、Windows启动后的整个屏幕 12.在屏幕上可以同时显示多个窗口，可以根据窗口的（A）栏的颜色来判断它是否是当前活动窗口 A、标题 B、菜单 C、状态 D、符号 13.下面关于中文Windows文件名的叙述中错误的是（C）。 A、文件名允许使用多个圆点分隔符 B、文件名允许使用空格 C、文件名允许使用竖线（“｜”） D、文件名允许使用汉字 14、在Windows中，带子菜单的菜单选项标记是（C）。 A、选项前带“√” B、选项前带“？” C、选项后带三角符 D、选项后带“…” 15、下列关于Windows剪贴板的叙述中，（B）是错误的。 A、按下Alt+PrintScreen键或Printscreen键都会往剪贴板中送信息 B、剪贴板中可以保存多次“复制”操作的内容 C、剪贴板中的信息可以保存到磁盘文件中长期保存 D、凡是有“剪切”和“复制”命令的地方，都可以把选取的信息送到剪贴板中去 16、下列不能出现在Windows资源管理器窗口左部的选项是（C）。 A、（C:） B、桌面 C、资源管理器 D、我的电脑 17.以下关于Windows中快捷方式的说法正确的是：(A) A、快捷方式提供了一种快速访问文件和程序的方法 B、快捷方式不可以由用户自己创建 C、快捷方式占用的内存空间非常大 D、快捷方式创建好了以后就不能修改 18.Windows的“我的电脑”窗口中，若已选定了文件或文件夹，为了设置其属性打开属性对话框，其操作是（C） A、用鼠标右键单击“查看”菜单中“工具栏”下的“属性”图标
第五章补充案例 案例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 进程 B 系统调用 C 库函数 D 系统调用和库函数 2. 用户在程序中试图读某文件的第100个逻辑块，使用操作系统的（）接口 A 系统调用 B 图形用户接口 C 原语 D 键盘命令 3.用户要在程序一级获得系统帮助，必须通过（）。 A.进程调度 B.作业调度 C.键盘命令 D .系统调用 4.用户的应用程序和应用系统是通过( )提供的支持和服务来使用系统资源完成其操作的。 A 点击鼠标 B 键盘命令 C 系统调用 D 图形用户界面 5. 用户可以通过（）两种方式来使用计算机。 A 命令方式和函数方式 B 命令方式和系统调用方式 C 命令方式和文件管理方式 D 设备管理方式和系统调用方式 6.系统调用的目的是（）。 A. 请求系统服务 B. 终止系统服务 C. 申请系统资源 D. 释放系统资源 7. 系统调用是由操作系统提供的内部调用，它（）。 A. 直接通过键盘交互方式使用 B. 只能通过用户程序间接使用 C. 是命令接口中的命令使用 D. 与系统的命令一样
8.操作系统内核与用户程序、应用程序之间的接口是（）。 A. shell 命令 B. 图形界面 C. 系统调用 D. C 语言函数 9.当CPU执行操作系统代码时，称处理机处于（）。 A 执行态 B 目态 C 管态 D 就绪态 10.为了便于用户直接或间接地控制自己的作业，操作系统向用户提供了命令接口，该接口又可进一步分为（）。 A 联机用户接口和脱机用户接口 B 程序接口和图形接口 C 联机用户接口和程序接口 D 脱机用户接口和图形接口 二、填空题 1. 用户在一次解题或一个事务处理过程中要求计算机系统所做工作的集合称为。 2.所谓系统调用，就是用户在程序中调用所提供的一些子功能。 三、简答题 1. 脱机命令接口和联机命令接口有什么不同？ 2.处理机为什么要区分核心态和用户态两种操作方式？什么情况下进行两种方式的转换？ 3.简述系统调用与函数调用有什么相同和不同点。 4. 区别概念：操作命令与系统调用 5. 简述系统调用的实现过程 6. 命令接口和图形用户接口分别有什么优缺点？ 7. 何谓脱机I/O和联机I/O?
第二章Windows 7操作系统习题 一、是非题 1.操作系统是计算机最基本的系统软件。 A. 对 B. 错 2.在单用户操作系统中,系统所有的硬件软件资源只能为一个用户提供服务. A. 对 B. 错 是一个多任务操作系统。 A. 对 B. 错 4.默认情况下, Windows7 的桌面上只显示”回收站”一个图标. A. 对 B. 错 5.在Windows 7 中,用户要在打开的多个窗口中切换,可使用“Alt+Enter”组合键。 A. 对 B. 错 6.“资源管理器”是Windows系统提供的硬件管理工具。 A. 对 B. 错 7.在Windows 7 中，将删除的文件暂时保存在“回收站”中，使逻辑删除而不是物理删除。 A. 对 B. 错 8.在Windows 7 中，文件或文件夹的设置为“只读”属性，则用户只能查看文件或文件夹的内容，而不能对其进行任何修改操作。 A. 对 B. 错 9.在Windows 7 中，“磁盘清理”程序是从计算机中删除文件和文件夹，以提高系统性能。 A. 对 B. 错 10. 在Windows 7 中，快捷方式是指向计算机上某个文件、文件夹或程序的链接。 A. 对 B. 错 11. 在Windows 7 中，将快捷方式从桌面删除，就删除了该快捷方式链接的文件和程序。 A. 对 B. 错 12. Windows 7 在外观上的最显著改进就是任务栏。
A. 对 B. 错 13. 在Windows 7 中，通常可以通过不同的图标来区分文件类型。 A. 对 B. 错 14. 在Windows 7 中，文件名可以根据需要进行更改，文件的扩展名也能根据需要更改。 A. 对 B. 错 15．写字板时Windows 7附带的一款创建和编辑文本的工具。其不仅可以用来编辑文本，而且可以插入图形、图片，以及连接和嵌入对象等。 A. 对 B. 错 二、单选题 7 系统正确的关机的过程是 A. 在运行Windows 7 时直接关机 B. 选择“开始”菜单的“关机”命令关闭所有运行程序 C. 先退到DOS系统，再关闭电源 D. 关闭所有任务栏的窗口后，再关闭电源 2.安装Windows 7 时，硬盘应该格式化的类型是 A. FAT B. FAT32 C. NTFS D. 无论什么都可以 7 不是的操作系统。 A. 分布式 B.“即插即用”功能 C. 图形界面 D. 多任务 4.在Windows 桌面上已经有某个应用程序的图标，要运行该程序，只需 A.单击该图标 B.双击该图标 C. 右击该图标 D. 右键双击该图标 5.在Windows 7 中，“桌面”指的是。 A. 活动窗口 B. 某个窗口 C. 全部窗口 D. 整个屏幕 6.当一个在前台运行的应用程序窗口被最小化后，该应用程序将 A．被终止运行 B. 继续在前台运行 C. 被暂停运行 D. 被转入后台运行 7.在Windows 7桌面上，打开资源管理器的操作方法是。 A.右击任务栏，然后从弹出的快捷菜单选择“资源管理器”命令
由于这三个线程也是彼此独立，各自拥有自己的资源，即100张电影票，因此程序输出的结果和（1）结果大同小异。均是各自线程对自己的100张票进行单独的处理，互不影响。 可见，只要现实的情况要求保证新建线程彼此相互独立，各自拥有资源，且互不干扰，采用哪个方式来创建多线程都是可以的。因为这两种方式创建的多线程程序能够实现相同的功能。 由于这三个线程也是彼此独立，各自拥有自己的资源，即100张电影票，因此程序输出的结果和例4.2.1的结果大同小异。均是各自线程对自己的100张票进行单独的处理，互不影响。 可见，只要现实的情况要求保证新建线程彼此相互独立，各自拥有资源，且互不干扰，采用哪个方式来创建多线程都是可以的。因为这两种方式创建的多线程程序能够实现相同的功能。
结果正如前面分析的那样，程序在内存中仅创建了一个资源，而新建的三个线程都是基于访问这同一资源的，并且由于每个线程上所运行的是相同的代码，因此它们执行的功能也是相同的。
可见，如果现实问题中要求必须创建多个线程来执行同一任务，而且这多个线程之间还将共享同一个资源，那么就可以使用实现Runnable接口的方式来创建多线程程序。而这一功能通过扩展Thread类是无法实现的，读者想想看，为什么？ 实现Runnable接口相对于扩展Thread类来说，具有无可比拟的优势。这种方式不仅有利于程序的健壮性，使代码能够被多个线程共享，而且代码和数据资源相对独立，从而特别适合多个具有相同代码的线程去处理同一资源的情况。这样一来，线程、代码和数据资源三者有效分离，很好地体现了面向对象程序设计的思想。因此，几乎所有的多线程程序都是通过实现Runnable接口的方式来完成的。
0、Java中多线程同步是什么？ 在多线程程序下，同步能控制对共享资源的访问。如果没有同步，当一个Java线程在修改一个共享变量时，另外一个线程正在使用或者更新同一个变量，这样容易导致程序出现错误的结果。 1、解释实现多线程的几种方法? Java线程可以实现Runnable接口或者继承Thread类来实现，当你打算多重继承时，优先选择实现Runnable。还可以使用线程池。 2、Thread.start()与Thread.run()有什么区别？ Thread.start()方法(native)启动线程，使之进入就绪状态，当cpu分配时间该线程时，由JVM调度执行run()方法。 3、为什么需要run()和start()方法，我们可以只用run()方法来完成任务吗？ 我们需要run()&start()这两个方法是因为JVM创建一个单独的线程不同于普通方法的调用，所以这项工作由线程的start方法来完成，start由本地方法实现，需要显示地被调用，使用这俩个方法的另外一个好处是任何一个对象都可以作为线程运行，只要实现了Runn able接口，这就避免因继承了Thread类而造成的Java的多继承问题。 4、什么是ThreadLocal类，怎么使用它？ ThreadLocal是一个线程级别的局部变量，并非“本地线程”。ThreadLocal为每个使用该变量的线程提供了一个独立的变量副本，每个线程修改副本时不影响其它线程对象的副本(译者注)。 5、Sleep()、suspend()和wait()之间有什么区别？ Thread.sleep()使当前线程在指定的时间处于“非运行”（Not Runnable）状态。线程一直持有对象的监视器。比如一个线程当前在一个同步块或同步方法中，其它线程不能进入该块或方法中。如果另一线程调用了interrupt()方法，它将唤醒那个“睡眠的”线程。 注意：sleep()是一个静态方法。这意味着只对当前线程有效，一个常见的错误是调用t.sl eep()，（这里的t是一个不同于当前线程的线程）。即便是执行t.sleep()，也是当前线程进入睡眠，而不是t线程。t.suspend()是过时的方法，使用suspend()导致线程进入停滞状态，该线程会一直持有对象的监视器，suspend()容易引起死锁问题。 object.wait()使当前线程出于“不可运行”状态，和sleep()不同的是wait是object的方法而不是thread。调用object.wait()时，线程先要获取这个对象的对象锁，当前线程必须在锁对象保持同步，把当前线程添加到等待队列中，随后另一线程可以同步同一个对象锁来调用object.notify()，这样将唤醒原来等待中的线程，然后释放该锁。基本上wait() /notify()与sleep() /interrupt()类似，只是前者需要获取对象锁。 6、在静态方法上使用同步时会发生什么事？ 同步静态方法时会获取该类的“Class”对象，所以当一个线程进入同步的静态方法中时，线程监视器获取类本身的对象锁，其它线程不能进入这个类的任何静态同步方法。它不像实例方法，因为多个线程可以同时访问不同实例同步实例方法。 7、当一个同步方法已经执行，线程能够调用对象上的非同步实例方法吗？
第二章用户界面 2.1 知识点汇总 1、作业及作业步 图2-1 作业及作业步 2、系统调用：用户程序中对操作系统的调用称为系统调用。使用户程序通过简单的调用，来实现一些硬件相关，应用无关的工作，从而简化了用户程序。 独立程序：不需要操作系统帮助的程序（包括程序的启动和结束） 非独立程序：需要操作系统帮助的程序 图2-2 系统调用的执行过程 系统调用的特点： （1）系统调用指令是由硬件决定的（即：CPU中的中断向量表）。 ＣＰＵ的指令集中都有一条系统调用指令，又称访管指令 但系统调用具体实现的功能由操作系统决定（即：操作系统中的，系统调用分支表，及系统调用代码）。 因此：同一种计算机上的不同操作系统，系统调用指令是相同的。同一操作系统，在不
同的计算机上，系统调用指令是不同的。 （2）系统调用是动态连接的 静态连接：程序在编译时，将被调用的程序嵌入到自身中。如：库函数调用 动态连接：程序在执行的过程中，执行到调用指令时，才连接到被调用的程序并执行。如：动态连接库（dynamic link library,DLL），系统调用。 由于操作系统是动态连接的，所以，缩短了用户程序，使用户程序和操作系统提供的系统调用功能相互独立。 （3）系统调用的调用地址和返回地址不是固定的。 系统调用的地址，由系统启动装载操作系统时，存放系统调用代码的位置决定，每次开机都可能存放在不同的位置上。 返回地址，由用户程序中系统调用指令的位置决定。 （４）安全接口 在执行系统调用和从系统调用中返回时，要分别保存和恢复程序状态字PSW，并设置PSW中的系统态／用户态标志位，进行系统态和用户态的切换。 执行系统调用时，进入系统态。从系统调用中返回用户程序时，进入用户态。 状态切换的目的：某些特权指令只能在系统态下执行。一些地址，只能在系统态下访问。从而限制了用户程序不能随意地进入操作系统区域，读写操作系统的内部代码，也限制了用户程序不能随意进入其它用户程序的区域。 中断：是指计算机在执行程序的过程中，当遇到需要立即处理的事件时，立即暂停当前正在运行的程序，转去执行有关服务程序，处理完后自动返回原程序。 发生中断的原因：系统调用，程序异常，IO事件完成，时间片结束，等等。可以归结为两大方面，一任务间切换的时候发生中断，二由用户态进入系统态时发生中断。 中断的执行过程：保存现场，将PSW等现场信息放入堆栈中，然后转去相应的中断处理程序。中断结束返回时，恢复现场，从堆栈中取出PSW等现场信息。继续执行原程序。2.2 例题解析 【例2.2.1】操作系统向用户提供了哪几类接口？ 答：操作系统向用户提供了两类接口：一类是命令接口，另一类是程序接口。用户利用命令接口提供的操作命令来组织和控制作业的执行，按命令接口对作业控制方式不同，又可以将命令接口分为联机命令接口和脱机命令接口；用户还可以利用程序接口提供的一组系统调用来请求并获得操作系统服务，程序接口在用户编制程序的时候使用。今年来，为了方便用户的使用，又出现了图形接口。 【例2.2.2】试说明作业和进程的状态，并说明引起状态转换的典型原因。 答：作业的状态有提交状态、后备状态、运行状态和完成状态。 当一个作业还未进入算机系统内之前，用户正在向系统提交作业时所处的状态叫做提交状态。送入计算机并由操作系统将其存放在磁盘上以后，系统为这个作业建立一个作业控制
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）后本线程才进入对象锁定池准备获得对象锁进入运行状态。 同步和异步有何异同，在什么情况下分别使用他们？举例说明。 答：如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。 当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。
第二章 Windows 7操作系统 一、选择题 1.Windows7系统中的“桌面”是指（）。 A.整个频幕 B.某个窗口 C.当前窗口 D.全部窗口 2.下列属于计算机操作系统的是（）。 A.Windows 7 B.Linux C.UNIX D.以上全部 3.在Windows 7中，打开一个菜单后，其中某菜单项会出现与之对应的级联菜单的标识是（）。 A.菜单项右侧有一组英文提示 B.菜单项右侧有一个黑色三角形 C.菜单项左侧有一个黑色圆点 D.菜单项左侧有一个“√”符号 4.在Windows 7中，能弹出对话框的操作是（）。 A.选择了带三角形箭头的菜单项 B.运行了与对话框对应的应用程序 C.选择了颜色变灰的菜单项 D.选择了带省略号的菜单项 5.把Windows 7的窗口和对话框作一比较，窗口可以移动和改变大小，而对话框（）。 A.既不能移动，也不能改变大小 B.仅可以移动，不能改变大小 C.仅可以改变大小，不能移动 D.既能移动，也能改变大小 6.Windows 7操作系统中，显示3D桌面效果的快捷键是（）。 A.Alt+Tab B.Win+shift C.Ctrl+Tab D.Win+Tab 7.在Windows 7操作系统中，进行窗口切换的快捷键是（）。 A.Alt+W B.Alt+Tab C.Alt+F D.Alt+N 8.剪贴板的作用是（）。 A.临时存放剪切或复制的信息 B.作为资源管理器管理的工作区 C.长期保存信息的存储区 D.在使用Dos 时，划给的临时区域 9.在Windows 7中，剪贴板是程序和文件间用来传递信息的临时存储区，此存储区是（）。 A.回收站的一部分 B.硬盘的一部分 C.软盘的一部分 D.内存的一部分 10.Windows 7中，若要选定当前文件夹中的全部文件和文件夹对象，可使用的组合键是（）。 A．Ctrl+V B．Ctrl+A C．Ctrl+X D．Ctrl+D 11.在Windows中连续进行了多次剪切操作后，“剪贴板”中存放的是（）。 A.空白 B.最后一次剪切的内容 C.第一次剪切的内容 D.所有剪切过的内容 12.用鼠标直接运行带有图标的Windows程序，所要用的操作是（）。 A.双击 B.单击 C.拖动 D.选中 13.更改Windows 7主题主要包括（）。 A.更改桌面背景 B.更改窗口颜色 C.更改声音和屏幕保护程序 D.以上都对 14.如果某个程序窗口被最小化，则程序将（）。 A.终止运行 B.暂停运行 C.转入后台运行 D.继续前台运行 15.在“资源管理器”窗口中，如果想一次选定多个连续的文件，正确的操作是（）。 A.单击第一个文件，按住Shift键，单击最后一个文件 B.单击第一个文件，按住Ctrl键，单击最后一个文件 C.按住Ctrl键，按住鼠标右键逐个选取 D.按住Shift键，按住鼠标左键逐个选取 16.在Windows 7的“资源管理器”中，已选定文件夹后，下列操作中不能删除该文件夹的操作是（）。 A.在键盘上按Delete键 B.用鼠标左键双击该文件夹 C.在“文件”菜单中选择“删除”命令 D.右击该文件夹，在弹出的快捷菜单中选择“删除”命令 17.在Windows7“资源管理器”中，进行文件复制可以先右击文件图标，在弹出的快捷菜单中选择“复制”命令，再右击目标文件夹或磁盘，在弹出的快捷菜单中选择（）命令。 A.粘贴 B.移动 C .拷贝 D.全选 18.下面“不合法”的文件名是（）。 A.12345678？.TXT B.WIN_PROG.EXE C.FILE.DAT D.35768.TXT 19.关于Windows7中窗口的说法，以下（）是正确的。 A.屏幕上只能出现一个窗口，这就是活动窗口 B.屏幕上可以出现多个窗口，但只有一个是活动窗口 C.屏幕上可以可以出现多个窗口，但不止一个是活动窗口 D.屏幕上出现的全部是活动窗口 20.在Windows7“资源管理器”的工作区中，已选定了若干个文件，若想取消其中几个选定文件，需要执行的操作是（）。 A.按住Ctrl键，然后依次单击要取消的文件 B.按住Shift键，然后依次单击要取消的文件 C.按住Ctrl键，然后用鼠标右键依次单击要取消的文件 D.按住Shift键，然后用鼠标右键依次单击要取消的文件 21.Windows 7操作系统是（）。 A.单用户单任务系统 B.单用户多任务系统 C.多用户单任务系统 D.多用户多任务系统 22.当窗口不能将所有的信息行显示在一屏内时，窗口中一定会出现（）。 A.滚动条 B.状态栏 C.提示信息窗口 D.警告信息窗口 23.打开快捷菜单的操作为（）。 A.单击 B.右击 C.双击 D.三击 24.在Windows7操作系统中，能安全关闭计算机的操作是（）。 A.在文件未保存的情况下，单击“开始”按钮→“关闭”计算机 B.在保存文件并关闭所有运行的程序后，单击“开始”按钮→“关闭”计算机 C.直接按主机面板上的电源按钮 D.直接拔掉电源关闭计算机 25.将鼠标指针移至（）上拖曳，既可移动窗口位置。 A.标题栏 B.格式栏 C.状态栏 D.菜单栏 26.以下输入法中属于键盘输入法的有（）。 A.光电输入法 B.手写输入法 C.语音识别输入法 D.搜狗拼音输入法 27.在Windows 7操作系统中，切换输入法的快捷键默认是（）。 A.Alt+Enter B.Ctrl+Alt C.Ctrl+Shift D.Alt+Shift 28.下列（）文件是压缩文件。 A.财务.doc B.财务.exe C.财务.zip D.财务.txt 29.在Windows7的“资源管理器”中，关于文件扩展名的显示，以下正确的是（）。 A.所有文件的扩展名始终显示，与设置无关 B.所有文件的扩展名始终不显示，是隐藏的，与设置无关 C.不可以更改扩展名是否显示的设置
线程编程方面java笔试题 60、java中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？ 答：有两种实现方法，分别是继承Thread类与实现Runnable接口 用synchronized关键字修饰同步方法 反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。 61、sleep() 和 wait() 有什么区别? 答：sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。 wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。 62、同步和异步有何异同，在什么情况下分别使用他们？举例说明。 答：如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。 当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。 63、启动一个线程是用run()还是start()? 答：启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。 64、当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法? 答：不能，一个对象的一个synchronized方法只能由一个线程访问。 65、请说出你所知道的线程同步的方法。 答：wait():使一个线程处于等待状态，并且释放所持有的对象的lock。 sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉Interrupt edException异常。 notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。 Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。 66、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么? 答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口 同步的实现方面有两种，分别是synchronized,wait与notify
云南外事外语职业学院教师教案（4课时） 1、计算机操作系统简介 1.1、了解操作系统基本概念 概念：操作系统（Operating System，简称OS）操作系统是管理和控制计算机系统中的所有资源，合理地组织计算机工作的流程，并为用户提供一个良好的工作环境和接口的系统软件。 裸机：没有安装任何软件的计算机； 操作系统是软件的集合； 1.2、操作系统的发展过程 操作系统的形成过程大致经历了手工操作、管理程序和操作系统3个阶段。 1.3、操作系统的分类 按与用户对话的界面进行分类： 1）命令行界面操作系统。例如MSDOS、Novell Netware。
2）图形用户界面操作系统。例如Windows。 按能够支持的用户和运行的任务进行分类： 1）单用户单任务操作系统—CP/M和MS-DOS 2）单用户多任务操作系统—WINDOWS 3）多用户多任务操作系统—Unix/Linux Windows Server 按使用环境和对作业处理的方式进行分类： 1）批处理操作系统 2）分时操作系统 3）实时操作系统 4）网络操作系统 5）分布式操作系统 1.4、操作系统的功能 1）CPU的控制与管理 2）内存的分配与管理 3）外部设备的控制与管理 4）文件的管理 5）作业管理和控制 1.5、常用操作系统介绍 1）DOS 操作系统 2）Windows 操作系统及发展 Windows 1.0 2.0、Windows95、Windows ME、Windows NT、Windows 2000、Windows XP、Windows server 2003、Windows Vista、Windows 7、Windows 8、Windows 10 3）UNIX 操作系统 4）Windows NT 操作系统 5）Linux 操作系统 6）MACOS 操作系统 2、Windows 7操作系统 2.1、Windows 7 新特征 1）更加简单 2）更加易用 3）更加快速 4）更加安全 5）更好的连接
java创建多线程的两种方法(继承Thread类/实现Runnable接 口) Thread 创建线程步骤: [java]view plaincopy 1.通常创建一个线程的步骤如下。 2.（1）创建一个新的线程类，继承 Thread 类并覆盖 Thread 类的 run()方法。 3.class ThreadType extends Thread{ 4.public void run(){ 5.…… 6. } 7. } 8.（2）创建一个线程类的对象，创建方法与一般对象的创建相同，使用关键字new完成。 9. ThreadType tt = new ThreadType(); 10.（3）启动新线程对象，调用 start()方法。 11. tt.start(); 12.（4）线程自己调用 run()方法。 13.void run(); 14.下面演示一个创建多个线程的例子。 15.class ThreadDemo2 extends Thread{ 16.//声明无参数，空构造方法 17. ThreadDemo2(){} 18.//声明带有字符串参数的构造方法 19. ThreadDemo2(String szName) 20. { 21.super(szName);//调用父类的构造方法 22. } 23.//重载 run 函数 24.public void run() 25. { 26.for (int count = 1,row = 1; row < 10; row++,count++) //循环计算输 出的*数目 27. { 28.for (int i = 0; i < count; i++)//循环输出指定的 count 数 目的* 29. { 30. System.out.print('*');//输出* 31. } 32. System.out.println();//输出* 33. }
实现多线程有两种方法：Thread类继承和Runnable接口实现一、创建线程的第一种方式：继承Thread类。 步骤： 1，定义类继承Thread。 2，复写Thread类中的run方法。 目的：将自定义代码存储在run方法。让线程运行。//run();仅仅是对象调用方法。而线程创建了，并没有运行。 3，调用线程的start方法， 该方法两个作用：启动线程，调用run方法。 Demo d = new Demo();//创建好一个线程。 //d.start();//开启线程并执行该线程的run方法。 d.run();//仅仅是对象调用方法。而线程创建了，并没有运行。 二、创建线程的第二种方式：实现Runable接口 步骤： 1，定义类实现Runnable接口 2，覆盖Runnable接口中的run方法。 将线程要运行的代码存放在该run方法中。
3，通过Thread类建立线程对象。 4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。 为什么要将Runnable接口的子类对象传递给Thread的构造函数。 因为，自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程去指定对象的run方法。就必须明确该run方法所属对象。 5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。 l 实现方式和继承方式有什么区别呢？ 实现方式好处：避免了单继承的局限性。 在定义线程时，建立使用实现方式。 两种方式区别： 继承Thread: 线程代码存放Thread子类run方法中。 实现Runnable，线程代码存在接口的子类的run方法。
java面试题之多线程 线程或者说多线程，是我们处理多任务的强大工具。线程和进程是不同的，每个进程都是一个独立运行的程序，拥有自己的变量，且不同进程间的变量不能共享；而线程是运行在进程内部的，每个正在运行的进程至少有一个线程，而且不同的线程之间可以在进程范围内共享数据。也就是说进程有自己独立的存储空间，而线程是和它所属的进程内的其他线程共享一个存储空间。线程的使用可以使我们能够并行地处理一些事情。线程通过并行的处理给用户带来更好的使用体验，比如你使用的邮件系统（outlook、Thunderbird、foxmail等），你当然不希望它们在收取新邮件的时候，导致你连已经收下来的邮件都无法阅读，而只能等待收取邮件操作执行完毕。这正是线程的意义所在。 实现线程的方式 实现线程的方式有两种： 1. 继承https://www.doczj.com/doc/0a19027376.html,ng.Thread，并重写它的run()方法，将线程的 执行主体放入其中。 2. 实现https://www.doczj.com/doc/0a19027376.html,ng.Runnable接口，实现它的run()方法，并将 线程的执行主体放入其中。 这是继承Thread类实现线程的示例： public class ThreadTest extends Thread { public void run() { // 在这里编写线程执行的主体 // do something } } 这是实现Runnable接口实现多线程的示例： public class RunnableTest implements Runnable {
public void run() { // 在这里编写线程执行的主体 // do something } } 这两种实现方式的区别并不大。继承Thread类的方式实现起来较为简单，但是继承它的类就不能再继承别的类了，因此也就不能继承别的类的有用的方法了。而使用是想Runnable接口的方式就不存在这个问题了，而且这种实现方式将线程主体和线程对象本身分离开来，逻辑上也较为清晰，所以推荐大家更多地采用这种方式。 如何启动线程 我们通过以上两种方式实现了一个线程之后，线程的实例并没有被创建，因此它们也并没有被运行。我们要启动一个线程，必须调用方法来启动它，这个方法就是Thread类的start()方法，而不是run()方法（既不是我们继承Thread类重写的run()方法，也不是实现Runnable接口的run()方法）。run()方法中包含的是线程的主体，也就是这个线程被启动后将要运行的代码，它跟线程的启动没有任何关系。上面两种实现线程的方式在启动时会有所不同。 继承Thread类的启动方式： public class ThreadStartTest { public static void main(String[] args) { // 创建一个线程实例 ThreadTest tt = new ThreadTest(); // 启动线程 tt.start(); } } 实现Runnable接口的启动方式：