Java线程：什么是线程

一 基本概念

　　多任务：同一时刻运行多个程序的能力。每一个任务称为一个线程。可以同时运行一个以上线程的程序称为多线程程序。

　　Java编写程序都运行在在Java虚拟机（JVM）中，在JVM的内部，程序的多任务是通过线程来实现的。每用java命令启动一个java应用程序，就会启动一个JVM进程。在同一个JVM进程中，有且只有一个进程，就是它自己。在这个JVM环境中，所有程序代码的运行都是以线程来运行。

　　一般常见的Java应用程序都是单线程的。比如，用java命令运行一个最简单的HelloWorld的Java应用程序时，就启动了一个JVM进程，JVM找到程序程序的入口点main()，然后运行main()方法，这样就产生了一个线程，这个线程称之为主线程。当main方法结束后，主线程运行完成。JVM进程也随即退出 。

　　对于一个进程中的多个线程来说，多个线程共享进程的内存块，当有新的线程产生的时候，操作系统不分配新的内存，而是让新线程共享原有的进程块的内存。因此，线程间的通信很容易，速度也很快。不同的进程因为处于不同的内存块，因此进程之间的通信相对困难。

　　进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。

　　线程是指进程中的一个执行流程，一个进程可以运行多个线程。比如java.exe进程可以运行很多线程。线程总是输入某个进程，进程中的多个线程共享进程的内存。

　　Java中线程是指java.lang.Thread类的一个实例或线程的执行。使用java.lang.Thread或java.lang.Runnable接口编写代码定义、实例化、启动新线程。

　　Java中每个线程都有一个调用栈，即使不在程序中创建任何新的线程，线程也在后台运行。main()方法运行在一个线程内，称为主线程。一旦创建一个新的线程，就产生一个新的调用栈。

　　线程分为两类：用户线程和守候线程。当所有用户线程执行完毕后，JVM自动关闭。但是守候线程却不独立与JVM，守候线程一般是有操作系统或用户自己创建的。

 

二 定义线程

1 扩展java.lang.Thread类以及实现java.lang.Runnable接口。

　　此类中有run()方法，public void run()，如果该线程是独立的Runnable运行对象构造的，则调用该Runnable对象的run()方法；否则，该方法不执行任何操作。Thread的子类也应该重写该方法。

 

三 实例化线程

1 如果是扩展了java.lang.Thread类的线程，则直接调用new即可。

2 如果是实现了jav.lang.Runnable接口的类，则调用Thread的构造方法：

　　Thread(Runnable target)

　　Thread(Runnable target,String name)

　　Thread(ThreadGroup group, Runnable target)

　　Thread(ThreadGroup group, Runnable target, String name)

　　Thread(ThreadGroup group, Runnable target, String name, long stackSize)

 

四 启动线程

　　在线程的Thread对象上调用start()方法，而不是run()或别的方法。

　　在调用start()方法之前，线程处于新状态中，新状态有一个Thread对象，但没有一个真正的线程。

　　在调用start()方法之后，发生了一系列复杂的事情：　　

　　　　启动新的执行线程(具有新的调用栈)；

　　　　该线程从新状态转移到可运行状态；

　　　　当该线程获得执行机会时，其目标run()方法将运行。

 

五 注意事项

　　1 获取当前线程的对象的方法是：Thread.currentThread()；

　　2 当线程目标run()方法结束时该线程完成。

　　3 一旦线程启动，它就永远不能再重新启动。只有一个新的线程可以被启动，并且只能一次。一个可运行的线程或死线程可以被重新启动。

　　4 线程的调度是JVM的一部分，在一个CPU的机器上上，实际上一次只能运行一个线程。一次只有一个线程栈执行。JVM线程调度程序决定实际运行哪个处于可运行状态的线程。众多可运行线程中的某一个会被选中做为当前线程。可运行线程被选择运行的顺序是没有保障的。

　　5 尽管通常采用队列形式，但这是没有保障的。队列形式是指当一个线程完成“一轮”时，它移到可运行队列的尾部等待，直到它最终排队到该队列的前端为止，它才能被再次选中。事实上，我们把它称为可运行池而不是一个可运行队列，目的是帮助认识线程并不都是以某种有保障的顺序排列一个队列的事实。

　　6 尽管我们没有无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式。

 

六 示例

　　当点击start按钮时，程序从屏幕左上角弹出一个球，这个球开始移动，调用addBall方法，循环运行1000次move。每调用一次move，球就会移动一点，当碰到墙壁时，就会调整方向，但是这个程序有个弊端：当你想在移动1000次之前，就想退出程序，点击close发现，其仍在移动。

