Java篇之多线程-02-线程创建

最新推荐文章于 2024-03-25 20:22:10 发布
最新推荐文章于 2024-03-25 20:22:10 发布
阅读量96 收藏
点赞数
分类专栏： Java # 多线程 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44514254/article/details/115381354
版权

Java 线程创建

三种创建方式

在这里插入图片描述

Thread

  • 自定义线程类继承 Thread 类
  • 重写 run() 方法，编写线程执行体
  • 创建线程对象，调用 start() 方法启动线程
package com.moon.demo01;

/*
    创建线程方式：
    1. 继承 Thread 类
    2. 重写 run() 方法
    3. 调用 start() 开启线程
    线程开启不一定立即执行，由 CPU 调度执行
 */
public class TestThread extends Thread {
    // 线程入口点
    @Override
    public void run() {
        // run 方法 线程体
        // 线程不一定立即执行，由 CPU 安排调度
        for (int i = 0; i < 200; i++) {
            System.out.println("多线程--" + i);
        }
    }

    public static void main(String[] args) {
        // main 方法 主线程

        // 创建线程对象
        TestThread testThread = new TestThread();
        // 调用 start() 方法开启线程
        testThread.start();

        for (int i = 0; i < 2000; i++) {
            System.out.println("main 方法--" + i);
        }
    }
}

网络图片下载练习

package com.moon.demo02;

// 需要引入 commons-io-2.8.0.jar 包
import org.apache.commons.io.FileUtils;

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

// 下载器
public 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 方法异常");
        }
    }
}

package com.moon.demo02;

// 练习 Thread，实现多线程同步下载图片
public class TestThread extends Thread{
    private String url; // 网络图片地址
    private String name; // 保存的文件名

    public TestThread(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) {
        TestThread t1 = new TestThread("http://img.netbian.com/file/2021/0310/smallf677a15bc950aef69cec1704ea509cb61615386187.jpg", "01.jpg");
        TestThread t2 = new TestThread("http://img.netbian.com/file/2021/0326/smallae961e173d8c70abb0107fcc0d5b195b1616774139.jpg", "02.jpg");
        TestThread t3 = new TestThread("http://img.netbian.com/file/2021/0328/smalle261b1a44ca68a9e5be68aeafe7fe83e1616932954.jpg", "03.jpg");
        t1.start();
        t2.start();
        t3.start();
        /*
        下载文件02.jpg成功
        下载文件01.jpg成功
        下载文件03.jpg成功
        // 并不一定按照预想的程序顺序执行下载，每次下载的先后顺序也不一样，由 CPU 调度执行
         */
    }
}

Runnable

  • 定义 MyRunnable 类，实现 Runnable 接口
  • 实现 run() 方法，编写线程执行体
  • 创建线程对象， 调用 start() 方法启动线程
  • 推荐使用 Runnable 对象，因为 Java 单继承的局限性
package com.moon.demo03;

/*
    创建线程方式
    1. 实现 runnable 接口
    2. 实现 run 方法
    3. 执行线程需要创建线程对象并丢入 runnable 接口实现类，调用 start() 方法
 */
public class TestThread implements Runnable {
    @Override
    public void run() {
        // 实现 run 方法 线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("多线程--" + i);
        }
    }

    public static void main(String[] args) {
        // main 方法 主线程

        // 创建 runnable 接口的实现对象
        TestThread testThread = new TestThread();

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

        // 以上两个步骤可简写为
        new Thread(testThread).start();


        for (int i = 0; i < 2000; i++) {
            System.out.println("main 方法--" + i);
        }
    }
}

以上网络图片下载练习使用 Runnable 实现

package com.moon.demo02;

// 练习 Thread，实现多线程同步下载图片
public class TestThread implements Runnable{
    private String url; // 网络图片地址
    private String name; // 保存的文件名

