41 什么是线程如何创建线程.docx

资源描述

41 什么是线程如何创建线程.docx

《41 什么是线程如何创建线程.docx》由会员分享，可在线阅读，更多相关《41 什么是线程如何创建线程.docx（14页珍藏版）》请在冰豆网上搜索。

41 什么是线程如何创建线程.docx

41什么是线程如何创建线程

4.1什么是线程，如何创建线程

2007-04-0710:

33 徐彬清华大学出版社我要评论（0）

∙摘要：

《XJava程序设计专家门诊》第四章的第1节“什么是线程，如何创建线程”。

这一节学习Java创建线程的具体步骤和对应的源代码。

同时，附有专家说明和专家指点，供大家参考！

∙标签：

Java 线程创建 Java 专家 XJava程序设计专家门诊

∙

限时报名参加“甲骨文全球大会·2010·北京”及“JavaOne和甲骨文开发者大会2010”

如果你学习过操作系统，那么一定对进程的概念非常熟悉，其实，几乎每种操作系统都支持进程——进程就是在某种程度上相互隔离的、独立运行的程序。

进程的引入大大提高了任务并发执行的效率，但是，进程也因为耗费资源太大等缺陷限制了它在并行处理方面的发展。

不过线程的引入改变了这一状况，线程也称做轻量级进程。

就像进程一样，线程在程序中是独立的、并发的执行路径，每个线程有它自己的堆栈、自己的程序计数器和自己的局部变量。

但是，与独立的进程相比，进程中的线程之间的独立程度要小。

它们共享内存、文件句柄和其他每个进程应有的状态。

线程的出现也并不是为了取代进程，而是对进程的功能作了扩展。

进程可以支持多个线程，它们看似同时执行，但相互之间并不同步。

一个进程中的多个线程共享相同的内存地址空间，这就意味着它们可以访问相同的变量和对象，而且它们从同一堆中分配对象。

尽管这让线程之间共享信息变得更容易，但你必须小心，确保它们不会妨碍同一进程里的其他线程。

目前，大多数的操作系统都支持线程，包括Linux、Solaris和WindowsNT/2003，都可以利用多个处理器调度线程在任何可用的处理器上执行。

如果某个程序有多个活动线程，那么还可以同时调度多个线程。

在精心设计的程序中，使用多个线程可以提高程序吞吐量和性能。

在某些情况下，使用线程还可以使程序编写和维护起来更简单。

虽然线程可以大大简化许多类型的应用程序，但是过度使用线程可能会危及程序的性能及其可维护性。

不要忘记，线程同样也在消耗资源。

因此，在不降低性能的情况下，创建一定数量的线程才是真正有用的。

Java成为第一个在语言本身中显式地包含线程的主流编程语言，它使针对线程的操作不再那么神秘，因为它已经不再把线程看做是底层操作系统的工具。

不过，虽然Java提供的线程工具和API看似简单，但是编写有效使用线程的复杂程序并不十分容易。

因为有多个线程共存在相同的内存空间中并共享相同的变量，所以必须小心使用，从而确保线程不会互相干扰。

本章就将介绍关于线程的各种用法。

4.1什么是线程，如何创建线程

问题

在网络中，数据传输的速率是远远低于计算机的处理能力的，就本地文件的读写而言，其读写速度也远低于CPU的处理能力。

在传统的单任务环境中，程序必须等待上一个任务完成以后才能执行下一个任务。

例如当前某个程序运行过程中需要等待用户键盘输入的数据，由于键盘输入的速度相对于CPU的执行速度而言要慢得多，这时候CPU就会空闲下来，直到收到键盘输入的数据，程序继续执行。

解决这种问题的办法就是引入多线程技术，Java提供了这样的技术，利用多线程技术编写的程序，可以使计算机同时并行运行多个相对独立的任务。

例如，可以创建一个线程来负责数据的输入和输出，而创建另一个线程在后台进行其他的数据处理，如果输入输出线程在接收数据时阻塞，而处理数据的线程仍然可以运行。

这样，多线程程序设计就大大提高了程序执行效率和处理能力。

那么什么是线程，如何创建线程呢？

解决思路

在掌握如何创建线程之前，先要了解一下什么是进程。

进程（process）本质上是一个执行的程序。

