Java多线程 | 操作线程的方法详解

一、线程的启动

1.1 start()方法

  无论是通过继承Thread类还是实现Runnable接口，线程的启动都需要调用start()方法。

// 定义一个实现Runnable接口的自定义线程类
public class MyRunnable implements Runnable {@Overridepublic void run() {// 线程执行的代码逻辑}
}// 在主线程中创建并启动自定义线程
public class Main {public static void main(String[] args) {// 创建线程对象Thread thread = new Thread(new MyRunnable());// 启动线程thread.start();}
}

二、线程的休眠与中断

2.1 Thread.sleep()方法

Thread.sleep()方法用于使当前线程休眠一段时间。它接受一个以毫秒为单位的参数，表示线程休眠的时间，调用这个方法必须要声明或捕捉异常。

        try {// 线程休眠2秒Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("线程休眠结束");

2.2 interrupt()方法

  Thread类的interrupt()方法用于中断线程。当一个线程被中断时，它的中断状态将被设置为true（默认是 flase），设置后不一定真的中断，看jvm如何选择，我们把握不了。

  调用中断方法也要声明或捕捉异常：InterruptedException

  可以通过Thread类的isInterrupted()方法来检查线程的中断状态。

public class MyThread implements Runnable {@Overridepublic void run() {while (!Thread.currentThread().isInterrupted()) {System.out.println("线程执行中");}System.out.println("线程被中断");}
}public class Main {public static void main(String[] args) {// 创建线程对象Thread thread = new Thread(new MyThread());// 启动线程thread.start();// 中断子线程try {thread.interrupt();} catch (InterruptedException e) {e.printStackTrace();}}
}

三、线程的等待与唤醒

  线程的等待与唤醒是多线程编程中常用的一种机制，它允许线程在满足特定条件之前等待，然后在条件满足时被唤醒继续执行。Java提供了多种方式来实现线程的等待与唤醒。

3.1 wait()方法

  Object类中的wait()方法用于使当前线程等待，并释放当前线程持有的锁。wait()方法需要在synchronized块内部调用，以确保线程在等待前释放锁。

  调用wait方法使线程进入等到状态后，不会自动醒过来，需要手动让线程苏醒。

public class MyThread implements Runnable {final Object lock = new Object(); // 用于同步的对象@Overridepublic void run() {synchronized (lock) {// 线程等待，并释放锁lock.wait();}}
}

3.2 Object类的notify()和notifyAll()方法

  Object类中的notify()方法用于唤醒在相同对象上调用wait()方法而等待的单个线程，而notifyAll()方法用于唤醒所有在相同对象上调用wait()方法而等待的线程。

public class MyThread implements Runnable {private final Object lock;public MyThread(Object lock) {this.lock = lock;}@Overridepublic void run() {synchronized (lock) {try {// 线程等待，并释放锁lock.wait();// 线程被唤醒后执行其他操作System.out.println("线程被唤醒");} catch (InterruptedException e) {e.printStackTrace();}}}
}public class Main {public static void main(String[] args) {Object lock = new Object();// 创建自定义线程对象MyThread myThread1 = new MyThread(lock);MyThread myThread2 = new MyThread(lock);// 创建线程对象Thread thread1 = new Thread(myThread1);Thread thread2 = new Thread(myThread2);// 启动线程thread1.start();thread2.start();// 主线程休眠1秒后唤醒所有子线程try {Thread.sleep(1000);synchronized (lock) {lock.notifyAll();}} catch (InterruptedException e) {e.printStackTrace();}}
}

3.3 await()和signal()方法

  Condition接口的await()方法可以使线程等待，并释放当前线程持有的锁。当其他线程调用signal()或signalAll()方法时，等待的线程将被唤醒。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class MyThread implements Runnable {private final Lock lock;private final Condition condition;public MyThread(Lock lock, Condition condition) {this.lock = lock;this.condition = condition;}@Overridepublic void run() {lock.lock();try {// 线程等待，并释放锁condition.await();// 线程被唤醒后执行其他操作System.out.println("线程被唤醒");} catch (InterruptedException e) {e.printStackTrace();} finally {lock.unlock();}}
}public class Main {public static void main(String[] args) {Lock lock = new ReentrantLock();Condition condition = lock.newCondition();// 创建自定义线程对象MyThread myThread = new MyThread(lock, condition);// 创建线程对象Thread thread = new Thread(myThread);// 启动线程thread.start();// 主线程休眠1秒后唤醒子线程try {Thread.sleep(1000);lock.lock();condition.signalAll();lock.unlock();} catch (InterruptedException e) {e.printStackTrace();}}
}

3.4 使用join()方法等待线程执行完成

  join()方法可以使一个线程等待另一个线程执行完成。当调用线程的join()方法时，调用线程将被阻塞，直到被调用的线程执行完成。下面是使用join()方法等待线程执行完成的示例：

public class MyThread implements Runnable {@Overridepublic void run() {System.out.println("子线程开始执行");try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("子线程执行完成");}
}public class Main {public static void main(String[] args) {// 创建自定义线程对象MyThread myThread = new MyThread();// 创建线程对象Thread thread = new Thread(myThread);// 启动线程thread.start();// 主线程调用join()方法等待子线程执行完成try {thread.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("主线程继续执行");}
}

四、线程的状态控制与管理

4.1 线程的优先级设置

  线程的优先级用于指定线程在竞争CPU资源时的相对重要性。Java中使用整数表示线程的优先级，范围从1到10，其中1为最低优先级，10为最高优先级。可以使用setPriority()方法设置线程的优先级，使用getPriority()方法获取线程的优先级。

  注意：设置了高的优先级只是让线程获取资源的概率增大。

public class Main {public static void main(String[] args) {// 创建线程对象Thread thread = new Thread(() -> {System.out.println("线程执行中");});// 设置线程优先级为最高thread.setPriority(Thread.MAX_PRIORITY);// 获取线程优先级int priority = thread.getPriority();System.out.println("线程优先级：" + priority);// 启动线程thread.start();}
}

4.2 线程的守护与非守护状态

  线程可以分为守护线程和非守护线程。当只剩下守护线程运行时，JVM会退出。可以使用setDaemon()方法将线程设置为守护线程，使用isDaemon()方法判断线程是否为守护线程。

  守护线程的优先级低，这是因为守护线程的业务是不紧急的，像JVM垃圾回收线程就被设置成了守护线程。

public class Main {public static void main(String[] args) {// 创建线程对象Thread thread = new Thread(() -> {System.out.println("线程执行中");});// 设置线程为守护线程thread.setDaemon(true);// 判断线程是否为守护线程boolean isDaemon = thread.isDaemon();System.out.println("线程是否为守护线程：" + isDaemon);// 启动线程thread.start();}
}

五、其他常用的线程操作方法

5.1 使用yield()方法让出CPU资源

  yield()方法是一个静态方法，用于提示线程调度器将当前线程让出CPU资源，使得其他具有相同优先级的线程有机会执行。调用yield()方法后，当前线程会从运行状态变为就绪状态，然后等待线程调度器重新调度。

public class Main {public static void main(String[] args) {// 创建线程对象Thread thread1 = new Thread(() -> {for (int i = 0; i < 5; i++) {System.out.println("线程1执行中");Thread.yield();}});Thread thread2 = new Thread(() -> {for (int i = 0; i < 5; i++) {System.out.println("线程2执行中");Thread.yield();}});// 启动线程thread1.start();thread2.start();}
}

  在上面的示例中，创建了两个线程对象thread1和thread2，它们分别输出"线程1执行中"和"线程2执行中"。在每次循环中，通过调用yield()方法让出CPU资源，使得两个线程可以交替执行。

5.2 使用isAlive()方法判断线程是否存活

  isAlive()方法用于判断线程是否存活，即线程是否已经启动且尚未终止。如果线程存活返回true，否则返回false。

public class Main {public static void main(String[] args) {// 创建线程对象Thread thread = new Thread(() -> {System.out.println("线程执行中");});// 启动线程thread.start();// 判断线程是否存活boolean isAlive = thread.isAlive();System.out.println("线程是否存活：" + isAlive);}
}