CSDN博客

img zdg

Java 101之线程基础

发表于2000/8/21 11:04:00  1690人阅读

作者: Al Saganich

<让我们深入了解一下Java线程,以及了解一下为什么需要需要开发基于线程的应用程序>

线程是Java语言的一个部分,而且是Java的最强大的功能之一。究竟什么是线程,为什么要开发基于线程的应用程序?在本文中,我们将深入了解一下线程的用法,以及使用线程的一些技术。在我们开始讲述线程之前,最好先了解一下有关背景知识和分析一下线程的工作原理。

当程序员一开始开发应用程序时,这些应用程序只能在一个时间内完成一件事情。应用程序从主程序开始执行,直到运行结束,像 Fortran/Cobol/Basic这些语言均是如此。

随着时间的推移,计算机发展到可以在同一时间段内运行不止一个应用程序的时代了,但是应用程序运行时仍然是串行的,即从开始运行到结束,下一条指令接着上一条指令执行。到最近,程序发展到可以在执行时,以若干个线程的形式运行。Java就具有运行多线程的能力,可以在同一时间段内进行几个操作,这就意味着给定的操作不必等到另外一个操作结束之后,才能开始。而且对某个操作可以指定更高一级的优先级。

不少程序语言,包括ADA, Modula-2和C/C++,已经可以提供对线程的支持。同这些语言相比,Java的特点是从最底层开始就对线程提供支持。除此以外,标准的Java类是可重入的,允许在一个给定的应用程序中由多个线程调用同一方法,而线程彼此之间又互不干扰。Java的这些特点为多线程应用程序的设计奠定了基础。

什么是线程?

究竟什么是线程呢?正如在图A中所示,一个线程是给定的指令的序列 (你所编写的代码),一个栈(在给定的方法中定义的变量),以及一些共享数据(类一级的变量)。线程也可以从全局类中访问静态数据。


栈以及可能的一些共享数据


每个线程有其自己的堆栈和程序计数器(PC)。你可以把程序计数器(PC)设想为用于跟踪线程正在执行的指令,而堆栈用于跟踪线程的上下文,上下文是当线程执行到某处时,当前的局部变量的值。虽然你可以编写出在线程之间传送数据的子程序,在正常情况下,一个线程不能访问另外一个线程的栈变量。

一个线程必须处于如下四种可能的状态之一,这四种状态为:

  • 初始态:一个线程调用了new方法之后,并在调用start方法之前的所处状态。在初始态中,可以调用start和stop方法。
  • Runnable一旦线程调用了start 方法,线程就转到Runnable 状态,注意,如果线程处于Runnable状态,它也有可能不在运行,这是因为还有优先级和调度问题。 阻塞/ NonRunnable:线程处于阻塞/NonRunnable状态,这是由两种可能性造成的:要么是因挂起而暂停的,要么是由于某些原因而阻塞的,例如包括等待IO请求的完成。 退出:线程转到退出状态,这有两种可能性,要么是run方法执行结束,要么是调用了stop方法。
  • 最后一个概念就是线程的优先级,线程可以设定优先级,高优先级的线程可以安排在低优先级线程之前完成。一个应用程序可以通过使用线程中的方法setPriority(int),来设置线程的优先级大小。

前面我们已经讲述了线程的基本知识,现在我们可以来看看Java为我们提供的用来开发基于线程的应用程序的两种机制:线程类和Runnable 接口。

派生线程类

最简单的编写基于线程的代码的方法之一,就是派生java.lang.Thread 类。该线程类是java.lang 包的一个成员,在缺省情况下,线程类可以被所有的Java应用程序调用。为了使用线程类,我们需要了解The java.lang.Thread 类中定义的五个方法:

  • run():该方法用于线程的执行。你需要重载该方法,以便让线程做特定的工作。
  • start():该方法使得线程启动run()
  • stop():该方法同start方法的作用相反,停止线程的运行。
  • suspend():该方法同stop方法不同的是,它并不终止未完成的线程,它仅仅挂起线程,以后还可恢复。
  • resume():该方法重新启动已经挂起的线程。

 