操作系统引入进程以后就允许计算机可以同时运行两个或两个以上的程序，这就是多任务的处理模式。

每一个进程都有自己独立的一块内存空间、一组系统资源。

在进程概念中，每一个进程的内部数据和状态都是完全独立的。

例如，基于进程的多任务处理功能不仅可以使我们在操作系统中使用记事本编辑文档，而且还可以同时听歌和看电影。

线程与进程相似，是一段完成某个特定功能的代码，是程序中单个顺序的流控制，但与进程不同的是，同类的多个线程是共享同一块内存空间和一组系统资源的，而线程本身的数据通常只有微处理器的寄存器数据，以及一个供程序执行时使用的堆栈。

所以系统在产生一个线程，或者在各个线程之间切换时，负担要比进程小得多，正因如此，线程也被称为轻型进程（light-weightprocess）。

一个进程中可以包含多个线程。

多线程则指的是在单个程序中可以同时运行多个不同的线程，执行不同的任务。

多线程意味着一个程序的多行语句可以看上去几乎在同一时间内同时运行。

同时运行的含义是指操作系统中管理的时间片会平均地分给每个线程，从而保证所有的线程都能够在极短的时间内得到处理。

每一时间片内只能执行一个线程，但由于时间片是一个很小的时间单元，每一个线程又是很小的代码段，因此，操作系统能够在很短的时间内进行线程的切换，所以看起来就好像是多个任务可以同时执行。

Java提供了线程类Thread来创建多线程的程序。

其实，创建线程与创建普通的类的对象的操作是一样的，而线程就是Thread类或其子类的实例对象。

每个Thread对象描述了一个单独的线程。

要产生一个线程，有两种方法：

◆需要从Java.lang.Thread类派生一个新的线程类，重载它的run（）方法；

◆实现Runnalbe接口，重载Runnalbe接口中的run（）方法。

具体步骤

1、扩展Thread类来创建线程

首先，需要通过创建一个新类来扩展Thread类，这个新类就成为Thread类的子类。

接着在该子类中重写Thread类的run（）方法，此时方法体内的程序就是将来要在新建线程中执行的代码。

示例如下所示：

classSubThreadextendsThread

{

…

publicvoidrun（）

{

//新建线程所要完成的工作

}

…

}

接着要创建该子类的对象，此时一个新的线程就被创建了，创建新线程时会用到Thread类定义的如下两个构造函数：

◆publicThread（）

◆publicThread（Stringname）

其中，第一个构造函数是Thread类默认的构造函数，不指定参数；第二个构造函数可以为新建的线程指定一个名称，该名称就是字符串参数name的值。

建立了新的线程对象以后，它并不运行，而是直到调用了该对象的start（）方法，该方法在Thread类中定义，在Thread类的子类中被覆盖。

它的作用是启动一个新的线程，并在该线程上运行子类对象中的run（）方法。

start（）方法声明格式为：

publicvoidstart（）

示例如下所示：

SubThreads=newSubThread（）; //创建Thread子类的对象

s.start（）;//启动一个新的线程

当一个类继承Thread类时，它必须重写run（）方法，这个方法是新线程的入口。

如果Thread类的这个子类没有覆盖run（）方法，那么程序会调用Thread类的run（）方法，只不过该run（）方法什么也不做，此时新线程一创建就结束了。

这种线程对程序来说是没有任何意义的，所以在这里提醒读者在创建线程的时候一定不要忘了覆盖Thread类的run（）方法。

下面举一个完整的例子来演示通过扩展Thread类创建线程的过程。

程序代码如下所示：

//例4.1.1 ThreadDemo.java

classNewThreadextendsThread //通过继承Thread类来创建一个新的线程

