多线程-线程创建的三种方式

最新推荐文章于 2022-09-04 17:24:10 发布
最新推荐文章于 2022-09-04 17:24:10 发布
阅读量106 收藏
点赞数
分类专栏： Java基础知识点总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skz980619/article/details/119610336
版权

线程的创建的三种方式

1.继承Thread类（重点）

实现方法：
  • 自定义线程类继承Thread类
  • 重写**run()**方法，编写线程执行体
  • 创建线程对象，调用**start()**方法启动线程
//创建线程方式一：继承Thread类，重写run()方法，调用start开启线程
public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("我在看代码---" + i);
        }
    }

    public static void main(String[] args) {
        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();

        //调用start方法开启线程
        testThread1.start();

        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习多线程---" + i);
        }
    }
}

总结：注意，线程开启不一定立即执行，由cpu调度执行

​ 不建议使用：避免OOP单继承的局限性

多线程同步下载图片

需求：练习Thread，实现多线程同步下载图片

  • 将commons.io包下载并导入lib目录

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yzSJQpc5-1628670582068)(C:\Users\zhou\AppData\Roaming\Typora\typora-user-images\image-20210810161719664.png)]

  • 编写下载器

    class WebDownLoader{
    //下载方法
    public void downloader(String url, String name){
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

  • 编写下载图片线程run()方法的执行体

    private String url;
private String name;

public TestThread2(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);
}

调用start()启动线程

public static void main(String[] args) {
    TestThread2 t1 = new TestThread2("https://img2.baidu.com/it/u=2379421903,2766120725&fm=26&fmt=auto&gp=0.jpg", "1.jpg");
    TestThread2 t2 = new TestThread2("https://img0.baidu.com/it/u=2580887492,2953392680&fm=26&fmt=auto&gp=0.jpg", "2.jpg");
    TestThread2 t3 = new TestThread2("https://img2.baidu.com/it/u=3562631285,4033075858&fm=26&fmt=auto&gp=0.jpg", "3.jpg");

    //先下载t1
    t1.start();
    //然后是t2
    t2.start();
    //最后是t3
    t3.start();
}

执行结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B5EY6nuD-1628670582069)(C:\Users\zhou\AppData\Roaming\Typora\typora-user-images\image-20210810163317143.png)]

查看文件，已经存在1.jpg, 2.jpg, 3.jpg

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7R3SyQiv-1628670582070)(C:\Users\zhou\AppData\Roaming\Typora\typora-user-images\image-20210810163349613.png)]

2.实现Runnable接口（重点）

实现方法：
  • 定义MyRunnable类实现Runnable接口
  • 实现run()方法，编写线程执行体
  • 创建线程对象，调用start()方法启动线程
//创建线程方式2：实现runnable接口，重写run方法，执行线程需要丢人runnable接口实现类，调用start方法
public class TestThread3 implements Runnable{

    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("我在看代码---" + i);
        }
    }

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

        //创建线程对象，通过线程对象来开启线程
        //Thread thread = new Thread(testThread3);

        //thread.start();

        new Thread(testThread3).start();

        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习多线程---" + i);
        }
    }
}

总结：推荐使用，避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

并发问题初识—火车抢票案例

火车票抢票问题：

public class TestThread4 implements Runnable {

    //票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true) {

            if (ticketNums <= 0) {
                break;
            }
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums-- + "张票");
        }
    }

    public static void main(String[] args) {
        TestThread4 ticket = new TestThread4();

        new Thread(ticket, "小明").start();
        new Thread(ticket, "老师").start();
        new Thread(ticket, "黄牛党").start();
    }
}

发现问题：当多个资源操作同一个资源的情况下，线程不安全，数据紊乱

龟兔赛跑案例-Race
//模拟龟兔赛跑
public class Race 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(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            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) {
        Race race = new Race();

        new Thread(race, "兔子").start();
        new Thread(race, "乌龟").start();
    }
}

输出结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qExHuyFs-1628670582071)(C:\Users\zhou\AppData\Roaming\Typora\typora-user-images\image-20210810171301805.png)]