运行List A中的程序,运行结果见List B

List A :扩展线程类

class TestThreads {
  public static void main (String args []) {
     class MyThread extends Thread {
        String which;
        MyThread (String which)            {
        this.which = which;          
     }
     public void run() {
        int iterations = (int)(Math.random()*100) %15;
        int sleepinterval = (int)(Math.random()*1000);
        System.out.println(which + " running for " + iterations +" iterations");
        System.out.println(which + " sleeping for " + sleepinterval + "ms between loops");
        for (int i = 0; < iterations; i++) {
                      System.out.println(which +" " + i);
                              try {
                                  Thread.sleep(sleepinterval);
                              } catch (InterruptedException e) {}
                          }
                      }
       }

       MyThread a = new MyThread("Thread A");
       MyThread b = new MyThread("Thread B");
       MyThread c = new MyThread("Thread C");
       a.start();
       b.start();
       c.start();
   }
}

ListB: 清单A的输出

Thread A running for 16 iterations

Thread C running for 15 iterations

Thread B running for 14 iterations

Thread A sleeping for 305ms between

   loops

Thread C sleeping for 836ms between

   loops

Thread B sleeping for 195ms between

   loops

Thread A 0

Thread C 0

Thread B 0

. . .

Thread C 13

Thread B 13

Thread A 14

Thread C 14

Thread A 15

List A演示了如何从现有的Thread类中派生出一个新类。新创建的类重载了run 方法。有趣的是,实现run 方法不必很严格,因为Thread类提供一个缺省的run方法,尽管它不是特别有用。

在有些场合,我们不能简单地改变指定对象的父类。我们仍然需要采用线程。这时,我们就需要用到Runnable接口。

使用Runnable接口

开发线程应用程序的第二个方法是通过Runnable接口来实现。在不少场合,你不能重新定义类的父母,或者不能定义派生的线程类,也许你的类的层次要求你的父类为特定的类。在这些情况下,可以通过Runnable接口来实现多线程的功能。

提示:接口是个复杂的技术,要彻底理解它的用法需要花费力气。感兴趣的读者可以阅读我的前一篇文章《接口的阐述》,发表在1998年5月的 Visual J++ Developer's Journal杂志上。

List C是一个简单的动画小程序,它是一个使用Runnable接口的例子。该例子可以放在网页上,它需要从Applet类中派生出来。该小程序的目的是通过对一个接一个的图象进行着色,从而显示出动画的效果。因为动画占用了不少处理器时间,我们不打算在图象着色的时候阻塞其他进程的运行。例如,如果打算停止动画,我们不想等到它运行结束时,再调用stop方法。换句话说,我们可以让小程序线程化。

List C: 动画小程序

import java.applet.*;
import java.awt.*;


public class TstRunnable extends Applet
    implements Runnable {
  private Thread m_Thread = null;
  private Image m_Images[];
  private Image m_CurrentImage =null;
  private int m_nImgWidth = 0;
  private int m_nImgHeight = 0;
  private boolean m_fAllLoaded =  alse;
  private final int NUM_IMAGES = 18;

  public TstRunnable() { }
  private void displayImage(Graphics g) {
     if ( null != m_CurrentImage )
        g.drawImage(m_CurrentImage,(getSize().width - m_nImgWidth) / 2, 
                      (getSize().height - m_nImgHeight) / 2, null);
  }
  public void paint(Graphics g) {
     if (null != m_CurrentImage) {
        Rectangle r = g.getClipBounds();
        g.clearRect(r.x, r.y, r.width, r.height);
        displayImage(g);
    }
     else
        g.drawString("Loading images...", 10, 20);
  }
// The Applets start method is called when the page is first shown.
  public void start() {
     if (m_Thread == null) {
        m_Thread = new Thread(this);
        m_Thread.start();
     }
 }
// The Applets stop method is called when the page is hidden.
  public void stop() {
     if (m_Thread != null) {
        m_Thread.stop();
        m_Thread = null;
     }
  }
// The run method is used by the thread
//   object we created in this start method.
  public void run() {
     int iWhichImage = 0;
     Graphics m_Graphics = getGraphics();
     repaint();
     m_Graphics = getGraphics();
     m_Images   = newImage[NUM_IMAGES];
     MediaTracker tracker = new MediaTracker(this);
     String strImage;
     for (int i = 1; i <= NUM_IMAGES; i++) {
        m_Images[i-1] = getImage(getCodeBase(),          
                      "img" + new Integer(i).toString() + ".gif");
        tracker.addImage(m_Images[i-1],0);
     }
     try {
        tracker.waitForAll();
        m_fAllLoaded = !tracker.isErrorAny();
     } catch (InterruptedException e) {}
     if (!m_fAllLoaded) {
        stop();
        m_Graphics.drawString("Error loading images!", 10, 40);
        return;
     }
 // Assuming all images are the same          
 // width and height.
 //------------------------------------
     m_nImgWidth  = m_Images[0].getWidth(this);
     m_nImgHeight = m_Images[0].getHeight(this);
     repaint();
     while (true) {
        try {
// Draw next image in animation.
                      m_CurrentImage = m_Images[iWhichImage];
                      displayImage(m_Graphics);
                      iWhichImage = (iWhichImage+1) % NUM_IMAGES;
                      Thread.sleep(50);
        } catch (InterruptedException            e) {
                      stop();
        }
     }
 }
}