{

NewThread（）//构造方法

{

super（"ThreadDemo"）; //定义线程的名字

System.out.println（"Newthread:

"+getName（））;

}

publicvoidrun（） //覆写run（）方法，这是线程的入口

{

while（true）

{

System.out.println（Thread.currentThread（）.getName（）+

" isrunning"）;

}

classThreadDemo

{

publicstaticvoidmain（Stringargs[]）

{

NewThreadthd=newNewThread（）;//创建一个新线程

thd.start（）; //启动线程，调用NewThread类对象的run（）方法

}

可以看到，新的线程是由实例化NewThread类的对象创建的，该NewThread类可以通过继承java.lang.Thread类来得到。

其中，在NewThread类中，构造函数里调用了super（）方法。

该方法将调用父类Thread下列形式的构造函数：

publicThread（StringthreadName）

这里，threadName指定线程名称（当然也可以不指定线程的名称，而由系统自动为新建线程提供名称）。

在NewThread类中通过覆写run（）方法来规定线程所要实现的内容。

此外，需要注意的是，启动新线程执行时必须调用start（）方法。

程序结果如图4.1.1所示：

图4.1.1创建一个新的线程并启动它

在上面的代码中，使用了Thread类的currentThread（）静态方法来获得当前程序执行时所对应的那个线程对象，又通过线程对象的getName（）方法，得到了当前线程的名字。

这些方法都可以在JDK帮助文档中查到。

因此，善于利用JDK帮助文档来获取有关类的更多信息，可以方便程序的编写。

在上面代码的run（）方法中，由于循环条件始终为true，因此，屏幕上会不断地输出ThreadDemoisrunning，新建的线程永远不会结束，这当然不是所希望的结果。

这里所希望的是可以合理的设置循环条件来有效地控制线程的终止。

所以，在run（）方法中使用到循环控制的时候一定要小心使用，否则局面难以控制。

其实，针对前面的程序做一些改动。

可以让这个程序实现一个非常有用的功能。

//例4.1.2 ThreadDemo2.java

classNewThreadextendsThread//通过继承Thread类来创建一个新的线程

{

NewThread（Stringname） //构造方法

{

super（name）;

}

publicvoidrun（） //重写run（）方法，这是线程的入口

{

for（inti=10;i>0;i--） //循环执行10次

{

try

{

System.out.println（"lefttime:

"+i）;

Thread.sleep（1000）; //当前线程睡眠1000毫秒

}catch（InterruptedExceptione）{ //处理异常

System.out.println（e.getMessage（））;

}

System.out.println（"gameisover,bye!

"）;

}

classThreadDemo2

{

publicstaticvoidmain（Stringargs[]）

{

NewThreadthd=newNewThread（"ThreadDemo"）;//创建一个新的线程

thd.start（）; //启动线程，调用NewThread类对象的run（）方法

}

程序输出结果如图4.1.2所示：

图4.1.2 线程应用

通过这个程序看到了什么？

在run（）方法体中，实现了一个倒计时的功能。

线程通过循环控制，每隔一秒输出一次剩余的时间，循环结束时输出"gameisover,bye!

"，线程也随之结束。

可见这个程序中新建的线程不是死循环，而是通过一些条件来对线程的起始进行了控制，从而实现了倒计时的功能。

在这个程序中，还可以看到，在给线程起名字的时候可以通过创建线程的时候来实现。

因为查阅JDK的帮助文档，会发现Thread类除了默认的构造函数之外，还有很多带参数的构造函数，只不过在这里是用到了publicThread（Stringname）这个构造方法。

并不是在创建线程对象的时候给线程起个名字就可以了，还应该在线程类的子类中定义相应的构造函数才行，这个构造函数的形式如下：

SubThread（Stringname） //线程子类的构造方法

{

super（name）;

}

如果不这样做，程序编译会提示错误，读者可以想想为什么。

也可以将上面程序中NewThread类的构造方法注释掉，编译一下程序，看到错误提示后，再去思考这个问题。

在这个程序中还用到了try…catch语句，它用来捕获程序中可能发生的异常，而产生异常的原因是程序中使用了Thread.sleep（）这样的方法。

通过查阅JDK的帮助文档，可以看到线程类的sleep（）方法的完整格式如下：

publicstaticvoidsleep（longmillis）throwsInterruptedException

看到这个throws关键字，想必读者就应知道为什么使用try…catch语句了。

由于这个方法可能会抛出一个中断异常，因此，有必要在程序调用这个方法时对可能发生的异常进行处理。

此外，这个方法是静态的，所以可以通过类名直接调用。

2、实现Runnable接口来创建线程

除了扩展Thread类可以创建线程之外，还可以通过定义一个实现了Runnable接口的类来创建线程。

为了将来程序执行时可以进入线程，在这个类中必须实现Runnable接口中唯一提供的run（）方法。

示例如下所示：

classOneThreadimplementsRunnable

{

…

publicvoidrun（）

{

//新建线程所要完成的工作

}

当定义好一个实现了Runnable接口的类以后，还不能直接去创建线程对象，要想真正去创建一个线程，还必须在类的内部实例化一个Thread类的对象。

此时，会用到Thread类定义的如下两个构造函数：

publicThread（Runnabletarget）

publicThread（Runnabletarget,Stringname）

在这两个构造函数中，参数target定义了一个实现了Runnable接口的类的对象引用。

新建的线程将来就是要执行这个对象中的run（）方法。

而新建线程的名字可以通过第二个构造方法中的参数name来指定。

示例如下所示：

OneThreadonethread=newOneThread（）;

Threadnewthread=newThread（onethread）;

此时，新线程对象才被创建，如果想要执行该线程的run（）方法，则仍然需要通过调用start（）方法来实现。

例如：

newthread.start（）;

要想创建新的线程对象，这两条语句缺一不可。

此后程序会在堆内存中实实在在地创建一个OneThread类的实例对象，该对象中包含了一个线程对象newthread。

newthread对象会通过调用start（）方法来执行它自己的run（）方法。

随着run（）方法的结束，线程对象newthread的生命也将结束，但是onethread对象还会存在于堆内存当中。

如果希望在实际编程当中一旦线程结束，即释放与线程有关的所有资源，可以使用创建匿名对象的方法来创建这个线程，格式如下所示：

newThread（newOneThread）.start（）;

这样一来，该线程一旦运行结束，所有与该线程有关的资源都将成为垃圾，这样就可以在特定的时间内被Java的垃圾回收机制予以回收，释放所占用内存，提高程序的效率。

下面这个程序是通过实现Runnable接口来创建的线程，可以将它和前面的例4.1.2的程序进行比较。

//例4.1.3 ThreadDemo3.java

classNewThreadimplementsRunnable//实现了Runnable接口

{

publicvoidrun（）//覆写Runnable接口中唯一的run（）方法，这是线程的入口

{

for（inti=10;i>0;i--）

{

try

{

System.out.println（"lefttime:

"+i）;

Thread.sleep（1000）; //当前线程睡眠1000毫秒

}catch（InterruptedExceptione）{ //处理异常

System.out.println（e.getMessage（））;

}

System.out.println（"gameisover,bye!

"）;

}

classThreadDemo3

{

publicstaticvoidmain（Stringargs[]）

{

NewThreadnewthread=newNewThread（）;

Threadthd=newThread（newthread,"ThreadDemo"）

thd.start（）; //启动线程，调用run（）方法

}

编译并运行这个程序，可以看到程序执行的结果和例4.1.2的程序输出的结果是完全一样的，因此，读者可以在创建线程的时候选择任意一种方式来实现。

专家说明

为了使程序达到优异的性能，可以利用创建线程来完成那些任务。

因为一个线程就是一个独立的执行通道，在没有特殊的要求之下，多个线程之间彼此独立运行，互不干扰。

而且带线程的程序通常比没有带线程的程序运行得要快，因此线程常用在网络和图形用户界面等程序设计当中，这一优势在多处理器的计算机上更加明显。

本节中不仅要理解什么是线程，而且还应掌握两种创建线程的方法，为以后在程序中使用多线程技术打下坚实的基础。

专家指点

学习了本节以后，有很多读者都会问到这样的问题：

为什么Java要提供两种方法来创建线程呢？

它们都有哪些区别？

相比而言，哪一种方法更好呢？

在Java中，类仅支持单继承，也就是说，当定义一个新的类的时候，它只能扩展一个外部类.这样，如果创建自定义线程类的时候是通过扩展Thread类的方法来实现的，那么这个自定义类就不能再去扩展其他的类，也就无法实现更加复杂的功能。

因此，如果自定义类必须扩展其他的类，那么就可以使用实现Runnable接口的方法来定义该类为线程类，这样就可以避免Java单继承所带来的局限性。

还有一点最重要的就是使用实现Runnable接口的方式创建的线程可以处理同一资源，从而实现资源的共享，这一点会在第4.2节中介绍。