多线程之进程、线程与多线程文字滚动的实现

 
                        多线程

相信读者都有这样的经验，计算机可以同时运行多个程序，例如在使用Winsows Media Player播放音乐的同时，可以使用IE浏览器上网浏览新闻。这些程序似乎都在同时运行，但事实并非如此，除非你的计算机有多个CPU（如双核结构），否则不会真正同时运行两个以上的程序。

进程和线程

进程也称任务，所以支持多个进程同时执行的操作系统就被称为多进程操作系统或多任务操作系统。当前主流的操作系统都属于这个类型。

在一个系统内部也可以实现多个任务并发执行，其中每个任务称为线程，即线程是指同一个程序（进程）内部每一个单独执行的流程。

我们以前编写程序的内部都只包含一个系统流程，从main开始，随着方法的调用进入到每一个方法的内部，调用完成后返回调用的位置，知道main方法结束以后该流程结束。这个流程称为系统流程，这样的程序也称为单线程程序。

多线程优势、

多线程程序的只要优势有两个：

1，          提高界面程序的响应速度。

2，          成分利用系统资源。

多线程也有不足之处，当程序中线程数量比较多时，系统将花费大量的实践进行进程的切换，反而降低了程序的 执行效率。

多线程的实现

在实现多线程时，Java 语言提供了3种实现方式：

1，          继承Thread类。

2，          实现Runnable接口。

3，          使用Timer和TimerTask组合。

继承Thread类实现多线程

import java.awt.*;

import java.util.TimerTask；

import javax.swing.*;

public class TextScroll extends JFrame{ 

JLabel lb = new JLabel("Thread多线程文字滚动的实现！！！",JLabel.CENTER);

   

    public TextScroll(){

         super("");

         this.add(lb);

         this.setSize(300,300);

         this.setVisible(true);

         new TextScroll_1(lb).start();

    }

    public static void main(String[] args) {

      new TextScroll();

    }

 

    class TextScroll_1 extends Thread{

         JLabel lb ;

         public TextScroll_1(JLabel _lb){

               lb = _lb;

         }

         public void run(){

               String str = lb.getText();

               while(true){

                    try{

                          str = str.substring(1)+str.substring(0,1);

                          lb.setText(str);

                          Thread.sleep(200);

                    }catch (InterruptedException ie) {

                          ie.printStackTrace();

                    }

               }

         }

    }

}

实现Runnable接口

import java.awt.*;

import java.util.TimerTask;

import javax.swing.*;

public class TextScroll1 extends JFrame {    

JLabel lb = new JLabel("Runnable多线程文字滚动的实现！！！",JLabel.CENTER);

   

    public TextScroll1(){

         super("");

         this.add(lb);

         this.setSize(300,300);

         this.setVisible(true);

         new TextScroll_1(lb).start();

        

    }

    public static void main(String[] args) {

         TextScroll1 t1 = new TextScroll1();

         t1.setVisible(true);

    }

}

class TextScroll_1 implements Runnable{

         JLabel lb ;

         public TextScroll_1(JLabel _lb){

               lb = _lb;

         }

         public void start() {

               String str = lb.getText();

               while(true){

                    try{

                          str = str.substring(1)+str.substring(0,1);

                          lb.setText(str);

                          Thread.sleep(200);

                    }catch (InterruptedException ie) {

                          ie.printStackTrace();

                    }

               }        

         }

         public void run(){

         }        

    }

    使用Timer和TimerTask组合。

import java.awt.*;

import java.util.TimerTask;

 

import javax.swing.*;

 

 

public class TextScroll2 extends JFrame{

   

    JLabel lb = new JLabel("TimerTask多线程文字滚动的实现！！！",JLabel.CENTER);

   

    public TextScroll2(){

         super("");

         this.add(lb);

         this.setSize(300,300);

         this.setVisible(true);

         new TextScroll_1(lb).start();

    }

    public static void main(String[] args) {

      new TextScroll2();

    }

 

    class TextScroll_1 extends TimerTask{

         JLabel lb ;

         public TextScroll_1(JLabel _lb){

               lb = _lb;

         }

         public void start() {

         String str = lb.getText();

         while(true){

                    try{

                          str = str.substring(1)+str.substring(0,1);

                          lb.setText(str);

                          Thread.sleep(200);

                    }catch (InterruptedException ie) {

                          ie.printStackTrace();

                    }

               }

         }

         public void run(){

 

         }

    }

}

在我们的OS里，

进程是资源分配的最小单位

线程是cpu调度的最小单位

 

1、继承Thread

   创建：  A extends Thread

       在A中实现run()

   启动：利用继承自Thread 的strart() 方法

          A a = new A();

      a.start();

 

2、实现Runnable接口

   创建：  A implements Runnable

       在A中实现run()

   启动： 以A的对象为Thread的构造函数的参数创建Thread对象

       并且利用它的start（）方法调度启动线程

          A a = new A();

      Thread b = new Thread(a);

      b.start();

 

 

3、利用Timer TimerTask

 

    创建：创建TimerTask的子类，并实现run()方法得到时钟器任务类

          MyTimerTask extends TimerTask{

         public void run(){

         }

      }

    启动：创建时钟器Timer对象

          利用时钟器对象的schedule()方法启动线程任务

 

      Timer timer = new Timer();

      timer.schedule(new MyTimerTask(), ....,...);