我们使用Runnable接口实现了线程,而没有通过创建线程类的派生类的方式。使用Runnable接口,需要我们实现run方法。我们也需要创建Thread对象的一个实例,它最终是用来调用run方法的。在小程序中的start方法中,我们通过使用thread建构方法产生一个Thread对象的实例,其参数就是实现Runnable接口的任何类。 Thread 对象启动已经定义好的run 方法,而run方法是用来进行动画显示的。当然,从线程类中派生出一个类,并在Applet派生类中创建实例,我们可完成同样的事情。该例子是用来演示Runnable接口的用法。

在我们接着读下去之前,有几个问题需要回答。你也许会问,浏览器调用Java小程序的start和stop方法吗? run 方法是如何被调用的? 情况是这样的,当浏览器启动了一个内部线程时,就相应地启动了applet 的运行。当网页显示时,就启动了applet的start 方法。Start方法创建一个线程对象,并把applet自身传送给线程,以实现run方法。

此时,两个线程在运行:由浏览器启动的初始线程,以及处理动画的线程。快速查看applet的start方法,可以知道它创建了线程,并启动了它。类似地,当网页被隐藏后,applet的stop方法就调用了线程的stop方法。

注意:AppletsThreads中的 start/stop子程序

在Applet 和Thread 两个类中都有start和stop方法,但它们的功能不同。一旦Applet 显示时,就调用applet的start方法,一旦applet 隐藏时,就调用applet的stop 方法。相反,线程的start方法将调用run方法,线程的stop方法将停止正在执行的线程。

动画程序的设计原理

既然我们已经看过动画是如何开始的。现在看看它的机理。首先,我们通过定义Runnable 接口的方式来编写小程序,一旦定义了该接口,就表明我们将在其后实现run方法。

public class TstRunnable
  extends Applet implements Runnable . . 

然后我们编写run方法,该方法将被动画线程所调用。

public void run() {
  . . . 
  }

我们也需要一个线程对象,该对象将管理我们的动画线程,如:

private Thread m_Thread = null;

一旦做好这些准备工作以后,当applet第一次被显示时,就会创建线程对象的一个实例,并把this对象作为建构方法的参数,之后就可以启动动画了:

public void start() {
  if (m_Thread == null)      {
     m_Thread      = new Thread(this);
     m_Thread.start();
  }
}

最后一步编写如下代码:一旦applet 被隐藏时,就停止动画,Applet的stop方法如下:

public void stop(){
  if (m_Thread != null) {
     m_Thread.stop();
     m_Thread = null;
  }
}
结论

基于线程的程序功能强大。本文中,我们讨论了线程的一些基本知识:什么是线程,如何使用它们。下个月,我们将学习一些使用线程时的注意点,并讨论线程的一些高级用法。

0 0

相关博文

我的热门文章

img
取 消
img