线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程,但轻量进程更多指内核线程,而把用户线程称为线程。本文主要介绍Java 线程(Thread)。

1、Java 线程(Thread)

线程允许程序通过同时执行多项操作来更有效地运行。

线程可用于在后台执行复杂的任务,而不会中断主程序。

2、创建线程Thread

有两种创建线程的方法。

可以通过扩展Thread类并覆盖其run()方法来创建它:

使用extends语法

public class Main extends Thread {
  public void run() {
    System.out.println("在线程中运行代码");
  }
}

创建线程的另一种方法是实现Runnable接口:

使用implement语法

public class Main implements Runnable {
  public void run() {
    System.out.println("在线程中运行代码");
  }
}

3、运行线程

如果该类使用extends扩展了Thread类,则可以通过创建该类的实例并调用其start()方法来运行该线程:

例如

public class Main extends Thread {
  public static void main(String[] args) {
    Main thread = new Main();
    thread.start();
    System.out.println("thread线程外运行");
  }
  public void run() {
    System.out.println("thread线程中运行");
  }
}

如果该类使用implements实现了Runnable接口,则可以通过将类的实例传递给Thread对象的构造函数,然后调用该线程的start()方法:

例如

public class Main implements Runnable {
  public static void main(String[] args) {
    Main obj = new Main();
    Thread thread = new Thread(obj);
    thread.start();
    System.out.println("thread线程外运行");
  }
  public void run() {
    System.out.println("thread线程中运行");
  }
}

使用extends的线程与使用implements的线程之间的区别主要区别在于,当一个类扩展Thread类时,不能扩展任何其他类,但是通过实现Runnable接口,可以从 另一个类,例如classMyClass扩展实现了Runnable接的OtherClass

4、线程并发问题

因为线程与程序的其他部分同时运行,所以无法知道代码将以什么顺序运行。当线程和主程序正在读取和写入相同的变量时,这些值是不可预测的。由此产生的问题称为并发问题。

例如:

一个代码示例,其中amount的值不可预测:

public class Main {
  public static void main(String[] args) {
  MyThread thread = new MyThread();
  thread.start();

  // 更新输出值
  System.out.println("Main begin: " + MyThread.amount);
  MyThread.amount++;
  System.out.println("Main end: " + MyThread.amount);
 }
  
}

class MyThread extends Thread {
  public static int amount = 0;
  public  void run() {
    amount++;
  }
}

为避免并发问题,最好在线程之间共享尽可能少的属性。 如果需要共享属性,则一种可能的解决方案是使用线程的isAlive()方法在使用任何可以更改的属性之前检查线程是否已完成运行。

例如:

使用isAlive()防止并发问题:

public class Main {
  public static void main(String[] args) {
  MyThread thread = new MyThread();
  thread.start();
   // 等待线程运行完成
    while(thread.isAlive()) {
    System.out.println("Waiting...");
  }
  // 更新输出值
  System.out.println("Main begin: " + MyThread.amount);
  MyThread.amount++;
  System.out.println("Main end: " + MyThread.amount);
 }
  
}
class MyThread extends Thread {
  public static int amount = 0;
  public  void run() {
    amount++;
  }
}

另外还可以加锁的方式,解决并发问题,例如,Java中线程的共享互斥操作,会使用synchronized关键字。每个锁在同一时刻,只能由一个线程持有。例如

public class Main {
  public static void main(String[] args) {
  MyThread thread = new MyThread();
  thread.start();
  // 更新并输出值 
  synchronized (MyThread.class) {
  System.out.println("Main begin: " + MyThread.amount);
  MyThread.amount++;
  System.out.println("Main end: " + MyThread.amount);
  }
 }
  
}

class MyThread extends Thread {
  public static int amount = 0;
  public  void run() {
  synchronized (MyThread.class) {
    amount++;
   }
  }
}

注意synchronized方法或声明执行期间,如程序遇到任何异常或return,线程都会释放锁。