Java多线程之Thread和Runnable以及Callable接口多线程的简单实现（适合小白入门，十分简单）

已于 2022-12-01 16:36:12 修改
阅读量1.1k 收藏 1
点赞数
分类专栏： Java 文章标签： java 开发语言 jvm intellij-idea
于 2022-12-01 14:51:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46106857/article/details/128131798
版权

Java多线程之Thread和Runnable

一、介绍

1、程序

程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。

2、进程

执行程序的一次执行过程，是一个动态的概念，是系统资源分配的单位。

3、线程

通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程。线程是CPU调度和执行的单位

4、整体思路

（1）线程是就是独立的执行路径。
（2）在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程。
（3）main()称之为主线程，为系统的入口，用于执行整个程序。
（4）在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序不能人为干预。
（5）对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制。
（6）线程会带来额外的开销。
（7）每个线程在自己工作内存交互，内存控制不当会造成数据不一致。

5、注意

很多的多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。

二、Thread

1、思路流程

（1）自定义线程类继承Thread类
（2）重写run( )方法，编写线程执行体
（3）创建线程对象，调用start ( )方法启动线程
（4）线程不一定立即执行，CPU安排调度

2、样例代码

package com.example.multithreading.demo1;

// 创建线程方式一：继承Thread类，重写run()方法，调用start开启线程

// 总结：注意，线程开启不一定立即执行，由CPU调度执行
public class ThreadTest1 extends Thread{

    @Override
    public void run(){
        // run方法线程体
        for (int i = 0; i < 10; i++) {
            System.out.println("线程" + i);
        }
    }

    public static void main(String[] args){
        // main线程，主线程
        // 创建一个线程对象
        ThreadTest1 threadTest1 = new ThreadTest1();
        // 调用start()方法开启线程
        threadTest1.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("主线程");
        }
    }

}

结果
在这里插入图片描述

3、多线程下载图片

package com.example.multithreading.demo1;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;

// 实现多线程同步下载图片
public class ThreadTest2 extends Thread{

    // 网络图片地址
    private String url;
    // 保存的文件名
    private String name;

    public ThreadTest2(String url, String name){
        this.url = url;
        this.name = name;
    }

    // 下载图片线程的执行体
    @Override
    public void run(){
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url, name);
        System.out.println("下载了文件名为：" + name);

    }

    public static void main(String[] args){
        ThreadTest2 threadTest1 = new ThreadTest2("http://www.pp3.cn/uploads/allimg/200710/14-200G00Z321.jpg","风景图1.jpg");
        ThreadTest2 threadTest2 = new ThreadTest2("http://www.pp3.cn/uploads/allimg/200710/14-200G00Z321.jpg","风景图2.jpg");
        ThreadTest2 threadTest3 = new ThreadTest2("http://www.pp3.cn/uploads/allimg/200710/14-200G00Z321.jpg","风景图3.jpg");
        threadTest1.start();
        threadTest2.start();
        threadTest3.start();
    }

}