3.实现Callable接口（了解）

  1. 实现Callable接口，需要返回值类型

  2. 重写call方法，需要抛出异常

  3. 创建目标对象

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

  5. 提交执行：Future r1 = ser.submit(t1);

  6. 获取结果：boolean rs1 = r1.get();

  7. 关闭服务：ser.shutdownNow();

    演示：用Callable改造下载图片案例

    import org.apache.commons.io.FileUtils;

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

//线程创建方式三：实现Callable接口
/*
    callable的好处：
    1.可以自定义返回值
    2.可以抛出异常
 */
public class TestCallable implements Callable<Boolean> {
    private String url;
    private String name;

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

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

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("https://img2.baidu.com/it/u=2379421903,2766120725&fm=26&fmt=auto&gp=0.jpg", "1.jpg");
        TestCallable t2 = new TestCallable("https://img0.baidu.com/it/u=2580887492,2953392680&fm=26&fmt=auto&gp=0.jpg", "2.jpg");
        TestCallable t3 = new TestCallable("https://img2.baidu.com/it/u=3562631285,4033075858&fm=26&fmt=auto&gp=0.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 WebDownLoader{
    //下载方法
    public void downloader(String url, String name){
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}
skz980619
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程-JDK5.0新增线程创建方式
02-03
### Java多线程-JDK5.0新增线程创建方式 #### 一、新增方式1：实现Callable接口 ##### （1）介绍 自Java 5.0起，为提高线程管理的灵活性与效率，引入了`Callable`接口，这是一种全新的创建线程的方式。与传统的`...
Java多线程-创建多线程的基本方式一：继承Thread类
01-19
Java提供了多种创建多线程的方式，其中最基础的一种是通过继承Thread类来实现。 一、创建和启动线程 1. 概述 Java虚拟机（JVM）支持多线程执行，每个线程都是通过`java.lang.Thread`类的实例来表示的。创建一个...
多线程(一)线程创建的三种方式
daxia7577的博客
01-12 214
创建线程的三种方式： 1.第一种方式继承Thread类，重写Thread类中的run方法，还需要调用start方法，start方法相当于通知CPU，线程已经就绪，CPU在合适的时间点调用该线程的run方法;我们程序中的main方法，我们称之为主线程。 2.创建线程的第二种方式，实现Runnable接口，并重写run方法，创建实例之后，将该实例包装成Thread实例，继续调用start...
第一章 线程
qq_39354297的博客
09-08 345
第一章 线程 1.1 多线程原理 画一个多线程执行时序图来体现一下多线程程序的执行流程。代码如下：自定义线程类： 1 public class MyThread extends Thread { 2 /* 3 * 利用继承中的特点 4 * 将线程名称传递 进行设置 5 */ 6 ...
多线程的创建的三种方式
qq_45559707的博客
02-20 232
多线程的三种创建方式 一、通过继承Thread类 1.创建一个继承Thread的子类； 2.重写Thread类的run（）方法； 3.创建Thread的子类对象； 4.通过此对象调用start（）方法； package com.example.paoduantui.Thread; import android.view.Window; /** * * 创建三个窗口卖票，总票数为100张，使用继承自Thread方式 * 用静态变量保证三个线程的数据独一份 * * 存在线程的安
多线程的三种创建方式
Maggie~~的博客
11-23 626
基本概念 程序：指令和数据的有序集合，本身没有任何运行的含义，是一个静态的概念，。 进程：在操作系统中运行的程序。程序执行的过程。动态概念 线程：CPU调度和执行的单位，一个进程可包含若干个线程。 多线程：真正的多线程有所个CPU（多核），如服务器。如果时模拟出来的多线程，即再一个cpu的情况下，再同一时间，cpu只能执行一个代码，因为切换很快，所以就有同时执行的错觉。 总结： 线程是独立执行的路径。 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程。 main()称之为主程序，
Java多线程-创建多线程的基本方式二：实现Runnable接口
01-25
总结，实现`Runnable`接口是创建Java多线程的一种常见方式，它提供了更大的灵活性，尤其是在需要多继承或者线程之间需要共享数据的情况下。掌握这两种创建线程的方法，并了解其适用场景，对于编写高效的并发程序至关...
Java创建线程三种方式的优缺点
08-26
实现Runnable接口创建线程是Java中另一种常用的线程创建方式。这种方式下，需要创建一个实现Runnable接口的类，并重写run方法。例如： ```java public class Thread2 implements Runnable { @Override public ...
Java特别篇-关于线程创建的三种方式的总结对比
最新发布
02-04
### Java特别篇-关于线程创建的三种方式的总结对比 #### 一、常见3种创建线程的方式 ##### （1）方式1：继承Thread类的方式 - **创建步骤**： - 创建一个类，继承`Thread`类。 - 重写`run()`方法，该方法将包含...
多线程三种创建方式
wyy的博客
06-07 281
方法一：继承Thread Thread package com.bjsxt.create; /** * @author dell * @data 2021/3/2 * 创建一个线程对象，并启动线程 * * 注意：启动main方法，自动创建main线程 * * thread.join() 阻塞乌龟线程，乌龟执行完，兔子才有机会 * * Thread类的常用方法： * public void run() * thread.star
多线程创建的三种方式
zhanggf的博客
02-05 490
方式一:创建Thread的子类 1、创建Thread子类的一个实例并重写run方法，run方法会在调用start()方法之后被执行，创建并运行上述Thread子类 class Mythread extends Thread{     public void run(){         System.out.println(Thread.currentThread().getId()+"
创建线程的三种方法_多线程的创建三种方式
weixin_39761645的博客
12-11 673
一、多线程的简单理解明白什么是多线程，小生通俗一点的理解为：在一个程序里，我想同时让这个程序完成多个任务。比如：让主函数 main 在打印1~100之间的所有整数的时候，要求在主函数打印到 20 的时候，再运行另一个类里的程序，让它打印10~100之间的所有整数。这里忽略同进程内的多线程之间的抢占时间问题，上面的举例需求是要求一个程序只要有发生同时运行俩个程序的情况就行，即不准出现无论程...
多线程/并发笔记:线程创建的三种方式
Mungo的专栏
09-12 537
Java线程创建的三种方式： 直接继承Thread类，重载run()方法 实现Runnable接口 实现Callable接口
Java中创建多线程的三种方法
godkzz的博客
08-04 409
目录 一、继承Thread类，重写run方法 1.准备一个普通的学生类 2.学生类继承Thread接口，并重写run方法 3.在Main方法中生成两个学生线程，并启动 4.输出结果 二、实现Runnable接口 1.准备一个普通的学生类 2.实现Runnable接口，重写run方法 3.在Main方法中，把学生类对象作为Thread对象的构造函数参数传入，并启动 4.输出结果 三、实现Callable接口 1.准备一个普通的学生类 2.实现Callable接口，重写call方法
学习多线程，创建多线程的三种方式
weixin_45627271的博客
09-04 1674
学习多线程，创建多线程的三种方式
创建多线程的三种方法（前两种比较常用）
qx020814的博客
07-11 1100
第一种就是继承Thread类，重写run方法， 第二种是实现Runnable 接口，实现run方法，然后利用Thread类的有参构造法，传入实现Runnable 接口的类，进行创建多线程 第三种比较复杂，不过它的run方法可以有返回值：1.创建一个类实现Callable接口，这里的泛型就是run返回的值2.创建FutureTask类对象，FutureTask类实现了RunnableFuture，而这个接口又继承了Runnable 接口，所以FutureTask类也可以创建多线程， 其实还...
Java多线程：创建线程的两种方式
在Java中，有两种主要方式来创建线程体： 1. **继承Thread类**: 通过创建Thread类的子类并重写`run()`方法来实现线程。`run()`方法包含了线程的主要执行逻辑。例如，在`ThreadDemo1.java`中，你可以定义一个类，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值