Java多线程实现之Runnable接口深度解析

news2025/6/10 13:09:32

Java多线程实现之Runnable接口深度解析

    • 一、Runnable接口概述
      • 1.1 接口定义
      • 1.2 与Thread类的关系
      • 1.3 使用Runnable接口的优势
    • 二、Runnable接口的基本实现方式
      • 2.1 传统方式实现Runnable接口
      • 2.2 使用匿名内部类实现Runnable接口
      • 2.3 使用Lambda表达式实现Runnable接口
    • 三、Runnable接口的高级应用
      • 3.1 线程间资源共享
      • 3.2 与线程池结合使用
      • 3.3 实现带返回值的任务（结合Future）
    • 四、Runnable接口与Thread类的对比
      • 4.1 主要区别
      • 4.2 如何选择
    • 五、Runnable接口的实战案例
      • 5.1 多线程下载器
      • 5.2 定时任务执行器
      • 5.3 生产者-消费者模型
    • 六、Runnable接口的注意事项
      • 6.1 线程安全问题
      • 6.2 异常处理
      • 6.3 线程中断
      • 6.4 资源管理
    • 总结

Java除了可以继承Thread类来创建和管理线程，还可以通过实现Runnable接口来实现多线程。本文我将详细介绍Runnable接口的原理、实现方式、高级应用以及与Thread类的对比，并通过多个实战案例展示其在实际开发中的应用场景，帮你全面掌握Runnable接口的使用。

一、Runnable接口概述

1.1 接口定义

Runnable是Java中的一个函数式接口，位于java.lang包下，其定义如下：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

该接口仅包含一个抽象方法run()，用于定义线程的执行逻辑。由于是函数式接口，因此可以使用Lambda表达式来简化实现。

1.2 与Thread类的关系

虽然Thread类是Java中线程的核心类，但通过实现Runnable接口来创建线程是更推荐的方式。Thread类本身也实现了Runnable接口，其构造函数可以接受一个Runnable对象作为参数，从而将线程的创建和任务的定义分离。

1.3 使用Runnable接口的优势

  • 避免单继承限制：Java不支持多重继承，实现Runnable接口的类还可以继承其他类
  • 更灵活的资源共享：多个线程可以共享同一个Runnable实例，便于实现资源共享
  • 代码解耦：将线程的创建和任务逻辑分离，提高代码的可维护性和可测试性
  • 更好的扩展性：可以与线程池等高级API配合使用

二、Runnable接口的基本实现方式

2.1 传统方式实现Runnable接口

class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "执行: " + i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class RunnableExample {
    public static void main(String[] args) {
        // 创建Runnable实例
        MyRunnable myRunnable = new MyRunnable();
        
        // 创建并启动线程
        Thread thread1 = new Thread(myRunnable, "线程1");
        Thread thread2 = new Thread(myRunnable, "线程2");
        
        thread1.start();
        thread2.start();
    }
}

2.2 使用匿名内部类实现Runnable接口

public class AnonymousRunnableExample {
    public static void main(String[] args) {
        // 使用匿名内部类创建Runnable实例
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName() + "执行: " + i);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        
        // 创建并启动线程
        Thread thread = new Thread(runnable, "匿名线程");
        thread.start();
    }
}

2.3 使用Lambda表达式实现Runnable接口

public class LambdaRunnableExample {
    public static void main(String[] args) {
        // 使用Lambda表达式创建Runnable实例
        Runnable runnable = () -> {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + "执行: " + i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        
        // 创建并启动线程
        Thread thread = new Thread(runnable, "Lambda线程");
        thread.start();
        
        // 更简洁的写法
        new Thread(() -> {
            System.out.println("极简线程执行");
        }, "极简线程").start();
    }
}

三、Runnable接口的高级应用

3.1 线程间资源共享

通过实现Runnable接口，可以轻松实现多个线程共享同一个资源：

class SharedResource implements Runnable {
    private int count = 0;
    
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            // 同步方法保证线程安全
            increment();
        }
        System.out.println(Thread.currentThread().getName() + "执行完毕，count=" + count);
    }
    
    public synchronized void increment() {
        count++;
    }
}

