Java之多线程详解

最新推荐文章于 2024-06-19 21:11:55 发布
最新推荐文章于 2024-06-19 21:11:55 发布
阅读量323 收藏 1
点赞数
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xzc_tobehero/article/details/121582190
版权
本文深入探讨了Java中的进程与线程概念，强调线程作为CPU调度执行的基本单位。通过示例说明了三种创建线程的方式：继承Thread类、实现Runnable接口（推荐）以及实现Callable接口，并给出了多线程图片保存和抢票等实际应用示例。
摘要由CSDN通过智能技术生成
  • Process与Thread(进程和线程)

程序是指令和数据的集合，是一个静态的概念。

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

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

例如:一个视频是一个进程，那么其中有播放声音、显示画面、看弹幕等多个线程。(main()相当于主线程，其他的方法为其他的线程)

  • 创建线程

方式一:继承Thread类，重写run() ，调用start()开启线程

调用run()方法按顺序依次执行

package 多线程;
//继承Thread类，重写run，调用start开启线程
public class Create extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for(int i = 0;i<20;++i){
            System.out.println("我在看代码--" + i);
        }
    }

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

        //创建一个线程对象
        Create create = new Create();

        //调用run方法按顺序执行
        create.run();
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程--" + i);
        }
    }
}
/*
结果为:
D:\Java\jdk\bin\java.exe "-javaagent:D:\java\IntelliJ IDEA Educational Edition 2020.1.1\lib\idea_rt.jar=64891:D:\java\IntelliJ IDEA Educational Edition 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\java\jdk\jre\lib\charsets.jar;D:\java\jdk\jre\lib\deploy.jar;D:\java\jdk\jre\lib\ext\access-bridge-64.jar;D:\java\jdk\jre\lib\ext\cldrdata.jar;D:\java\jdk\jre\lib\ext\dnsns.jar;D:\java\jdk\jre\lib\ext\jaccess.jar;D:\java\jdk\jre\lib\ext\jfxrt.jar;D:\java\jdk\jre\lib\ext\localedata.jar;D:\java\jdk\jre\lib\ext\nashorn.jar;D:\java\jdk\jre\lib\ext\sunec.jar;D:\java\jdk\jre\lib\ext\sunjce_provider.jar;D:\java\jdk\jre\lib\ext\sunmscapi.jar;D:\java\jdk\jre\lib\ext\sunpkcs11.jar;D:\java\jdk\jre\lib\ext\zipfs.jar;D:\java\jdk\jre\lib\javaws.jar;D:\java\jdk\jre\lib\jce.jar;D:\java\jdk\jre\lib\jfr.jar;D:\java\jdk\jre\lib\jfxswt.jar;D:\java\jdk\jre\lib\jsse.jar;D:\java\jdk\jre\lib\management-agent.jar;D:\java\jdk\jre\lib\plugin.jar;D:\java\jdk\jre\lib\resources.jar;D:\java\jdk\jre\lib\rt.jar;D:\JavaSE\基础语法\out\production\基础语法 多线程.Create
我在看代码--0
我在看代码--1
我在看代码--2
我在看代码--3
我在看代码--4
我在看代码--5
我在看代码--6
我在看代码--7
我在看代码--8
我在看代码--9
我在看代码--10
我在看代码--11
我在看代码--12
我在看代码--13
我在看代码--14
我在看代码--15
我在看代码--16
我在看代码--17
我在看代码--18
我在看代码--19
我在学习多线程--0
我在学习多线程--1
我在学习多线程--2
我在学习多线程--3
我在学习多线程--4
我在学习多线程--5
我在学习多线程--6
我在学习多线程--7
我在学习多线程--8
我在学习多线程--9
我在学习多线程--10
我在学习多线程--11
我在学习多线程--12
我在学习多线程--13
我在学习多线程--14
我在学习多线程--15
我在学习多线程--16
我在学习多线程--17
我在学习多线程--18
我在学习多线程--19

进程已结束,退出代码0

*/

调用start()方法穿插执行代码,并且每次运行的结果都不相同(穿插顺序不同)

package 多线程;
//继承Thread类，重写run，调用start开启线程
public class Create extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for(int i = 0;i<20;++i){
            System.out.println("我在看代码--" + i);
        }
    }

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

        //创建一个线程对象
        Create create = new Create();

        //调用start()方法，开启线程
        create.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程--" + i);
        }
    }
}
/*
结果为:
我在学习多线程--0
我在看代码--0
我在学习多线程--1
我在看代码--1
我在看代码--2
我在看代码--3
我在看代码--4
我在看代码--5
我在学习多线程--2
我在看代码--6
我在看代码--7
我在看代码--8
我在学习多线程--3
我在学习多线程--4
我在看代码--9
我在学习多线程--5
我在看代码--10
我在看代码--11
我在学习多线程--6
我在看代码--12
我在学习多线程--7
我在看代码--13
我在学习多线程--8
我在看代码--14
我在学习多线程--9
我在看代码--15
我在学习多线程--10
我在看代码--16
我在学习多线程--11
我在看代码--17
我在学习多线程--12
我在看代码--18
我在学习多线程--13
我在看代码--19
我在学习多线程--14
我在学习多线程--15
我在学习多线程--16
我在学习多线程--17
我在学习多线程--18
我在学习多线程--19

进程已结束,退出代码0
*/

