Java线程

原创已于 2024-08-24 17:19:45 修改 · 719 阅读

12 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#java #开发语言

于 2024-08-24 15:52:42 首次发布

Java基础专栏收录该内容

3 篇文章

订阅专栏

文章目录

Java线程简介

Java线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。每个线程都有自己独立的执行路径，但共享进程的内存空间和其他资源。Java通过java.lang.Thread类来支持多线程编程。

创建线程的几种方式

继承Thread类
通过继承Thread类来创建线程是最基本的一种方式。需要创建一个继承自Thread类的子类，并重写其run方法。然后创建该子类的实例，调用其start方法来启动线程。

class MyThread extends Thread {  
    public void run() {  
        System.out.println("线程运行中");  
    }  
}  
  
public class ThreadExample {  
    public static void main(String[] args) {  
        MyThread t1 = new MyThread();  
        t1.start(); // 启动线程  
    }  
}

实现Runnable接口
实现Runnable接口是另一种创建线程的方式。你需要创建一个实现了Runnable接口的类的实例，此类的实例作为Thread对象的创建参数。然后，通过调用Thread类的start方法来启动线程。

class MyRunnable implements Runnable {  
    public void run() {  
        System.out.println("线程运行中");  
    }  
}  
  
public class RunnableExample {  
    public static void main(String[] args) {  
        Thread t1 = new Thread(new MyRunnable());  
        t1.start(); // 启动线程  
    }  
}

实现Callable接口
首先，我们定义一个实现了Callable接口的类或者匿名类。Callable接口类似于Runnable，但它允许任务完成时返回一个结果，并且可以抛出一个异常。

3.1 通过创建对象

import java.util.concurrent.Callable;  
  
public class MyCallableTask implements Callable<String> {  
    @Override  
    public String call() throws Exception {  
        // 模拟耗时任务  
        Thread.sleep(1000);  
        return "任务完成，返回结果";  
    }  
}

3.2 直接使用匿名类：

Callable<String> task = new Callable<String>() {  
    @Override  
    public String call() throws Exception {  
        Thread.sleep(1000);  
        return "任务完成，返回结果";  
    }  
};

3.3 使用Lambda表达式

Callable<String> task = () -> {  
    Thread.sleep(1000);  
    return "任务完成，返回结果";  
};

3.4 使用ExecutorService执行Callable

import java.util.concurrent.*;  
  
public class CallableExecutorExample {  
    public static void main(String[] args) {  
        // 创建一个ExecutorService  
        ExecutorService executor = Executors.newSingleThreadExecutor();  
  
        // 提交Callable任务到ExecutorService  
        Future<String> future = executor.submit(new MyCallableTask());  
  
        try {  
            // 等待Callable任务完成并获取结果  
            String result = future.get(); // 这会阻塞，直到任务完成  
            System.out.println(result);  
        } catch (InterruptedException | ExecutionException e) {  
            e.printStackTrace();  
        }  
  
        // 关闭ExecutorService  
        executor.shutdown();  
    }  
}

如果你使用的是匿名类或Lambda表达式定义的Callable，那么submit方法的调用方式会略有不同，但基本思路是一样的。
3.5 使用Lambda表达式的完整示例:

ExecutorService executor = Executors.newSingleThreadExecutor();  
  
Future<String> future = executor.submit(() -> {  
    Thread.sleep(1000);  
    return "任务完成，返回结果";  
});  
  
try {  
    String result = future.get();  
    System.out.println(result);  
} catch (InterruptedException | ExecutionException e) {  
    e.printStackTrace();  
}  
  
executor.shutdown();

4.使用Callable和Future（通过ExecutorService）

import java.util.concurrent.*;  
  
class MyCallable implements Callable<Integer> {  
    public Integer call() throws Exception {  
        return 123;  
    }  
}  
  
public class CallableExample {  
    public static void main(String[] args) throws ExecutionException, InterruptedException {  
        ExecutorService executor = Executors.newCachedThreadPool();  
        Future<Integer> future = executor.submit(new MyCallable());  
        System.out.println(future.get()); // 获取结果  
        executor.shutdown();  
    }  
}