多线程详解

最新推荐文章于 2021-07-19 20:05:37 发布
最新推荐文章于 2021-07-19 20:05:37 发布
阅读量118 收藏
点赞数
文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41915921/article/details/107496487
版权

我们先了解一下什么是程序、进程、线程
一个程序在一个进程里运行，一个进程可以有多个线程，如视频中同时听到声音，看到图像，看弹幕，等等。

Process与Thread

  • 说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
  • 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。
  • 通常在一个进程中可以包含若干个线程，当然一个线程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。

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

1、概念

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

2、线程的创建（Thread、Runnable、Callable）

三种创建的方式

1、 Thread class ========> 继承Thread类（重点）

2、 Runnable接口 =======> 实现Runnable接口（重点）

3、Callable接口 =========> 实现Callable接口（了解）

Thread

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

测试 TestThread1.java

package com.haiyang.demo01;

//创建线程方式一：继承Thread类，重写run()方法，调用start开启线程
public class TestThread1  extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i <20 ; i++) {
            System.out.println("我是线程一，继承了Thread"+i);
        }

    }

    public static void main(String[] args) {

        //创建一个线程对象
        TestThread1 thread1 = new TestThread1();
        //调用start()方法开启线程
        thread1.start();

        //main线程，主线程
        for (int i = 0; i <100 ; i++) {
            System.out.println("我是main线程，主线程"+i);
        }

    }
}

输出：
在这里插入图片描述
注意：线程开启不一定立即执行，是由cpu调度的

多线程下载多张图片

要先导入commons.io的依赖

		<dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.7</version>
        </dependency>

package com.haiyang.demo01;


import org.apache.commons.io.FileUtils;

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

//练习Thread，实现多线程同步下载图片
public class TestThread2 extends Thread{

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

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

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


    public static void main(String[] args) {
        TestThread2 t1 = new TestThread2("https://img-blog.csdnimg.cn/20200721105042393.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTE1OTIx,size_16,color_FFFFFF,t_70", "1.jpg");
        TestThread2 t2 = new TestThread2("https://img-blog.csdnimg.cn/20200720160019134.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTE1OTIx,size_16,color_FFFFFF,t_70", "2.jpg");
        TestThread2 t3 = new TestThread2("https://img-blog.csdnimg.cn/20200720135855390.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTE1OTIx,size_16,color_FFFFFF,t_70", "3.jpg");
        t1.start();
        t2.start();
        t3.start();
    }
}

//下载器
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异常，download方法出现问题");
        }

    }
}

输出：
在这里插入图片描述

Runnable

  • 定义一个类实现Runnable接口
  • 实现run()方法，编写线程执行体
  • 创建线程对象。创建代理类对象，代理类对象调用start()方法启动线程

测试 TestThread3.java

package com.haiyang.demo01;

//创建线程方式2：实现Runnable接口，重写run()，执行线程需要创建线程对象，线程对象调用start()开启线程
public class TestThread3 implements Runnable {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i <20 ; i++) {
            System.out.println("我是线程一，继承了Thread"+i);
        }
    }


    public static void main(String[] args) {

        //创建Runnable接口的实现类对象
        TestThread3 testThread3 = new TestThread3();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        new Thread(testThread3).start();
        //main线程，主线程
        for (int i = 0; i <100 ; i++) {
            System.out.println("我是main线程，主线程"+i);
        }

    }
}

输出：
在这里插入图片描述

多线程下载多张图片

要先导入commons.io的依赖

		<dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.7</version>
        </dependency>

package com.haiyang.demo01;


import org.apache.commons.io.FileUtils;

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

//练习Thread，实现多线程同步下载图片
public class TestThread4 implements Runnable{

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

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

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


    public static void main(String[] args) {
        TestThread2 t1 = new TestThread2("https://img-blog.csdnimg.cn/20200721105042393.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTE1OTIx,size_16,color_FFFFFF,t_70", "1.jpg");
        TestThread2 t2 = new TestThread2("https://img-blog.csdnimg.cn/20200720160019134.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTE1OTIx,size_16,color_FFFFFF,t_70", "2.jpg");
        TestThread2 t3 = new TestThread2("https://img-blog.csdnimg.cn/20200720135855390.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTE1OTIx,size_16,color_FFFFFF,t_70", "3.jpg");
//        t1.start();
//        t2.start();
//        t3.start();
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
    }
}

//下载器
class WebDownloader1{
    //下载方法
    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异常，download方法出现问题");
        }

    }
}

输出：
在这里插入图片描述

小结：

1、继承Thread类

  • 子类继承Thread类具备多线程能力
  • 启动线程：子类对象.start()
  • 不建议使用，避免oop单继承的局限性

2、实现Runnable接口

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

多个线程操作同一个对象

package com.haiyang.demo01;

//多个线程操作同一个对象
//买火车票的例子
public class TestThread5 implements Runnable {

    //票数
    private int ticketNum = 10;