　　Thread类的静态方法sleep()将暂停给定的毫秒数。调用Thread.sleep不会创建一个新线程，sleep是Thread类的静态方法，用于暂停当前线程活动。

　　Bounce.java

 package Thread;
 import java.awt.*;
 import java.awt.event.*;
 import javax.swing.*;
 public class BounceThread {
     public static void main(String[] args){
         EventQueue.invokeLater(new Runnable(){
             public void run(){
                 JFrame frame=new BounceFrame();
                 frame.setTitle("BounceFrame");
                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                 frame.setVisible(true);
             }
         });
     }
 }
 /*class BallRunnable implements Runnable{
     private Ball ball;
     private Component component;
     public static final int STEPS=1000;
     public static final int DELAY=5;
     public BallRunnable(Ball aBall,Component aComponent){
         ball=aBall;
         component=aComponent;
     }
     public void run(){
         try{
             for(int i=1;i<=STEPS;i++){
                 ball.move(component.getBounds());
                 component.repaint();
                 Thread.sleep(DELAY);
             }
         }
         catch(InterruptedException e){}
     }
 }*/
 class BounceFrame extends JFrame{
     private BallComponent comp;
     public static final int STEPS=1000;
     public static final int DELAY=100;
     public BounceFrame(){
         comp=new BallComponent();
         add(comp,BorderLayout.CENTER);
         JPanel buttonPanel=new JPanel();
         addButton(buttonPanel,"Start",new ActionListener(){
             public void actionPerformed(ActionEvent event){
                 addBall();
             }
         });
         addButton(buttonPanel,"Close",new ActionListener(){
             public void actionPerformed(ActionEvent event){
                 System.exit(0);
             }
         });
         add(buttonPanel,BorderLayout.SOUTH);
         pack();
     }
     public void addButton(Container c,String title,ActionListener listener){
         JButton button=new JButton(title);
         c.add(button);
         button.addActionListener(listener);
     }
     /*public void addBall(){
         Ball b=new Ball();
         comp.add(b);
         Runnable r=new BallRunnable(b,comp);
         Thread t=new Thread(r);
         t.start();
     }*/
     public void addBall(){
         try{
             Ball ball=new Ball();
             comp.add(ball);
             for(int i=1;i<=STEPS;i++){
                 ball.move(comp.getBounds());
                 comp.paint(comp.getGraphics());
                 Thread.sleep(DELAY);
             }
         }
         catch(InterruptedException e){}
     }
 }

　　BollComponent.java

 package Thread;
 import java.awt.*;

 import java.util.*;
 import javax.swing.*;
 public class BallComponent extends JPanel{
     private static final int DEFAULT_WIDTH=450;
     private static final int DEFAULT_HEIGHT=350;
     private java.util.List<Ball>balls=new ArrayList<>();
     public void add(Ball b){
         balls.add(b);
     }
     public void paintComponent(Graphics g){
         super.paintComponent(g);
         Graphics2D g2=(Graphics2D)g;
         for(Ball b:balls){
             g2.fill(b.getShape());
         }
     }
     public Dimension getPreferredSize(){
         return new Dimension(DEFAULT_WIDTH,DEFAULT_HEIGHT);
     }
 }

　　Ball.java

 package Thread;
 import java.awt.geom.*;
 import java.awt.geom.Ellipse2D.Double;
 public class Ball {
     private static final int XSIZE=15;
     private static final int YSIZE=15;
     private double x=0;
     private double y=0;
     private double dx=1;
     private double dy=1;
     public void move(Rectangle2D bounds){
         x+=dx;
         y+=dy;
         if(x<bounds.getMinX()){
             x=bounds.getMinX();
             dx=-dx;
         }
         if(x+XSIZE>=bounds.getMaxX()){
             x=bounds.getMaxX()-XSIZE;
             dx=-dx;
         }
         if(y<bounds.getMinY()){
             y=bounds.getMinY();
             dy=-dy;
         }
         if(y+YSIZE>=bounds.getMaxY()){
             y=bounds.getMaxY()-YSIZE;
             dy=-dy;
         }
     }
     public Ellipse2D getShape(){
         return new Ellipse2D.Double(x,y,XSIZE,YSIZE);
     }
 }

　　针对上述的情况，下面的代码是改进后的，当点击close时，就会退出当前线程。而且不论何时点击Start按钮，addBall都会启动一个新线程.