public class ResourceSharingExample {
    public static void main(String[] args) throws InterruptedException {
        // 创建共享资源实例
        SharedResource sharedResource = new SharedResource();
        
        // 创建并启动多个线程共享同一个资源
        Thread thread1 = new Thread(sharedResource, "线程1");
        Thread thread2 = new Thread(sharedResource, "线程2");
        
        thread1.start();
        thread2.start();
        
        // 等待两个线程执行完毕
        thread1.join();
        thread2.join();
        
        System.out.println("最终count值: " + sharedResource.count);
    }
}

3.2 与线程池结合使用

Runnable接口是线程池（ExecutorService）的主要任务类型：

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);
        
        // 提交多个Runnable任务到线程池
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("线程池中的线程执行任务: " + taskId);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        
        // 关闭线程池
        executor.shutdown();
    }
}

3.3 实现带返回值的任务（结合Future）

虽然Runnable接口的run()方法没有返回值，但可以通过Future和Callable接口实现带返回值的任务：

import java.util.concurrent.*;

public class FutureExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        
        // 创建一个Callable任务
        Callable<Integer> callable = () -> {
            Thread.sleep(2000);
            return 100;
        };
        
        // 提交任务并获取Future
        Future<Integer> future = executor.submit(callable);
        
        // 获取任务结果（会阻塞直到任务完成）
        System.out.println("任务结果: " + future.get());
        
        executor.shutdown();
    }
}

四、Runnable接口与Thread类的对比

4.1 主要区别

特性Runnable接口Thread类
实现方式实现Runnable接口继承Thread类
单继承限制无，可以继承其他类受Java单继承限制
资源共享天然支持，多个线程可共享同一个Runnable实例需通过静态变量等方式实现资源共享
代码结构任务逻辑与线程创建分离，解耦性好任务逻辑与线程创建耦合在一起
扩展性可与线程池等高级API更好配合直接使用，扩展性较差

4.2 如何选择

  • 推荐使用Runnable接口：在大多数情况下，实现Runnable接口是更好的选择，尤其是需要资源共享或与线程池配合使用时
  • 使用Thread类的场景：当需要重写Thread类的其他方法（如start()、interrupt()等）时，可以考虑继承Thread类，但这种场景非常少见

五、Runnable接口的实战案例

5.1 多线程下载器

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;

class DownloadTask implements Runnable {
    private String url;
    private String outputFile;
    
    public DownloadTask(String url, String outputFile) {
        this.url = url;
        this.outputFile = outputFile;
    }
    
    @Override
    public void run() {
        try (InputStream in = new URL(url).openStream();
             OutputStream out = new FileOutputStream(outputFile)) {
            
            byte[] buffer = new byte[4096];
            int bytesRead;
            while ((bytesRead = in.read(buffer)) != -1) {
                out.write(buffer, 0, bytesRead);
            }
            
            System.out.println("下载完成: " + outputFile);
        } catch (IOException e) {
            System.err.println("下载失败: " + outputFile + ", 错误: " + e.getMessage());
        }
    }
}

public class MultiThreadDownloader {
    public static void main(String[] args) {
        String[] urls = {
            "https://example.com/file1.txt",
            "https://example.com/file2.txt",
            "https://example.com/file3.txt"
        };
        
        String[] outputFiles = {
            "downloads/file1.txt",
            "downloads/file2.txt",
            "downloads/file3.txt"
        };
        
        // 创建并启动多个下载线程
        for (int i = 0; i < urls.length; i++) {
            Thread thread = new Thread(new DownloadTask(urls[i], outputFiles[i]));
            thread.start();
        }
    }
}

5.2 定时任务执行器

import java.util.Date;

class ScheduledTask implements Runnable {
    private String taskName;
    
    public ScheduledTask(String taskName) {
        this.taskName = taskName;
    }
    