    @Override
    public void run() {
        while (true){
        if (ticketNum <= 0){
            break;
        }
        //模拟延时
        try {
            Thread.sleep(200);
        }catch (InterruptedException e){
            e.printStackTrace();
        }

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


    public static void main(String[] args) {
        TestThread5 ticket = new TestThread5();
        new Thread(ticket,"小红").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛党").start();
    }
}

输出：
在这里插入图片描述
发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱

模拟龟兔赛跑的例子

package com.haiyang.demo01;

public class Race implements Runnable {

    private static String winner;

    @Override
    public void run() {

        for (int i = 1; i <= 100; i++) {

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

            //判断比赛是否结束
            boolean flag = gameOver(i);
            //比赛结束了，就停止程序
            if (flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"跑了"+ i + "步");
        }
    }
    
    //判断是否完成比赛
    public boolean gameOver(int steps){
        if (winner != null){
            return true;
        }else if (steps >= 100){
            winner = Thread.currentThread().getName();
            System.out.println("胜利者是"+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<Boolean> result1 = ser.submit(t1)
6、获取结果：boolean r1 = result1.get()
7、关闭服务：ser.shutdownNow();

多线程同步下载图片

package com.haiyang.demo02;

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.name = name;
        this.url = url;
    }


    @Override
    public Boolean call(){
        WebDownloader2 webDownloader = new WebDownloader2();
        webDownloader.downloader(url,name);
        System.out.println("下载成功的文件名："+name);

        return true;
    }


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("https://img-blog.csdnimg.cn/20200721105042393.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTE1OTIx,size_16,color_FFFFFF,t_70", "1.jpg");
        TestCallable t2 = new TestCallable("https://img-blog.csdnimg.cn/20200720160019134.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTE1OTIx,size_16,color_FFFFFF,t_70", "2.jpg");
        TestCallable t3 = new TestCallable("https://img-blog.csdnimg.cn/20200720135855390.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTE1OTIx,size_16,color_FFFFFF,t_70", "3.jpg");

        //创建执行服务：
        ExecutorService ser = Executors.newFixedThreadPool(1);
        //提交执行：
        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();
    }

}
//下载器
class WebDownloader2 {
    //下载方法
    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异常，download方法出现问题");
        }

    }
}

输出：
在这里插入图片描述
Callable的好处：
1、可以定义返回值
2、可以抛出异常

Ocean..
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多线程的详解
Maybe_do_it的博客
03-15 530
多线程 多条路走、提高效率。线程是独立执行的路径 线程实现（重点） 线程创建 继承Thread类（重点） 即将一个类声明为Thread的子类，重写run()方法，调用start开启线程 public class testThread1 extends Thread{ @Override public void run() { //run方法线程体 for (int i = 0; i < 10; i++) { System.out.
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
Java多线程详解 在Java编程中，多线程是一种重要的技术，它使得程序能够同时执行多个任务，提高系统的效率和响应性。本教程将详细讲解Java中的多线程概念，包括线程的创建、状态、同步以及高级主题，旨在帮助初学者...
Java多线程详解及示例
最新发布
07-20
在多线程环境下，死锁是指两个或多个线程相互等待对方释放资源，导致它们都无法继续执行。活锁则是指线程不断重试获取资源，但由于其他线程持有资源不释放，导致线程陷入无限循环的状态。避免死锁和活锁的关键在于...
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线程...
python多线程详解（超详细）
12-21
python中的多线程是一... python多线程详解 什么是线程？ 线程也叫轻量级进程，是操作系统能够进行运算调度的最小单位，它被包涵在进程之中，是进程中的实际运作单位。 线程自己不拥有系统资源，只拥有一点儿在运行
Linux中多线程详解及简单实例
01-20
Linux中多线程详解及简单实例 1.概念 进程：运行中的程序。 线程：一个程序中的多个执行路径。更准确的定义是：线程是一个进程内部的一个控制序列。 2.为什么要有线程？ 用fork调用进程代价太高，需要让一个...
Java 多线程
weixin_43916678的博客
07-19 391
文章目录进程线程多线程的实现方式1设置和获取线程名称线程调度线程控制线程生命周期多线程的实现方式2线程同步同步代码块案例：卖票同步方法线程安全的类Lock锁生产者消费模式 进程 是正在运行的程序。 是系统进行资源分配和调用的独立单位。 每一个进程都有它自己的内存空间和系统资源。 线程 是进程中的单个顺序控制流，是一条执行路径。 单线程：一个进程如果只有一条执行路径，则成为单线程程序。 多线程：一个进程如果有多条执行路径，则成为多线程程序。 多线程的实现方式1 方式1：继承Thread类 定义一个类MyTh
*多线程、同步
xyc1211的博客
07-24 300
线程的3种创建方式： 一：实现 Runnable 接口 二：继承 Thread 类本身 三：Callable 和 Future 创建线程 线程Thread类常用的方法： 创建线程的三种方式的对比 线程池 线程安全 java线程同步机制： 方式一：同步代码块 方式二：同步函数 方法3：lock锁 线程通讯 线程的停止： 守护线程（后台线程）： 线程死锁
多线程（学习笔记）
漫漫路上人的博客
03-21 263
01多线程的概述 02多线程的实现方式1 代码 首先创建一个线程类 public class MyThread extends Thread{ @Override public void run() { for (int i = 0; i < 30; i++) { System.out.println(getName()+":"+i); } } } 接下...
Delphi多线程详解：创建与应用实践
Delphi多线程详解深入探讨了在Delphi编程中实现多线程的各个方面。章节11首先定义了线程的基本概念，指出在Win32操作系统中，线程是表示进程中执行路径的对象，每个应用程序至少有一个主线程，但可以通过创建额外...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值