下面为一个多线程图片保存的实例:

package 多线程;

import org.apache.commons.io.FileUtils;

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

//练习Thread，实现多线程同步下载图片
public class PicLoad extends Thread{
    private String url;
    private String name;

    public PicLoad(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);
    }
}
//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url, String name){
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}
class Test{
    public static void main(String[] args) {
        PicLoad p1 = new PicLoad("https://pic1.zhimg.com/80/v2-86c0da0f749a46a1a7a2c7b80465d530_720w.jpg?source=1940ef5c", "qzy.jpg");
        PicLoad p2 = new PicLoad("https://ts1.cn.mm.bing.net/th?id=OIP-C.5eGvoxrfiCR8-F954A0g2gAAAA&w=146&h=170&c=8&rs=1&qlt=90&o=6&dpr=1.25&pid=3.1&rm=2", "bqb.jpg");
        PicLoad p3 = new PicLoad("https://ts1.cn.mm.bing.net/th?id=OIP-C.q5iRYT4Q_g_r7UBqAON9UwAAAA&w=146&h=170&c=8&rs=1&qlt=90&o=6&dpr=1.25&pid=3.1&rm=2", "xzc.jpg");
        p1.start();
        p2.start();
        p3.start();
    }
}
/*
结果为:
下载了文件名为:qzy.jpg
下载了文件名为:xzc.jpg
下载了文件名为:bqb.jpg
*/

结果成功保存了三张图片，但是保存顺序发生了变化，即为多线程的理念。

方法二:实现Runnable接口(推荐)

定义MyRunna类实现Runna接口

实现run()方法，编写线程执行体

创建线程对象，调用start()方法启动线程 

package 多线程;
//方法二:实现Runnable接口，重写run方法，执行线程需要丢入Runnable接口实现类，调用start开启线程
public class Create2 implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for(int i = 0;i<20;++i){
            System.out.println("我在看代码--" + i);
        }
    }

    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        Create2 create2 = new Create2();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        Thread thread = new Thread(create2);
        thread.start();
        //new Thread(create2).start();//二者等价
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程--" + i);
        }
    }
}

 输出结果也为穿插输出

 抢票实例:

package 多线程;

public class Create3 implements Runnable{
    //票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true){
            if(ticketNums<=0){
                break;
            }
            System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums-- + "票");
        }
    }

    public static void main(String[] args) {
        Create3 ticket = new Create3();
        new Thread(ticket, "小明").start();
        new Thread(ticket, "老师").start();
        new Thread(ticket, "黄牛党").start();
    }
}
/*
黄牛党拿到了第10票
黄牛党拿到了第7票
黄牛党拿到了第6票
黄牛党拿到了第5票
小明拿到了第8票
小明拿到了第3票
老师拿到了第9票
老师拿到了第1票
小明拿到了第2票
黄牛党拿到了第4票
*/

龟兔赛跑实例:

package 多线程;
//龟兔赛跑模拟
public class Rabbit implements Runnable{

    //胜利者
    private static String winner;
    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) {
        Rabbit rabbit = new Rabbit();
        new Thread(rabbit, "兔子").start();
        new Thread(rabbit, "乌龟").start();
    }
}
//无论怎样都是乌龟获胜

方法三:实现Callable接口

实现方法:

实现Callable接口，设置返回值

重写call方法，并抛出异常

创建目标对象 

进入主函数......

package 多线程;

import org.apache.commons.io.FileUtils;

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

//方法三:实现callable接口
/*
可以定义返回值
可以抛出异常
实现复杂
*/
public class TestCallable implements Callable<Boolean> {
        private String url;
        private String name;

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

        public Boolean call() {
            WebDownloader webDownloader = new WebDownloader();
            webDownloader.downloader(url, name);
            System.out.println("下载了文件名为:" + name);
            return true;
        }