    public TestThread(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) {
        TestThread t1 = new TestThread("http://img.netbian.com/file/2021/0310/smallf677a15bc950aef69cec1704ea509cb61615386187.jpg", "01.jpg");
        TestThread t2 = new TestThread("http://img.netbian.com/file/2021/0326/smallae961e173d8c70abb0107fcc0d5b195b1616774139.jpg", "02.jpg");
        TestThread t3 = new TestThread("http://img.netbian.com/file/2021/0328/smalle261b1a44ca68a9e5be68aeafe7fe83e1616932954.jpg", "03.jpg");
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
    }
}

小结：

  • 继承 Thread 类
    • 子类继承 Thread 类，具备多线程能力
    • 启动线程：子类对象.start()
    • 不建议使用：避免 OOP 单继承局限性
  • 实现 Runnable 接口
    • 实现接口 Runnable，具有多线程能力
    • 启动线程：传入目标对象 + Thread 对象.start()
    • 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用
package com.moon.demo04;

// 多个线程同时操作一个对象
// 模拟买票例子
// 发现问题：多个线程操作同一个资源的情况下，线程不安全、数据紊乱
public class TestThread 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();
            }
            // 获取当前执行的线程名
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + "--> 抢到了第" + ticketNums-- + "张票");
        }
    }

    public static void main(String[] args) {
        TestThread ticket = new TestThread();
        
        // 一个对象被多个线程使用
        new Thread(ticket, "小明").start();
        new Thread(ticket, "小红").start();
        new Thread(ticket, "隔壁老王").start();
    }

}

案例：龟兔赛跑-Race

  1. 首先来个赛道距离，然后要离终点越来越近
  2. 判断比赛是否结束
  3. 打印出胜利者
  4. 龟兔开始赛跑
  5. 故事中是乌龟赢的，兔子需要睡觉，所以需要模拟兔子睡觉
  6. 终于，乌龟赢得比赛
package com.moon.demo05;

// 模式龟兔赛跑
public class Race implements Runnable {
    private static String winner; // 胜利者

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            String threadName = Thread.currentThread().getName();

            // 模拟兔子休息
            if (threadName.equals("兔子") && i % 10 == 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            // 判断比赛是否结束
            boolean flag = this.gameOver(i);
            if (flag) {
                break;
            }

            System.out.println(threadName + " --> 跑了" + i + "米");
        }
    }

    // 判断是否完成比赛
    private boolean gameOver(int meter) {
        // 已近存在胜利者
        if (winner != null) {
            return true;
        }
        if (meter >= 100) {
            Race.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();
    }
}

Callable

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

利用 callable 改造下载图片案例

package com.moon.demo06;

import java.util.concurrent.*;

// 练习 Thread，实现多线程同步下载图片
// 实现 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("http://img.netbian.com/file/2021/0310/smallf677a15bc950aef69cec1704ea509cb61615386187.jpg", "01.jpg");
        TestCallable t2 = new TestCallable("http://img.netbian.com/file/2021/0326/smallae961e173d8c70abb0107fcc0d5b195b1616774139.jpg", "02.jpg");
        TestCallable t3 = new TestCallable("http://img.netbian.com/file/2021/0328/smalle261b1a44ca68a9e5be68aeafe7fe83e1616932954.jpg", "03.jpg");

        // 创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        // 提交执行
        Future<Boolean> result1 = ser.submit(t1);
        Future<Boolean> result2 = ser.submit(t2);
        Future<Boolean> result3 = ser.submit(t3);
        // 获取结果
        boolean r1 = result1.get();
        boolean r2 = result2.get();
        boolean r3 = result3.get();

        System.out.println(r1);
        System.out.println(r2);
        System.out.println(r3);

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

静态代理

演示：实现静态代理对比 Thread

  • 你：真实角色
  • 婚庆公司：代理你，帮你处理结婚的事
  • 结婚：你和婚庆公司都实现结婚接口即可
package com.moon.demo07;

// 结婚接口
public interface Marry {
    void happyMarry();
}

package com.moon.demo07;

// 真实角色(你)：你去结婚
public class You implements Marry{
    @Override
    public void happyMarry() {
        System.out.println("我们结婚啦~~");
    }
}

package com.moon.demo07;

