Java中的线程-CSDN博客

本文链接：https://blog.csdn.net/XingZaiUnrivaled/article/details/140480283

一、介绍

什么是线程

线程是操作系统能够进行调度的最小单位。一个进程可以包含多个线程，这些线程共享进程的资源（如内存、文件句柄等），但可以独立执行。Java的多线程机制允许开发者在一个应用程序中同时执行多个线程。

线程的生命周期

线程的生命周期主要包括以下几个状态：

新建（New）： 线程被创建但尚未启动。
就绪（Runnable）： 线程已准备好运行，等待CPU的调度。
运行（Running）： 线程正在执行。
阻塞（Blocked）： 线程因为某种原因被阻塞，无法继续执行，如等待资源释放。
死亡（Dead）： 线程执行结束或因异常退出。

二、创建和启动线程

Java中创建和启动线程有两种主要方式：

方式一：继承`Thread`类

第一步：继承 Thread 类
第二步：重写 run() 方法
第三步：创建 Thread 子类对象
第四步：调用 start() 方法启动线程

重点是一定要使用start才能启动线程，如果只是使用run那就只是调用了run方法而不是启动线程。

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程
    }
}

class MyThread extends Thread {    //继承Thread
    @Override
    public void run() {
        // 线程要执行的任务
        System.out.println("MyThread is running.");
    }
}

start() 方法和 run() 方法区别

调用 run() 方法仅仅只是调用了一个子类中重写的父类方法，并没有真正开启一个新的线程，还是在当前线程运行，也就是 main 线程。

小总结

因为 Java 是单继承的，一个类继承了 Thread 类就不能继承其它类，所以通常不采用这个办法创建多线程。

方式二：实现`Runnable`接口

public class Main {
    public static void main(String[] args) {
        // 第四步：创建实现了 Runnable 接口的类的对象
        MyRunnable runnable = new MyRunnable();

        // 第五步：创建 Thread 类对象
        // 参数1：runnable 对象
        // 参数2：线程名称（可以不写）
        Thread thread = new Thread(runnable, "thread 2");

        // 第六步：调用 Thread 对象的 start() 方法启动线程
        thread.start();
    }
}

// 第一步：实现 Runnable 接口
class MyRunnable implements Runnable {

    // 第二步：实现 run() 方法
    @Override
    public void run() {
        // 第三步：编写线程中的逻辑代码
        // 线程要执行的任务
        System.out.println("MyRunnable is running.");
    }
}

方法三：方法二的变式

使用匿名内部类，就是直接匿名实现Runnable接口，当然也可以不用普通的匿名内部类，也可以使用lambda表达式来

public class Main {
    public static void main(String[] args) {
        // 第一步：以匿名内部类的方式创建 Runnable 接口类型的对象
        Runnable runnable = new Runnable() {
        @Override
        public void run() {
            // 第二步：编写线程中的逻辑代码
            System.out.println(Thread.currentThread().getName() + " is working");
            }
        };
    
        // 第三步：创建 Thread 类对象
        // 参数1：runnable 对象
        // 参数2：线程名称
        Thread thread = new Thread(runnable, "thread 003");

        // 第四步：调用 Thread 对象的 start() 方法启动线程
        thread.start();
    }
}

方法四：方法三的变式

有声明变量的形式

public class Main {
    public static void main(String[] args) {
        // 编写 Lambda 表达式的口诀：
        // 复制小括号
        // 写死右箭头
        // 落地大括号

        // 第一步：以匿名内部类的方式创建 Runnable 接口类型的对象
        Runnable runnable = () -> {
            // 第二步：编写线程中的逻辑代码
            System.out.println(Thread.currentThread().getName() + " is working");
        };

        // 第三步：创建 Thread 类对象
        // 参数1：runnable 对象
        // 参数2：线程名称
        Thread thread = new Thread(runnable, "thread 004");

        // 第四步：调用 Thread 对象的 start() 方法启动线程
        thread.start();;
    }
}

不声明变量形式

public class Main {
    public static void main(String[] args) {
        // 第一步：创建 Thread 类对象并调用 start() 方法启动线程
        // 参数1：以Lambda 表达式形式创建的 runnable 对象
        // 参数2：线程名称
        new Thread(() -> {
            // 第二步：编写线程中的逻辑代码
            System.out.println(Thread.currentThread().getName() + " is working");
        }, "thread 005").start();
    }
}

三、线程的控制

线程的暂停与恢复

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

class MyThread extends Thread {
    public void run() {
        try {
            for (int i = 0; i < 5; i++) {
                System.out.println("MyThread is running: " + i);
                Thread.sleep(1000); // 线程休眠1秒
            }
        } catch (InterruptedException e) {
            System.out.println("Thread interrupted.");
        }
    }
}

线程的优先级

每个线程都有一个优先级，优先级较高的线程会有更大的几率被操作系统调度执行。可以使用setPriority方法设置线程的优先级。

thread.setPriority(Thread.MAX_PRIORITY); // 设置最高优先级

线程的同步

为了避免多个线程同时访问共享资源而导致的数据不一致问题，需要对资源访问进行同步。

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        MyThread thread1 = new MyThread(counter);
        MyThread thread2 = new MyThread(counter);

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Count: " + counter.getCount()); // 应该输出2000
    }
}

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

class MyThread extends Thread {
    private Counter counter;

    public MyThread(Counter counter) {
        this.counter = counter;
    }

    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }
}

四、高级主题

线程池

Java提供了ExecutorService接口和其实现类（如ThreadPoolExecutor）来管理线程池，从而提高线程管理的效率。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        
        for (int i = 0; i < 5; i++) {
            executor.execute(new MyRunnable());
        }
        
        executor.shutdown();
    }
}

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("MyRunnable is running.");
    }
}

Callable和Future

Callable接口类似于Runnable，但它可以返回结果或抛出异常。Future接口用于表示异步计算的结果。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        
        Future<Integer> future = executor.submit(new MyCallable());
        
        try {
            Integer result = future.get(); // 获取结果（阻塞等待）
            System.out.println("Result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        
        executor.shutdown();
    }
}

class MyCallable implements Callable<Integer> {
    public Integer call() {
        return 123;
    }
}

这就是Java的线程基础，大家跑跑代码应该就能理解起来了。那如果对你有帮助的话不要忘记点赞和收藏。