        public static void main(String[] args) throws Exception, InterruptedException{
            TestCallable t1 = new TestCallable("https://pic1.zhimg.com/80/v2-86c0da0f749a46a1a7a2c7b80465d530_720w.jpg?source=1940ef5c", "qzy.jpg");
            TestCallable t2= new TestCallable("https://ts1.cn.mm.bing.net/th?id=OIP-C.5eGvoxrfiCR8-F954A0g2gAAAA&w=146&h=170&c=8&rs=1&qlt=90&o=6&dpr=1.25&pid=3.1&rm=2", "bqb.jpg");
            TestCallable t3 = new TestCallable("https://ts1.cn.mm.bing.net/th?id=OIP-C.q5iRYT4Q_g_r7UBqAON9UwAAAA&w=146&h=170&c=8&rs=1&qlt=90&o=6&dpr=1.25&pid=3.1&rm=2", "xzc.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 rs1 = result1.get();
            boolean rs2 = result2.get();
            boolean rs3 = result3.get();
            //关闭服务
            ser.shutdownNow();
        }
    }
class WebDownloader{
    //下载方法
    public void downloader(String url, String name){
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}
/*
结果为:
下载了文件名为:bqb.jpg
下载了文件名为:xzc.jpg
下载了文件名为:qzy.jpg
*/

一只猪咪
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 多线程
萤火之光
10-24 486
同步与异步 同步：交替执行 异步：按顺序执行 进程与线程的区别 线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。另外，也正是因为共享资源，所以线程中执行时一般都要进行同步和互斥。总...
40个Java多线程问题总结（优就业JAVA分享）
HZC的专栏
12-22 877
前言 java多线程分类中写了21篇多线程的文章，21篇文章的内容很多，个人认为，学习，内容越多、越杂的知识，越需要进行深刻的总结，这样才能记忆深刻，将知识变成自己的。这篇文章主要是对多线程的问题进行总结的，因此罗列了40个多线程的问题。 这些多线程的问题，有些来源于各大网站、有些来源于自己的思考。可能有些问题网上有、可能有些问题对应的答案也有、也可能有些各位网友也都看过，但是本文写作
java多线程
最新发布
m0_46702681的博客
06-19 1950
javajava。
JAVA多线程
水月洞天
06-23 585
1 多线程概述 1:要想了解多线程，必须先了解线程，而要想了解线程，必须先了解进程，因为线程是依赖于进程而存在。 2:什么是进程? 通过任务管理器我们就看到了进程的存在。 而通过观察，我们发现只有运行的程序才会出现进程。 进程：就是正在执行的应用程序。 进程是系统进行资源分配和调用的独立单位。 每一个进程都有它自己的内存...
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
Java多线程详解
01-20
文章目录1、进程与线程2、创建多线程2.1、继承Thread类2.2、实现Runnable接口2.3、使用匿名内部类实现2.4、实现Runnable接口的好处2.5、使用Callable和Future创建线程3、线程的生命周期4、几种特殊线程4.1、join线程...
基于Java回顾之多线程详解
09-05
在Java编程中，多线程是一个至关重要的概念，它允许程序同时执行多个任务，从而提高系统的效率和响应速度。本文将深入探讨Java中的多线程，包括线程的基本属性、创建线程的方式、线程状态的转换以及线程间的通信。 ...
JAVA多线程编程实例详解
08-25
JAVA多线程编程实例详解 JAVA多线程编程是指在一个程序中可以同时运行多个线程，以提高程序的执行效率和响应速度。JAVA多线程编程可以通过继承Thread类或实现Runnable接口来实现。 在JAVA中，线程是系统进行资源...
java多线程编程之管道通信详解
08-29
Java多线程编程中的管道通信（Pipe Communication）是一种在不同线程之间传递数据的有效方式，无需借助临时文件或共享变量。这种通信机制依赖于Java提供的`PipeInputStream`和`PipedOutputStream`（对于字节流）或者...
Java总结篇系列：Java多线程（一）
weixin_34228662的博客
06-30 390
多线程作为Java中很重要的一个知识点，在此还是有必要总结一下的。 一.线程的生命周期及五种基本状态 关于Java中线程的生命周期，首先看一下下面这张较为经典的图： 上图中基本上囊括了Java中多线程各重要知识点。掌握了上图中的各知识点，Java中的多线程也就基本上掌握了。主要包括： Java线程具有五中基本状态 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thre...
java线程机试_多线程面试题（2020）
weixin_39991055的博客
02-28 231
多线程1.并行和并发有什么区别？并行：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑 上来看那些任务是同时执行。并发：多个处理器或多核处理器同时处理多个任务。如下图：并发和并行 并发 = 两个队列和一台咖啡机。 并行 = 两个队列和两台咖啡机。2.线程和进程的区别？一个程序下至少有一个进程，一个进程下至少有一个线程，一个进程下也可以有 多个线程来增加程序的执行速度。3.守护...
Java多线程编程详解
"Java的多线程编程教程" 在Java编程中，多线程是一个重要的特性，它使得程序能够同时执行多个任务，提高了系统资源的利用率和程序的响应速度。本教程深入探讨了Java的多线程机制，由肖明教授在计算机学院讲解。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值