// 下载器
class WebDownloader{
    // 下载方法
    public void downloader(String url, String name){
        try{
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (MalformedURLException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

结果
在这里插入图片描述

三、Runnable

1、思路流程

（1）定义一个类实现Runnable接口
（2）实现run( )方法，编写线程执行体
（3）创建线程对象，调用start( )方法启动线程
（因为java单继承的局限性，推荐使用Runnable对象）

2、样例代码

package com.example.multithreading.demo1;

// 创建线程方式2：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
public class ThreadTest3 implements Runnable{
    @Override
    public void run() {
        // run方法线程体
        for (int i = 0; i < 10; i++) {
            System.out.println("线程" + i);
        }
    }

    public static void main(String[] args){
        // 创建runnable接口的实现类对象
        ThreadTest3 threadTest3 = new ThreadTest3();

        // 创建线程对象，通过线程对象来开启线程代理
        new Thread(threadTest3).start();

        for (int i = 0; i < 20; i++) {
            System.out.println("主线程");
        }
    }
}

结果
在这里插入图片描述

3、多线程下载图片

package com.example.multithreading.demo1;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;

public class ThreadTest3_1 implements Runnable{

    // 网络图片地址
    private String url;
    // 保存的文件名
    private String name;

    public ThreadTest3_1(String url, String name){
        this.url = url;
        this.name = name;
    }

    // 下载图片线程的执行体
    @Override
    public void run(){
        WebDownloader2 webDownloader2 = new WebDownloader2();
        webDownloader2.downloader(url, name);
        System.out.println("下载了文件名为：" + name);

    }

    public static void main(String[] args){
        ThreadTest2 threadTest1 = new ThreadTest2("http://www.pp3.cn/uploads/allimg/200710/14-200G00Z321.jpg","风景图1.jpg");
        ThreadTest2 threadTest2 = new ThreadTest2("http://www.pp3.cn/uploads/allimg/200710/14-200G00Z321.jpg","风景图2.jpg");
        ThreadTest2 threadTest3 = new ThreadTest2("http://www.pp3.cn/uploads/allimg/200710/14-200G00Z321.jpg","风景图3.jpg");
        new Thread(threadTest1).start();
        new Thread(threadTest2).start();
        new Thread(threadTest3).start();
    }

}


// 下载器
class WebDownloader2{
    // 下载方法
    public void downloader(String url, String name){
        try{
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (MalformedURLException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

结果
在这里插入图片描述

四、Callable接口（仅作了解）

1、具体流程

（1）实现Callable接口，需要返回值类型
（2）重写call方法，需要抛出异常
（3）创建目标对像
（4）创建执行服务：ExecutorService ser = Excecutors.newFixedThreadPool(1);
（5）提交执行：Future result1 = ser.submit(t1);
（6）获取结果：boolean r1 = result1.get()
（7）关闭服务：ser.shutdownNow()

2、优点

可以定义返回值
可以抛出异常

3、样例

package com.example.multithreading.demo2;

import com.example.multithreading.demo1.ThreadTest2;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.concurrent.*;

public class CallableTest implements Callable<Boolean> {

    // 网络图片地址
    private String url;
    // 保存的文件名
    private String name;

    public CallableTest(String url, String name){
        this.url = url;
        this.name = name;
    }

    // 下载图片线程的执行体
    @Override
    public Boolean call(){
        WebDownloader3 webDownloader = new WebDownloader3();
        webDownloader.downloader(url, name);
        System.out.println("下载了文件名为：" + name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableTest t1 = new CallableTest("http://www.pp3.cn/uploads/allimg/200710/14-200G00Z321.jpg","风景图1.jpg");
        CallableTest t2 = new CallableTest("http://www.pp3.cn/uploads/allimg/200710/14-200G00Z321.jpg","风景图2.jpg");
        CallableTest t3 = new CallableTest("http://www.pp3.cn/uploads/allimg/200710/14-200G00Z321.jpg","风景图3.jpg");

        // 创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);

        // 提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);

        // 获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();

        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);

        // 关闭服务
        ser.shutdownNow();
    }
}

// 下载器
class WebDownloader3{
    // 下载方法
    public void downloader(String url, String name){
        try{
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (MalformedURLException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

结果
在这里插入图片描述

五、两者比较（Thread与Runnable）

1、Thread类

（1）子类继承Thread类具备多线程能力
（2）启动线程：子类对象.start( )
(不建议使用：避免OOP单继承局限性)

ThreadTest1 threadTest1 = new ThreadTest1();
threadTest1.start();

2、Runnable接口

（1）实现接口Runnable具有多线程能力
（2）启动线程：传入目标对象 + Thread对象.start( )
(推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用)

// 一份资源
ThreadTest threadTest = new ThreadTest();
// 多个代理
new Thread(threadTest, "张三").start();
new Thread(threadTest, "李四").start();
new Thread(threadTest, "王五").start();

3、并发问题

3.1 问题场景

多个线程操作同一个资源的情况下，线程不安全，数据会出现紊乱。

3.2 样例

package com.example.multithreading.demo1;

// 多个线程同时操作同一个对像
// 买票
public class ThreadTest4 implements Runnable{

    private int num = 10;

    @Override
    public void run() {
        while (true) {
            if (num <= 0) {
                break;
            }

            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            System.out.println(Thread.currentThread().getName() + "-->拿到了第" + num-- + "张票");
        }
    }

    public static void main(String[] args) {
        ThreadTest4 threadTest4= new ThreadTest4();
        new Thread(threadTest4, "张三").start();
        new Thread(threadTest4,"李四").start();
        new Thread(threadTest4,"王五").start();
    }
}

结果
在这里插入图片描述

六、多线程模拟龟兔赛跑

1、具体代码

package com.example.multithreading.demo1;

// 模拟龟兔赛跑
public class TortoiseAndRabbitRace implements Runnable {

    // 定义胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            // 模拟兔子休息
            if(Thread.currentThread().getName().equals("兔子") && i%10==0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }

            // 判断比赛是否结束
            boolean flag = gameOver(i);

            if (flag) {
                break;
            }

            System.out.println(Thread.currentThread().getName() + "跑了" + i + "步");
        }
    }

    // 判断是否完成比赛
    private boolean gameOver(int steps) {
        // 判断是否有胜利者
        if(winner != null){
            // 已经存在胜利者
            return true;
        }
        if (steps >= 100){
            winner = Thread.currentThread().getName();
            System.out.println("winner is " + winner);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        TortoiseAndRabbitRace race = new TortoiseAndRabbitRace();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

结果
在这里插入图片描述

熊凯瑞
关注
专栏目录
Java 线程对比（Thread,Runnable,Callable）实例详解
08-31
在Java中，有三种常见的创建线程的方式：继承Thread类、实现Runnable接口以及使用Callable接口。下面将对这三种方式的使用、优缺点进行详细对比。 1. 继承Thread类 这种方式是最直接的创建线程的方法，通过创建...
13、Callable介绍（Thread如何启动Callable）
分享java学习路上的一些笔记，不足之处多多见谅。
11-15 1320
3、而这个FutureTask可以与Callable挂上关系，也可以与Runnable挂上关系。2、Runnable下面有FutureTask实现类（里面有RunnableFuture）1、去看Runnable接口（里面有FutureTask实现类）我们Thread只能先new Runnable接口（这个接口里面有FutureTask实现类），所以里面写实现类和写Runnable是一样的（也就是第二行）。然后TutureTask（里面又有Callable）。所以联系起了Thread
Java多线程Thread、Runnable、Callable知识点
每天八杯水的博客
12-04 1229
一、程序、进程、线程 三者关系与区别 程序：静态的，一堆数据与语句的集合，也就是平时写的代码。 进程：动态的，程序运行的一次过程，也就是运行该程序。 线程： 相当于是执行进程的多个路线，进程中的main函数就是主线程，如果没有多线程，进程就只能按照程序中的代码老老实实的按照顺序执行，当在main函数中调用其他函数时，只能先中断，保存上下文去先执行要调用的函数，才能回到main函数原位置继续执行代码。 如果是多线程，当调用其他函数时，单独开辟一个线程去执行该函数，...
Runnable和Thread以及Callable的区别
一只菜橘猫
07-16 5523
Thread 1、是一个类 2、只能被继承 实现方式 class ThreadTest extends Thread{     private int ticket = 100;     public void run(){       while(true){         if(ticket &gt; 0){   ticket-   }else{ break;  }}} new T...
Java多线程 - Runnable接口和Callable接口的区别
你今天真好看呀
02-21 3315
文章目录1. Runnable接口实例2. Callable接口原理3. Callnable接口实例4. FutureTask是什么？5. 线程池中 submit() 和 execute() 方法有什么区别？ Runnable接口源码： @FunctionalInterface public interface Runnable { // 这个run()方法返回值为void，没有受检异常的异常声明，出现异常只能内部捕获 public abstract void run(); } Call
Java多线程实现Callable接口
09-02
在Java中，实现多线程有两种主要方式：继承Thread类和实现Runnable接口。此外，Java 5引入了Callable接口，它提供了一种更灵活的方式来创建线程，特别是当需要从线程中返回结果时。 Callable接口类似于Runnable，但...
Java多线程Callable接口实现代码示例
08-29
Java 多线程 Callable 接口实现代码示例 Java 多线程编程中，创建线程有多种方式，其中一种便是实现 Callable 接口。Callable 接口是一个函数式接口，定义了一个 call 方法，该方法可以抛出异常并返回结果。与 ...
Java多线程之Callable接口的实现
08-27
在Java中，有两种方式可以实现多线程编程，即继承Thread类和实现Runnable接口。然而，在一些情况下，我们需要在多线程中返回结果或者抛出异常，这时就需要使用Callable接口。 Callable接口是Java 1.5中引入的新的...
java多线程—Runnable、Thread、Callable区别
没长正
08-12 1165
java多线程—Runnable、Thread、Callable区别 阅读目录 多线程编程优点第一种实现方法—继承Thread类第二种实现方法—实现Runnable接口第三种—实现Callable接口总结参考 回到顶部 多线程编程优点 进程之间不能共享内存，但线程之间共享内存非常容易。 系统创建线程所分配的资源相对创建进程而言，代价非常小。
多线程，线程的创建和启动，Thread、Runnable、Callable的用法
sunzixiao的博客
07-16 1009
大部分时候我们都作者单线程编程，程序都只有一条顺序执行流从main方法开始执行，一次向下执行每行代码。但实际情况是，单线程的程序往往功能非常有限，例如我们要开发一个煎蛋的服务器程序，这个服务器程序需要向不同的客户端提供服务，不同客户端之间互不干扰，这就需要多线程。多线程程序可以包括多个顺序执行流，多个顺序流之间互不干扰。Java提供了非常优秀的多线程支持，程序可以通过非常简单的方式来启动多线程。进程就是一个应用程序（一个进程是一个软件）线程是一个进程中的执行场景/执行单元阿里巴巴进程马云。...
图形化 一个线程用来求前n个数的最大者，另一个线程用于更新界面把当前求的最大者显示出来。
木心Fx的博客
11-19 843
//郑州轻工业大学 //题号：实验三 第一题 //题目： 我们使用的计算机系统就是一个多线程程序，我们在编辑文档时，可以同时听音乐、看视频，桌面右下角的时钟会不断更新最新时间，这些都是多线程给我们带来的好处。请实现一个多线程程序，分别使用Thread类和Runnable接口求一个整数序列中的最大者，其中，一个线程用来求前n个数的最大者，另一个线程用于更新界面把当前求的最大者显示出来。要求：每隔5秒求一次前n个数的最大者，然后再隔5秒求前n+1个数的最大者，依次类推，并以图形化形式实时显示运行结果。 适合新人
Thread、Runnable、Callable、Future、FutureTask，谈谈他们的关系？
hnhygkx的博客
03-24 416
Thread、Runnable、Callable、Future、FutureTask 关系
线程(Thread) -- Callable实现
Rong_zhe的博客
08-19 684
实现线程的方式有四种： 方式一：定义类继承Thread类 方式二：定义类实现Runnable接口 通过定义类实现Callable接口用于创建线程，Callable接口类似于Runnable，但是Runnable不返回结果，也不能抛出异常，而Callable可以返回结果，可以抛出异常。 通过查看源码可以知道开启新的线程需要Thread(Runnable)对象，现在Callable怎样传输给线程对象呢...
轻松掌握理解多线程
Ivan的博客
02-26 383
三种多线程实现方式 Thread的`run()`方法理解 为什么不直接调用`run()`方法，而是调用`start()`方法呢？ 为什么不推荐使用继承Thread的方式实现多线程？ `sleep()`方法让哪个线程休眠？
Thread、Runnable、Callable、Future、FutureTask之间的关系
Apandam的博客
06-29 327
Thread 和 Runnable 是一个策略模式，FutureTask 和 Callable 又是一个策略模式，最后通过 Runnable 和 FutureTask 的继承关系，将这 2 个策略模式组合在一起。
Java多线程：Runnable与Callable的区别和原理
最新发布
隐风的博客
10-10 747
总的来说，Runnable和Callable都是用于实现多线程的工具，但它们的设计目的和使用场景是不同的。Runnable更适合用于执行简单的、不需要返回结果的任务，而Callable更适合用于需要返回计算结果的任务。在编写多线程程序时，我们需要根据实际需求选择适当的接口。在Java多线程编程中，我们经常使用Runnable和Callable接口来创建并执行线程。这两个接口都是Java.lang包中的部分，并且都用于实现多线程。在本文中，我们将深入探讨这两种接口的差异以及它们的工作原理。
【java】runnable和callable的区别
当白的技术小窝 ( git : https://github.com/canwhite )
12-09 6683
java中runnable和callable的区别
Java线程创建三方式详解：继承Thread vs Runnable接口与Callable/Future
Java特别篇深入探讨了线程创建的三种主要方式：继承Thread类、实现Runnable接口以及使用Callable和Future接口。本文将对这三种创建线程的方式进行详细解释和对比。 1. **继承Thread类**： - 创建步骤： - 创建一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

熊凯瑞

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值