本文共 3490 字，大约阅读时间需要 11 分钟。

Java高级编程01

Java多线程编程

Java中的多线程编程可以通过两种方式实现：继承Thread类或实现Runnable接口。Thread类提供了一个基础的线程结构，而Runnable接口则允许更灵活地定义线程任务。对于大多数场景，建议使用Runnable接口，因为它避免了单继承的局限性，并支持更灵活的功能扩展。

继承Thread类

要实现多线程编程，首先需要继承Thread类。通过覆盖Thread类中的run()方法，可以定义线程的执行逻辑。例如：

public class MyThread extends Thread {    private String title;    public MyThread(String title) {        this.title = title;    }    @Override    public void run() {        for (int i = 0; i < 5; i++) {            System.out.println(title + "运行，i=" + i);        }    }}

实现Runnable接口

另一种实现多线程的方式是通过实现Runnable接口。Runnable接口定义了一个run()方法，用于执行线程任务。与Thread类继承相比，Runnable接口更灵活，因为它允许单继承。

public class MyThread implements Runnable {    private String title;    public MyThread(String title) {        this.title = title;    }    @Override    public void run() {        for (int i = 0; i < 5; i++) {            System.out.println(title + "运行，i=" + i);        }    }}

Runnable与Callable的区别

Runnable接口和Callable接口都是用于定义多线程任务，但有以下区别：

• Runnable：没有返回值，适用于不需要返回结果的任务。
• Callable：可以有返回值，适用于需要获取结果的任务。

Thread与Runnable的关系

Thread类和Runnable接口之间存在关联。Thread类本身实现了Runnable接口，这意味着即使你继承Thread类，你仍然可以将其视为一个Runnable对象。线程的启动和管理仍然依赖Thread类中的start()方法。

Callable接口

从JDK 1.5开始，Callable接口提供了一种更灵活的多线程任务定义方式。与Runnable不同，Callable接口可以返回一个值。

public class MyThread implements Callable
   
     {    @Override    public String call() throws Exception {        for (int i = 0; i < 5; i++) {            System.out.println("运行，i=" + i);        }        return "程序执行完毕";    }}
   

线程运行状态

线程在运行过程中会经历多个状态：

• 新态：线程被创建但尚未启动。
• 就绪态：线程准备好执行，但尚未获得CPU。
• 运行态：线程正在执行CPU instructions。
• 阻塞态：线程在等待I/O操作或其他系统资源。
• 终止态：线程的执行完成或被强制终止。

线程常用操作方法

• 线程的命名：可以通过构造方法或setName()方法设置线程名，默认名称是Thread-+数字。
• 线程的取得：可以通过currentThread()方法获取当前线程。
• 主线程：主线程负责执行程序的整体流程，子线程负责执行长时间或 Blocking操作。

线程休眠

线程可以通过sleep()方法暂缓执行。需要注意的是，sleep()方法可能抛出InterruptedException异常。

public class MyThread implements Runnable {    @Override    public void run() {        for (int i = 0; i < 10; i++) {            System.out.println(Thread.currentThread().getName() + "、x=" + x);            try {                Thread.sleep(100);            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }}

线程中断

可以通过interrupt()方法中断线程。中断后，线程会抛出InterruptedException异常。

public class MyThread implements Runnable {    @Override    public void run() {        System.out.println("该睡觉了");        try {            Thread.sleep(10000);        } catch (InterruptedException e) {            System.out.println("谁打扰了我的睡眠");            e.printStackTrace();        }    }}

线程强制运行

可以通过join()方法等待线程完成。强制执行后，线程会独占资源直到完成。

public class MyThread implements Runnable {    @Override    public void run() {        for (int i = 0; i < 100; i++) {            if (i == 3) {                mainThread.join();            }            System.out.println(Thread.currentThread().getName() + "执行、i=" + i);        }    }}

线程礼让

可以通过yield()方法让线程暂时让出CPU，允许其他线程执行。

public class MyThread implements Runnable {    @Override    public void run() {        for (int i = 0; i < 100; i++) {            if (i % 3 == 0) {                Thread.yield();                System.out.println("***玩耍的线程礼让了资源***");            }            System.out.println(Thread.currentThread().getName() + "执行、i=" + i);        }    }}

线程优先级

线程的优先级可以通过setPriority()方法设置，优先级越高，线程执行的优先级越高。默认优先级为5（中等优先级）。

public class MyThread implements Runnable {    @Override    public void run() {        for (int i = 0; i < 10; i++) {            System.out.println(Thread.currentThread().getName() + "、x=" + i);        }    }}