Java多线程基本用法总结_Java教程

这篇是Java 多线程基本用法的一个总结。

本篇文章会从一下几个方面来说明Java多线程的基本用法：

如何使用多线程
如何得到多线程的一些信息
如何停止线程
如何暂停线程
线程的一些其他用法

如何使用多线程

启动线程的两种方式

Java 提供了2种方式来使用多线程，一种是编写一个类来继承Thread,然后覆写run方法，然后调用start方法来启动线程。这时这个类就会以另一个线程的方式来运行run方法里面的代码。另一种是编写一个类来实现Runnable接口，然后实现接口方法run，然后创造一个Thread对象，把实现了Runnable接口的类当做构造参数，传入Thread对象，最后该Thread对象调用start方法。

这里的start方法是一个有启动功能的方法，该方法内部回调run方法。所以，只有调用了start方法才会启动另一个线程，直接调用run方法，还是在同一个线程中执行run，而不是在另一个线程执行run

此外，start方法只是告诉虚拟机，该线程可以启动了，也就说该线程在就绪的状态，但不代表调用start就立即运行了，这要等待JVM来决定什么时候执行这个线程。也就是说，如果有两个线程A,B ，A先调用start，B后调用start，不代表A线程先运行，B线程后运行。这都是由JVM决定了，可以认为是随机启动。

下面我们用实际的代码，来说明两种启动线程的方式：

第一种，继承Thread

									public class ExampleThread extends Thread{

									  @Override

									  public void run() {

									    super.run();

									    System.out.println("这是一个继承自Thread的ExampleThread");

									  }

									}

测试的代码可以看test目录下的ExampleThreadTest类

另一种，实现了Runnable接口

									public class ExampleRunable implements Runnable{

									  public void run() {

									    System.out.println("这是实现Runnable接口的类");

									  }

									}

测试的代码可以看test目录下的ExampleRunableTest类。

如何得到多线程的一些信息

我们在启动多线程之后，希望能通过一些API得到启动的线程的一些信息。JDK给我们提供了一个Thread类的方法来得到线程的一些信息。

线程的名字 —— getName()
线程的ID —— getId()
线程是否存活 —— isAlive()

得到线程的名字

这些方法是属于Thread的内部方法，所以我们可以用两种方式调用这些方法，一个是我们的类继承Thread来使用多线程的时候，可以用过this来调用。另一种是通过Thread.currentThread() 来调用这些方法。但是这两个方法在不同的使用场景下是有区别的。

我们先简单来看两个方法的使用。

第一个Thread.currentThread()的使用，代码如下：

									public class ExampleCurrentThread extends Thread{

									  public ExampleCurrentThread(){

									    System.out.println("构造方法的打印：" + Thread.currentThread().getName());

									  }

									  @Override

									  public void run() {

									    super.run();

									    System.out.println("run方法的打印：" + Thread.currentThread().getName());

									  }

									}

测试的代码如下：

									public class ExampleCurrentThreadTest extends TestCase {

									  public void testInit() throws Exception{

									    ExampleCurrentThread thread = new ExampleCurrentThread();

									  }

									  public void testRun() throws Exception {

									    ExampleCurrentThread thread = new ExampleCurrentThread();

									    thread.start();

									    Thread.sleep(1000);

									  }

									}

结果如下：

									构造方法的打印：main

									run方法的打印：Thread-0

									构造方法的打印：main

为什么我们在ExampleCurrentThread内部用Thread.currentThread()会显示构造方法的打印是main，是因为Thread.currentThread()返回的是代码段正在被那个线程调用的信息。这里面很显然构造方法是被main线程执行的，而run方法是被我们自己启动的线程执行的，因为没有给他起名字，所以默认是Thread-0。

接下来，我们在看一看继承自Thread，用this调用。

									public class ComplexCurrentThread extends Thread{

									  public ComplexCurrentThread() {

									    System.out.println("begin=========");

									    System.out.println("Thread.currentThread().getName=" + Thread.currentThread().getName());

									    System.out.println("this.getName()=" + this.getName());

									    System.out.println("end===========");

									  }

									  @Override

									  public void run() {

									    super.run();

									    System.out.println("run begin=======");

									    System.out.println("Thread.currentThread().getName=" + Thread.currentThread().getName());

									    System.out.println("this.getName()=" + this.getName());

									    System.out.println("run end==========");

									  }

									}

测试代码如下：

									public class ComplexCurrentThreadTest extends TestCase {

									  public void testRun() throws Exception {

									    ComplexCurrentThread thread = new ComplexCurrentThread();

									    thread.setName("byhieg");

									    thread.start();

									    Thread.sleep(3000);

									  }

									}

结果如下：

									begin=========

									Thread.currentThread().getName=main

									this.getName()=Thread-0

									end===========

									run begin=======

									Thread.currentThread().getName=byhieg

									this.getName()=byhieg

									run end==========

首先在创建对象的时候，构造器还是被main线程所执行，所以Thread.currentThread()得到的就是Main线程的名字，但是this方法指的是调用方法的那个对象，也就是ComplexCurrentThread的线程信息，还没有setName,所以是默认的名字。然后run方法无论是Thread.currentThread()还是this返回的都是设置了byhieg名字的线程信息。