// 代理角色(婚庆公司)：帮助你结婚
public class WeddingCompany implements Marry{
    // 代理谁 --> 真实目标角色
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void happyMarry() {
        before();
        this.target.happyMarry(); // 真实对象
        after();
    }

    private void before() {
        System.out.println("结婚之前，布置现场中...");
    }

    private void after() {
        System.out.println("结婚之后，收尾款！！！");
    }
}

package com.moon.demo07;

/*
  静态代理模式：
      真实对象和代理对象都要实现同一个接口
      代理对象要代理真实角色

  好处：
      代理对象可以做很多真实对象做不了的事情
      真实对象可以专注做自己的事情
 */
public class StaticProxy {
    public static void main(String[] args) {
        //new Thread(new ThreadClassName()).start(); 与 Runnable 开启多线程一致
        new WeddingCompany(new You()).happyMarry();
    }
}
ilomoyou
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
6-1 jmu-Java-07多线程-Thread (20分)
sddfnsff的博客
05-26 5989
编写MyThread类继承自Thread。创建MyThread类对象时可指定循环次数n。 功能：输出从0到n-1的整数。 并在最后使用System.out.println(Thread.currentThread().getName()+" "+isAlive())打印标识信息 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即MyThread类的代码/ public class Main { public static void main(String[] args
Java多线程-JDK5.0新增线程创建方式
02-03
Java多线程--JDK5.0新增线程创建方式
Java创建线程的四种方式
Andy
07-28 11万+
1.继承Thread类实现多线程     run()为线程类的核心方法，相当于主线程的main方法，是每个线程的入口     a.一个线程调用 两次start()方法将会抛出线程状态异常，也就是的start()只可以被调用一次      b.native生明的方法只有方法名，没有方法体。是本地方法，不是抽象方法，而是调用c语言方法       registerNative()方法包含了所有与线程...
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 14万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
12jmu-Java-07多线程-Thread
ihopeyousuccess的博客
11-30 1999
编写MyThread类继承自Thread。创建MyThread类对象时可指定循环次数n。 功能：输出从0到n-1的整数。 并在最后使用System.out.println(Thread.currentThread().getName()+" "+isAlive())打印标识信息 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即MyThread类的代码/ public class Main { public static void main(String[] args
013jmu-Java-07多线程-PrintTask
ihopeyousuccess的博客
11-30 4717
编写PrintTask类实现Runnable接口。 功能：输出从0到n-1的整数(n在创建PrintTask对象的时候指定)。并在最后使用System.out.println(Thread.currentThread().getName());输出标识信息。 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即PrintTask类的代码/ public class Main { public static void main(String[] args) { Scann
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
最新发布
qq_35716689的博客
03-25 14万+
开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。通过这个过程,我们可以更好地掌握多线程编程的技巧,并培养编码能力和系统性思维。
Java基础进阶多线程-四种创建方式
qq_46096136的博客
09-11 6332
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完 放回池中。调用start方法开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。run方法在分支栈的栈底部，main方法在主栈的栈底部。背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程， 对性能影响很大。启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。好处：提高响应速度（减少了创建新线程的时间）
Java多线程实战-CountDownLatch模拟压测实现
qq_35716689的博客
03-17 14万+
当多个线程需要协调和同步执行任务时，Java 中的 CountDownLatch（倒计时器）是一个常用的工具类。它可以帮助开发者实现线程之间的同步，确保某些线程在其他线程完成任务后再继续执行。牵着猫散步的鼠鼠。本文将介绍 CountDownLatch 的基本原理、用法以及示例代码，最后会使用CountDownLatch完成一个简单的压测实现。
Java多线程 - Java创建线程的4种方式
你今天真好看呀
02-18 9600
文章目录1. Java创建线程有哪几种方式？1.1 线程创建方法一：继承Thread类创建线程类1.2 线程创建方法二：实现Runnable接口创建线程目标类1.3 优雅创建Runnable线程目标类的两种方式1.4 通过实现Runnable接口的方式创建线程目标类的优缺点1.5 线程创建方法三：使用Callable和FutureTask创建线程1.6 线程创建方法四：通过线程池创建线程2. 线程的 run() 和 start() 有什么区别？3. Runnable 和 Thread 用哪个好？4. Fut
Java多线程实战-CompletableFuture异步编程优化查询接口响应速度
qq_35716689的博客
03-20 14万+
CompletableFuture为Java提供了强大的异步编程能力,可以极大地提高应用的并发能力和响应速度。通过并行执行多个查询任务,我们可以大幅减少接口的响应时间,优化用户体验。同时,CompletableFuture的代码风格函数式、简洁、优雅,也使得代码更加易读易维护。 但是,异步编程也不是万能的,它需要开发者转变思维模式,还需要权衡利弊。在实际项目中,我们可以结合其他优化手段,选择合适的方案,以达到最佳的性能效果。
Java多线程-创建多线程的基本方式二：实现Runnable接口
01-25
总结，实现`Runnable`接口是创建Java多线程的一种常见方式，它提供了更大的灵活性，尤其是在需要多继承或者线程之间需要共享数据的情况下。掌握这两种创建线程的方法，并了解其适用场景，对于编写高效的并发程序至关...
Java多线程-创建多线程的基本方式一：继承Thread类
01-19
【Java多线程-创建多线程的基本方式一：继承Thread类】 在Java编程中，多线程是一种并发执行任务的机制，它允许多个任务在同一时间运行，从而提高程序的效率和响应速度。Java提供了多种创建多线程的方式，其中最...
Java多线程-线程的同步与锁的问题
09-01
Java多线程编程中，线程同步是一种解决并发问题的关键技术。当多个线程同时访问共享资源时，可能会引发数据不一致性和竞态条件。线程同步的主要目标是确保同一时间只有一个线程能够访问特定的代码段，以避免数据损坏...
第-章-JAVA多线程优秀文档.pptx
12-01
本文档将详细介绍 JAVA 多线程的概念、特点、创建方式、线程生命周期、同步机制、线程通信等知识点，并通过实例分析和代码示例来深入讲解 JAVA 多线程的应用场景和实现方法。 一、JAVA 多线程概念 在 Java 中，...
Elasticsearch
记录个人技术、生活成长历程，看心情不定期更新
09-01 2258
Elasticsearch 是一个基于 Lucene 的搜索服务器，它提供了一个分布式多用户能力的全文搜索引擎，基于 RESTful web 接口 Elasticsearch 是用 Java 开发的，并作为 Apache 许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索、稳定可靠、快速安装、使用方便优点：Lucene 不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，部分文本分析引擎。.........
浅谈IOC与DI
记录个人技术、生活成长历程，看心情不定期更新
04-23 461
控制反转IOC(Inversion of Control)是说创建对象的控制权进行转移，以前创建对象的主动权和创建时机是由自己把控的，而现在这种权力转移到第三方，比如转移交给了IOC容器，它就是一个专门用来创建对象的工厂，你要什么对象，它就给你什么对象，有了 IOC容器，依赖关系就变了，原先的依赖关系就没了，它们都依赖IOC容器了，通过IOC容器来建立它们之间的关系。
Java篇(07)-异常处理
记录个人技术、生活成长历程，看心情不定期更新
03-26 217
Java 异常处理什么是异常？简单分类异常体系结构ErrorExceptionError 和 Exception 的区别异常处理机制自定义异常总结 什么是异常？ 实际工作中，遇到的情况不可能是非常完美的。比如：你写的某个模块，用户输入不一定符合你的要求、你的程序要打开某个文件，这个文件可能不存在或者文件格式不对、你要读取数据库的数据，数据可能是空的、我们的程序在跑着，内存或硬盘可能满了… 软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常（Exception），意思是例外。这些例外情况，
Java篇之多线程-03-线程状态
记录个人技术、生活成长历程，看心情不定期更新
04-01 151
Java 线程状态五大状态线程方法停止线程线程休眠 sleep线程礼让 yield线程强制执行 join观测线程状态线程优先级守护(daemon)线程 五大状态 线程方法 方法 说明 setPriority(int newPriority) 更改线程的优先级 static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠 void join() 等待该线程终止 static void yield() 暂停当前正在执行的线程对象，并执行其

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值