　　实现多个线程的方法：将移动球的代码放置在一个独立的线程中，点击开始就会重新启动一个线程。简单过程如下：

　　　　1、将任务代码放在实现了Runnable接口的类的run方法中。

 class MyRunnable implements Runnable{
      public void run(){
          task code
     }
 }

　　　　2、创建一个类对象。Runnable r=new MyRunnable();

　　　　3、由Runnable创建一个Thread对象。Thread t=new Thread();

　　　　4、启动线程：t.start();

　BounceThread.java

 package Thread;
 import java.awt.*;
 import java.awt.event.*;
 import javax.swing.*;
 public class BounceThread {
     public static void main(String[] args){
         EventQueue.invokeLater(new Runnable(){
             public void run(){
                 JFrame frame=new BounceFrame();
                 frame.setTitle("BounceFrame");
                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                 frame.setVisible(true);
             }
         });
     }
 }
 class BallRunnable implements Runnable{
     private Ball ball;
     private Component component;
     public static final int STEPS=1000;
     public static final int DELAY=5;
     public BallRunnable(Ball aBall,Component aComponent){
         ball=aBall;
         component=aComponent;
     }
     public void run(){
         try{
             for(int i=1;i<=STEPS;i++){
                 ball.move(component.getBounds());
                 component.repaint();
                 Thread.sleep(DELAY);
             }
         }
         catch(InterruptedException e){}
     }
 }
 class BounceFrame extends JFrame{
     private BallComponent comp;
     //public static final int STEPS=1000;
     //public static final int DELAY=100;
     public BounceFrame(){
         comp=new BallComponent();
         add(comp,BorderLayout.CENTER);
         JPanel buttonPanel=new JPanel();
         addButton(buttonPanel,"Start",new ActionListener(){
             public void actionPerformed(ActionEvent event){
                 addBall();
             }
         });
         addButton(buttonPanel,"Close",new ActionListener(){
             public void actionPerformed(ActionEvent event){
                 System.exit(0);
             }
         });
         add(buttonPanel,BorderLayout.SOUTH);
         pack();
     }
     public void addButton(Container c,String title,ActionListener listener){
         JButton button=new JButton(title);
         c.add(button);
         button.addActionListener(listener);
     }
     public void addBall(){
         Ball b=new Ball();
         comp.add(b);
         Runnable r=new BallRunnable(b,comp);
         Thread t=new Thread(r);
         t.start();
     }
     /*public void addBall(){
         try{
             Ball ball=new Ball();
             comp.add(ball);
             for(int i=1;i<=STEPS;i++){
                 ball.move(comp.getBounds());
                 comp.paint(comp.getGraphics());
                 Thread.sleep(DELAY);
             }
         }
         catch(InterruptedException e){}
     }*/
 }

　BollComponent.java

 package Thread;
 import java.awt.*;

 import java.util.*;
 import javax.swing.*;
 public class BallComponent extends JPanel{
     private static final int DEFAULT_WIDTH=450;
     private static final int DEFAULT_HEIGHT=350;
     private java.util.List<Ball>balls=new ArrayList<>();
     public void add(Ball b){
         balls.add(b);
     }
     public void paintComponent(Graphics g){
         super.paintComponent(g);
         Graphics2D g2=(Graphics2D)g;
         for(Ball b:balls){
             g2.fill(b.getShape());
         }
     }
     public Dimension getPreferredSize(){
         return new Dimension(DEFAULT_WIDTH,DEFAULT_HEIGHT);
     }
 }

　　Ball.java

 package Thread;
 import java.awt.geom.*;
 import java.awt.geom.Ellipse2D.Double;
 public class Ball {
     private static final int XSIZE=15;
     private static final int YSIZE=15;
     private double x=0;
     private double y=0;
     private double dx=1;
     private double dy=1;
     public void move(Rectangle2D bounds){
         x+=dx;
         y+=dy;
         if(x<bounds.getMinX()){
             x=bounds.getMinX();
             dx=-dx;
         }
         if(x+XSIZE>=bounds.getMaxX()){
             x=bounds.getMaxX()-XSIZE;
             dx=-dx;
         }
         if(y<bounds.getMinY()){
             y=bounds.getMinY();
             dy=-dy;
         }
         if(y+YSIZE>=bounds.getMaxY()){
             y=bounds.getMaxY()-YSIZE;
             dy=-dy;
         }
     }
     public Ellipse2D getShape(){
         return new Ellipse2D.Double(x,y,XSIZE,YSIZE);
     }
 }

运行结果如下：