所以Thread.currentThread指的是具体执行这个代码块的线程信息。构造器是main执行的，而run方法则是哪个线程start，哪个线程执行run。这么看来，this能得到的信息是不准确的，因为如果我们在run中执行了this.getName()，但是run方法却是由另一个线程start的，我们是无法通过this.getName得到运行run方法的新城的信息的。而且只有继承了Thread的类才能有getName等方法，这对于Java没有多继承的特性语言来说，是个灾难。所有后面凡是要得到线程的信息，我们都用Thread.currentThread()来调用API。

得到线程的ID

调用getID取得线程的唯一标识。这个和上面的getName用法一致，没什么好说的，可以直接看ExampleIdThread和他的测试类ExampleIdThreadTest。

判断线程是否存活

方法isAlive()的作用是测试线程是否处于活动状态。所谓活动状态，就是线程已经启动但是没有终止。即该线程start之后，被认为是存活的。

我们看一下具体的例子：

									public class AliveThread extends Thread{

									  @Override

									  public void run() {

									    super.run();

									    System.out.println("run方法中是否存活" + "  " + Thread.currentThread().isAlive());

									  }

									}

测试方法如下：

									public class AliveThreadTest extends TestCase {

									  public void testRun() throws Exception {

									    AliveThread thread = new AliveThread();

									    System.out.println("begin == " + thread.isAlive());

									    thread.start();

									    Thread.sleep(1000);

									    System.out.println("end ==" + thread.isAlive());

									    Thread.sleep(3000);

									  }

									}

结果如下：

									begin == false

									run方法中是否存活  true

									end ==false

我们可以发现在start之前，该线程被认为是没有存活，然后run的时候，是存活的，等run方法执行完，又被认为是不存活的。

如何停止线程

判断线程是否终止

JDK提供了一些方法来判断线程是否终止 —— isInterrupted()和interrupted()

停止线程的方式

这个是得到线程信息中比较重要的一个方法了，因为这个和终止线程的方法相关联。先说一下终止线程的几种方式：

等待run方法执行完
线程对象调用stop()
线程对象调用interrupt(),在该线程的run方法中判断是否终止，抛出一个终止异常终止。
线程对象调用interrupt(),在该线程的run方法中判断是否终止，以return语句结束。

第一种就不说了，第二种stop()方法已经废弃了，因为可能会产生如下原因：

强制结束线程，该线程应该做的清理工作，无法完成。
强制结束线程，该线程已操作的加锁对象强制解锁，造成数据不一致。

具体的例子可以看StopLockThread以及他的测试类StopLockThreadTest

第三种，是目前推荐的终止方法，调用interrupt,然后在run方法中判断是否终止。判断终止的方式有两种，一种是Thread类的静态方法interrupted(),另一种是Thread的成员方法isInterrupted()。这两个方法是有所区别的，第一个方法是会自动重置状态的，如果连续两次调用interrupted()，第一次如果是false,第二次一定是true。而isInterrupted()是不会的。

例子如下：

									public class ExampleInterruptThread extends Thread{

									  @Override

									  public void run() {

									    super.run();

									    try{

									      for(int i = 0 ; i < 50000000 ; i++){

									        if (interrupted()){

									          System.out.println("已经是停止状态，我要退出了");

									          throw new InterruptedException("停止.......");

									        }

									        System.out.println("i=" + (i + 1));

									      }

									    }catch (InterruptedException e){

									      System.out.println("顺利停止");

									    }

									  }

									}

测试的代码如下：

									public class ExampleInterruptThreadTest extends TestCase {

									  public void testRun() throws Exception {

									    ExampleInterruptThread thread = new ExampleInterruptThread();

									    thread.start();

									    Thread.sleep(1000);

									    thread.interrupt();

									  }

									}

第四种方法和第三种一样，唯一的区别就是将上面的代码中的抛出异常换成return,个人还是喜欢抛出异常，这里处理的形式就比较多，比如打印信息，处理资源关闭或者捕捉之后再重新向上层抛出。

注意一点，我们上面抛出的异常是InterruptedException，这里简单说一下可能产生这个异常的原因，在原有线程sleep的情况下，调用interrupt终止线程，或者先终止线程，再让线程sleep。

如何暂停线程

在JDK中提供了以下两个方法用来暂停线程和恢复线程。

suspend()——暂停线程
resume()——恢复线程

这两个方法和stop方法一样是被废弃的方法，其用法和stop一样，暴力的暂停线程和恢复线程。这两个方法之所以是废弃的主要由以下两个原因：

线程持有锁定的公共资源的情况下，一旦被暂停，则公共资源无法被其他线程所持有。
线程强制暂停，导致该线程执行的操作没有执行完全，这时访问该线程的数据会出现数据不一致。

线程的一些其他用法

线程的其他的一些基础用法如下：

线程让步
设置线程的优先级
守护线程

线程让步

JDK提供yield()方法来让线程放弃当前的CPU资源，将它让给其他的任务去占用CPU时间，但是这也是随机的事情，有可能刚放弃资源，又马上占用时间片了。

具体的例子可以参考ExampleYieldThread以及他的测试类ExampleYieldThreadTest

设置线程的优先级

我们可以设置线程的优先级来让CPU尽可能的将执行的资源给优先级高的线程。Java设置了1-10这10个优先级，又有三个静态变量来提供三个优先级：

									/**

									 * The minimum priority that a thread can have.

									 */

									public final static int MIN_PRIORITY = 1;

									/**

									 * The default priority that is assigned to a thread.

									 */

									public final static int NORM_PRIORITY = 5;

									/**

									 * The maximum priority that a thread can have.

									 */

									public final static int MAX_PRIORITY = 10;