    @Override
    public void run() {
        System.out.println(new Date() + " - 执行任务: " + taskName);
        try {
            // 模拟任务执行时间
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(new Date() + " - 任务" + taskName + "执行完毕");
    }
}

public class ScheduledTaskExecutor {
    public static void main(String[] args) {
        // 创建并启动定时任务线程
        Thread task1 = new Thread(new ScheduledTask("数据库备份"));
        Thread task2 = new Thread(new ScheduledTask("日志清理"));
        
        // 设置任务执行间隔
        Thread scheduler1 = new Thread(() -> {
            while (true) {
                task1.run();
                try {
                    // 每天执行一次
                    Thread.sleep(24 * 60 * 60 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
        Thread scheduler2 = new Thread(() -> {
            while (true) {
                task2.run();
                try {
                    // 每周执行一次
                    Thread.sleep(7 * 24 * 60 * 60 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
        scheduler1.start();
        scheduler2.start();
    }
}

5.3 生产者-消费者模型

import java.util.LinkedList;
import java.util.Queue;

class SharedQueue {
    private Queue<Integer> queue = new LinkedList<>();
    private static final int MAX_SIZE = 5;
    
    public synchronized void produce(int item) throws InterruptedException {
        // 队列满时等待
        while (queue.size() == MAX_SIZE) {
            wait();
        }
        
        queue.add(item);
        System.out.println("生产者生产: " + item);
        
        // 通知消费者
        notifyAll();
    }
    
    public synchronized int consume() throws InterruptedException {
        // 队列空时等待
        while (queue.isEmpty()) {
            wait();
        }
        
        int item = queue.poll();
        System.out.println("消费者消费: " + item);
        
        // 通知生产者
        notifyAll();
        return item;
    }
}

class Producer implements Runnable {
    private SharedQueue queue;
    
    public Producer(SharedQueue queue) {
        this.queue = queue;
    }
    
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                queue.produce(i);
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Consumer implements Runnable {
    private SharedQueue queue;
    
    public Consumer(SharedQueue queue) {
        this.queue = queue;
    }
    
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                queue.consume();
                Thread.sleep(800);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ProducerConsumerExample {
    public static void main(String[] args) {
        SharedQueue queue = new SharedQueue();
        
        // 创建生产者和消费者线程
        Thread producerThread = new Thread(new Producer(queue));
        Thread consumerThread = new Thread(new Consumer(queue));
        
        // 启动线程
        producerThread.start();
        consumerThread.start();
    }
}

六、Runnable接口的注意事项

6.1 线程安全问题

当多个线程共享同一个Runnable实例时，需要特别注意线程安全问题。可以使用synchronized关键字、Lock接口或原子类（如AtomicInteger）来保证线程安全。

6.2 异常处理

Runnable接口的run()方法不允许抛出受检异常，因此需要在方法内部进行异常处理。如果需要处理异常并返回结果，可以考虑使用Callable接口。

6.3 线程中断

在Runnable实现中，应该正确处理线程中断请求。可以通过检查Thread.interrupted()状态或捕获InterruptedException来实现：

@Override
public void run() {
    while (!Thread.interrupted()) {
        // 线程执行逻辑
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            // 恢复中断状态
            Thread.currentThread().interrupt();
            break;
        }
    }
}

6.4 资源管理

确保在Runnable任务中正确管理资源，如文件句柄、网络连接等。可以使用try-with-resources语句来自动关闭资源。

总结

Runnable接口是Java多线程编程的重要组成部分，通过实现该接口可以灵活地定义线程任务，并与Java的线程管理机制无缝结合。与继承Thread类相比，实现Runnable接口具有更好的扩展性和资源共享能力，是更推荐的多线程实现方式。

若这篇内容帮到你，动动手指支持下！关注不迷路，干货持续输出！
ヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉ

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2406657.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

李沐--动手学深度学习--GRU

李沐--动手学深度学习--GRU

1.GRU从零开始实现 #9.1.2GRU从零开始实现 import torch from torch import nn from d2l import torch as d2l#首先读取 8.5节中使用的时间机器数据集 batch_size,num_steps 32,35 train_iter,vocab d2l.load_data_time_machine(batch_size,num_steps) #初始化模型参数 def …
阅读更多...
EasyRTC音视频实时通话功能在WebRTC与智能硬件整合中的应用与优势

EasyRTC音视频实时通话功能在WebRTC与智能硬件整合中的应用与优势

一、WebRTC与智能硬件整合趋势​ 随着物联网和实时通信需求的爆发式增长&#xff0c;WebRTC作为开源实时通信技术&#xff0c;为浏览器与移动应用提供免插件的音视频通信能力&#xff0c;在智能硬件领域的融合应用已成必然趋势。智能硬件不再局限于单一功能&#xff0c;对实时…
阅读更多...
【版本控制】GitHub Desktop 入门教程与开源协作全流程解析

【版本控制】GitHub Desktop 入门教程与开源协作全流程解析

目录 0 引言1 GitHub Desktop 入门教程1.1 安装与基础配置1.2 核心功能使用指南仓库管理日常开发流程分支管理 2 GitHub 开源协作流程详解2.1 Fork & Pull Request 模型2.2 完整协作流程步骤步骤 1: Fork&#xff08;创建个人副本&#xff09;步骤 2: Clone&#xff08;克隆…
阅读更多...
Android屏幕刷新率与FPS(Frames Per Second) 120hz

Android屏幕刷新率与FPS(Frames Per Second) 120hz

Android屏幕刷新率与FPS(Frames Per Second) 120hz 屏幕刷新率是屏幕每秒钟刷新显示内容的次数&#xff0c;单位是赫兹&#xff08;Hz&#xff09;。 60Hz 屏幕&#xff1a;每秒刷新 60 次&#xff0c;每次刷新间隔约 16.67ms 90Hz 屏幕&#xff1a;每秒刷新 90 次&#xff0c;…
阅读更多...
【PX4飞控】mavros gps相关话题分析，经纬度海拔获取方法，卫星数锁定状态获取方法

【PX4飞控】mavros gps相关话题分析，经纬度海拔获取方法，卫星数锁定状态获取方法

使用 ROS1-Noetic 和 mavros v1.20.1&#xff0c; 携带经纬度海拔的话题主要有三个&#xff1a; /mavros/global_position/raw/fix/mavros/gpsstatus/gps1/raw/mavros/global_position/global 查看 mavros 源码&#xff0c;来分析他们的发布过程。发现前两个话题都对应了同一…
阅读更多...
ubuntu中安装conda的后遗症

ubuntu中安装conda的后遗症

缘由: 在编译rk3588的sdk时&#xff0c;遇到编译buildroot失败&#xff0c;提示如下&#xff1a; 提示缺失expect&#xff0c;但是实测相关工具是在的&#xff0c;如下显示&#xff1a; 然后查找借助各个ai工具&#xff0c;重新安装相关的工具&#xff0c;依然无解。 解决&am…
阅读更多...
【Java多线程从青铜到王者】单例设计模式(八)

【Java多线程从青铜到王者】单例设计模式(八)

wait和sleep的区别 我们的wait也是提供了一个还有超时时间的版本&#xff0c;sleep也是可以指定时间的&#xff0c;也就是说时间一到就会解除阻塞&#xff0c;继续执行 wait和sleep都能被提前唤醒(虽然时间还没有到也可以提前唤醒)&#xff0c;wait能被notify提前唤醒&#xf…
阅读更多...
react菜单，动态绑定点击事件，菜单分离出去单独的js文件，Ant框架

react菜单，动态绑定点击事件，菜单分离出去单独的js文件，Ant框架

1、菜单文件treeTop.js // 顶部菜单 import { AppstoreOutlined, SettingOutlined } from ant-design/icons; // 定义菜单项数据 const treeTop [{label: Docker管理,key: 1,icon: <AppstoreOutlined />,url:"/docker/index"},{label: 权限管理,key: 2,icon:…
阅读更多...
VSCode 使用CMake 构建 Qt 5 窗口程序

VSCode 使用CMake 构建 Qt 5 窗口程序

首先，目录结构如下图： 运行效果： cmake -B build cmake --build build 运行： windeployqt.exe F:\testQt5\build\Debug\app.exe main.cpp #include "mainwindow.h"#include <QAppli
阅读更多...
Win系统权限提升篇UAC绕过DLL劫持未引号路径可控服务全检项目

Win系统权限提升篇UAC绕过DLL劫持未引号路径可控服务全检项目

应用场景&#xff1a; 1、常规某个机器被钓鱼后门攻击后&#xff0c;我们需要做更高权限操作或权限维持等。 2、内网域中某个机器被钓鱼后门攻击后&#xff0c;我们需要对后续内网域做安全测试。 #Win10&11-BypassUAC自动提权-MSF&UACME 为了远程执行目标的exe或者b…
阅读更多...
Qwen系列之Qwen3解读：最强开源模型的细节拆解

Qwen系列之Qwen3解读：最强开源模型的细节拆解

文章目录 1.1分钟快览2.模型架构2.1.Dense模型2.2.MoE模型 3.预训练阶段3.1.数据3.2.训练3.3.评估 4.后训练阶段S1: 长链思维冷启动S2: 推理强化学习S3: 思考模式融合S4: 通用强化学习 5.全家桶中的小模型训练评估评估数据集评估细节评估效果弱智评估和民间Arena 分析展望 如果…
阅读更多...
RushDB开源程序 是现代应用程序和 AI 的即时数据库。建立在 Neo4j 之上

RushDB开源程序 是现代应用程序和 AI 的即时数据库。建立在 Neo4j 之上

一、软件介绍 文末提供程序和源码下载 RushDB 改变了您处理图形数据的方式 — 不需要 Schema&#xff0c;不需要复杂的查询&#xff0c;只需推送数据即可。 二、Key Features ✨ 主要特点 Instant Setup: Be productive in seconds, not days 即时设置 &#xff1a;在几秒钟…
阅读更多...
表单设计器拖拽对象时添加属性

表单设计器拖拽对象时添加属性

背景&#xff1a;因为项目需要。自写设计器。遇到的坑在此记录 使用的拖拽组件时vuedraggable。下面放上局部示例截图。 坑1。draggable标签在拖拽时可以获取到被拖拽的对象属性定义 要使用 :clone, 而不是clone。我想应该是因为draggable标签比较特。另外在使用**:clone时要将…
阅读更多...
CSS 工具对比：UnoCSS vs Tailwind CSS，谁是你的菜？

CSS 工具对比：UnoCSS vs Tailwind CSS，谁是你的菜？

在现代前端开发中&#xff0c;Utility-First (功能优先) CSS 框架已经成为主流。其中&#xff0c;Tailwind CSS 无疑是市场的领导者和标杆。然而&#xff0c;一个名为 UnoCSS 的新星正以其惊人的性能和极致的灵活性迅速崛起。 这篇文章将深入探讨这两款工具的核心理念、技术差…
阅读更多...
Qt的学习（二）

Qt的学习（二）

1. 创建Hello Word 两种方式&#xff0c;实现helloworld&#xff1a; 1.通过图形化的方式&#xff0c;在界面上创建出一个控件&#xff0c;显示helloworld 2.通过纯代码的方式&#xff0c;通过编写代码&#xff0c;在界面上创建控件&#xff0c; 显示hello world&#xff1b; …
阅读更多...
工厂方法模式和抽象工厂方法模式的battle

工厂方法模式和抽象工厂方法模式的battle

1.案例直接上手 在这个案例里面&#xff0c;我们会实现这个普通的工厂方法&#xff0c;并且对比这个普通工厂方法和我们直接创建对象的差别在哪里&#xff0c;为什么需要一个工厂&#xff1a; 下面的这个是我们的这个案例里面涉及到的接口和对应的实现类&#xff1a; 两个发…
阅读更多...
鸿蒙Navigation路由导航-基本使用介绍

鸿蒙Navigation路由导航-基本使用介绍

1. Navigation介绍 Navigation组件是路由导航的根视图容器&#xff0c;一般作为Page页面的根容器使用&#xff0c;其内部默认包含了标题栏、内容区和工具栏&#xff0c;其中内容区默认首页显示导航内容&#xff08;Navigation的子组件&#xff09;或非首页显示&#xff08;Nav…
阅读更多...
CMS内容管理系统的设计与实现：多站点模式的实现

CMS内容管理系统的设计与实现：多站点模式的实现

在一套内容管理系统中&#xff0c;其实有很多站点&#xff0c;比如企业门户网站&#xff0c;产品手册&#xff0c;知识帮助手册等&#xff0c;因此会需要多个站点&#xff0c;甚至PC、mobile、ipad各有一个站点。 每个站点关联的有站点所在目录及所属的域名。 一、站点表设计…
阅读更多...
ZYNQ学习记录FPGA(二)Verilog语言

ZYNQ学习记录FPGA(二)Verilog语言

一、Verilog简介 1.1 HDL&#xff08;Hardware Description language&#xff09; 在解释HDL之前&#xff0c;先来了解一下数字系统设计的流程&#xff1a;逻辑设计 -> 电路实现 -> 系统验证。 逻辑设计又称前端&#xff0c;在这个过程中就需要用到HDL&#xff0c;正文…
阅读更多...
Java中HashMap底层原理深度解析：从数据结构到红黑树优化

Java中HashMap底层原理深度解析：从数据结构到红黑树优化

一、HashMap概述与核心特性 HashMap作为Java集合框架中最常用的数据结构之一&#xff0c;是基于哈希表的Map接口非同步实现。它允许使用null键和null值&#xff08;但只能有一个null键&#xff09;&#xff0c;并且不保证映射顺序的恒久不变。与Hashtable相比&#xff0c;Hash…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023