多线程讲解（详解）

news2025/1/17 0:05:24

目录

什么是多线程？

为什么要使用多线程？

线程的创建

使用Thread实现

从以上代码我们梳理一下多线程创建步骤：

注意：

小示例

首先，引入依赖

然后，按照我们刚刚说的构建多线程的步骤进行构建，并实现一个下载功能

 接下来在run方法中调用图片下载功能

最后在主函数中调用

 执行结果

Thread类的相关方法

使用Runnable实现

我们直接看代码

​编辑 那我们同样的来总结一下步骤

那到底使用哪个方法来实现比较好呢？我们可以来看一下对比

继承Thread类

实现Runnable接口

线程实例（引出的并发问题）

抢票问题

线程同步

那接下来我们再看一个案例，银行取钱的问题

      

  接下来我将向各位介绍线程的相关知识，请各位上车，我们马上就要开始啦~

什么是多线程？

        说起多线程，那就不得不说什么是进程了，进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器，因此一个进程当中就可能存在多个线程。那么多线程就很容易理解：多线程就是指一个进程中同时有多个执行路径（线程）正在执行。

为什么要使用多线程？

        我们学多线程，为什么要学呢？多线程有什么好的地方需要我们去学习呢？这里就不得不说说多线程的优点了：

  •  在我们的程序中，有很多的操作是非常耗时的，就比如数据库读写操作、文件IO操作等，如果我们把这些都做成单线程，无疑整个程序就必须等到这些执行完之后才能执行之后的操作，所以如果我们使用多线程那我们就可以把这些程序放到后台执行的同时，执行其他操作。
  • 提高了整个程序的效率。
  • 对于一些用户输入、文件存储等，多线程就有了很好的实践。

当然，任何东西都是有他的缺点的，那多线程的缺点又是什么呢？

  • 使用太多线程，是很耗系统资源，因为线程需要开辟内存。更多线程需要更多内存。
  • 影响系统性能，因为操作系统需要在线程之间来回切换。
  • 需要考虑线程操作对程序的影响，如线程挂起，中止等操作对程序的影响。
  • 线程使用不当会发生很多问题。

线程的创建

        线程的创建主要包括两种方法，一种是继承Thread，重写run方法，另一种是实现Runable接口，也需要重写run方法。

        线程的启动，调用start（）方法即可。  我们也可以直接使用线程对象的run方法，不过直接使用，run方法就只是一个普通的方法了。

接下来我们一一进行讲解~

使用Thread实现

public class testThread extends Thread{

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

    public static void main(String[] args) {
//        main线程，主线程
//        创建一个线程对象
        testThread testThread=new testThread();
//        调用start方法开启线程
//        该方法可以同时并发执行多个线程
        testThread.start();
            System.out.println(Thread.currentThread().getName()+":这是主线程");
    }
}

结果如下：

输出太多了，我这里就没有截完~

从以上代码我们梳理一下多线程创建步骤：
  1. 创建一个类，继承Thread类
  2. 重写run()方法
  3. 在主函数中使用start()方法来执行多线程 

接下来我们再稍微修改一下代码

public class testThread extends Thread{

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

    public static void main(String[] args) {
//        main线程，主线程
//        创建一个线程对象
        testThread testThread=new testThread();
//        调用start方法开启线程
//        该方法可以同时并发执行多个线程
        testThread.start();
        for (int i = 0; i < 50; i++) {
            System.out.println("这是主线程"+i);
        }
//            System.out.println(Thread.currentThread().getName()+":这是主线程");
    }
}

部分结果：

 

        从上面的结果我们看到，主线程中的方法和run中的方法并不是有秩序的执行，而是交互执行，所以我们这里总结特点，run方法由jvm调度，什么时候调度，执行的过程控制都有操作系统的CPU调度决定。

注意：
  • 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
  • 想要启动多线程，必须调用start方法。
  • 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上 的异常“IllegalThreadStateException”。
小示例

接下来我们用一个小示例来充分体会一下多线程的特点（这里做一个图片下载的功能）~

首先，引入依赖
      <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.7</version>
        </dependency>
然后，按照我们刚刚说的构建多线程的步骤进行构建，并实现一个下载功能
   public void  downloadPicture(String url, String name) {
            try{
                FileUtils.copyURLToFile(new URL(url),new File(name));
            }catch (Exception e){
                e.printStackTrace();
                System.out.println("图片"+name+"下载失败");
            }

        }
 接下来在run方法中调用图片下载功能
 public void run() {
        DownloadPicture downloadPicture=new DownloadPicture();
        downloadPicture.downloadPicture(url, name);
        System.out.println("下载了文件名为"+name);
    }
最后在主函数中调用
 public static void main(String[] args) {
        testThreadWithDownloadPicture t1 = new testThreadWithDownloadPicture("https://gd-hbimg.huaban.com/8ddcc487e510962d0aff6f296025483a26ed4b2f106ce2f-1QFFia_fw658webp","1.jpg");
        testThreadWithDownloadPicture t2 = new testThreadWithDownloadPicture("https://gd-hbimg.huaban.com/8ddcc487e510962d0aff6f296025483a26ed4b2f106ce2f-1QFFia_fw658webp","2.jpg");
        testThreadWithDownloadPicture t3 = new testThreadWithDownloadPicture("https://gd-hbimg.huaban.com/8ddcc487e510962d0aff6f296025483a26ed4b2f106ce2f-1QFFia_fw658webp","3.jpg");

        t1.start();
        t2.start();
        t3.start();
    }
 执行结果

 

你可以运行多次，你会发现每次输出的顺序都不一样~

Thread类的相关方法

  • start():启动当前线程；调用当前线程的run()方法
  • run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
  • currentThread():静态方法，返回执行当前代码的线程
  • getName():获取当前线程的名字
  • setName():设置当前线程的名字
  • yield():暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程，若没有，继续执行当前线程。
  • join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
  • stop():已过时。当执行此方法时，强制结束当前线程，不推荐使用。
  • sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
  • isAlive():判断当前线程是否存活

使用Runnable实现

我们直接看代码
public class testRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("今天星期几~"+i);
        }
    }

    public static void main(String[] args) {
        testRunnable testRunnable=new testRunnable();
        new Thread(testRunnable).start();
        for (int i = 0; i < 50; i++) {
            System.out.println("这里是主线程--"+i);
        }
    }
}

部分结果

 那我们同样的来总结一下步骤
  1. 创建一个类，实现Runnable这个接口
  2. 重写run方法
  3. 在主函数中使用new Thread().start();的方法调用run方法

我们发现，其实以上两种方法的实现步骤都差不多，这里你可以试试使用Runnable方法来修改我们刚刚的下载图片的案例~

这里我们只需要修改主函数中的方法，其余地方均不做修改

 public static void main(String[] args) {
        testThreadWithDownloadPicture t1 = new testThreadWithDownloadPicture("https://gd-hbimg.huaban.com/8ddcc487e510962d0aff6f296025483a26ed4b2f106ce2f-1QFFia_fw658webp","1.jpg");
        testThreadWithDownloadPicture t2 = new testThreadWithDownloadPicture("https://gd-hbimg.huaban.com/8ddcc487e510962d0aff6f296025483a26ed4b2f106ce2f-1QFFia_fw658webp","2.jpg");
        testThreadWithDownloadPicture t3 = new testThreadWithDownloadPicture("https://gd-hbimg.huaban.com/8ddcc487e510962d0aff6f296025483a26ed4b2f106ce2f-1QFFia_fw658webp","3.jpg");

//        t1.start();
//        t2.start();
//        t3.start();

        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
    }

 同样也能得到结果~

那到底使用哪个方法来实现比较好呢？我们可以来看一下对比

继承Thread类

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

实现Runnable接口

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

线程实例（引出的并发问题）

既然我们讲完了如何创建多线程，那练手肯定是必要的，这里我们就来看一个比较经典的案例

抢票问题

乘坐高铁都需要进行抢票，如何用多线程进行实现呢？

public class testGaotieSoldTicket implements Runnable{

    private Integer ticketNum = 10;
    @Override
    public void run() {
        while (ticketNum > 0) {
            System.out.println(Thread.currentThread().getName() + "--->售出第" + ticketNum + "张票");
            ticketNum--;
        }
    }

    public static void main(String[] args) {
        testGaotieSoldTicket gts = new testGaotieSoldTicket();
        //创建三个线程
        new Thread(gts,"售票窗口1").start();
        new Thread(gts,"售票窗口2").start();
        new Thread(gts,"售票窗口3").start();
    }
}

结果

看到以上结果了吗，有没有发现什么问题？没错，出现了对同一张票进行了多次出售的情况，怎么做呢？此时我们需要使用并发来控制

注：如果你的输出结果始终是统一线程的输出，你可以使用Thread.sleep()来模拟延时

线程同步

        处理多线程问题时,多个线程访问同一个对象﹐并且某些线程还想修改这个对象﹒这时候我们就需要线程同步﹒线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕，下一个线程再使用。

        由于同一进程的多个线程共享同一块存储空间﹐在带来方便的同时,也带来了访问冲突问题﹐为了保证数据在方法中被访问时的正确性﹐在访问时加入锁机制synchronized，当一个线程获得对象的排它锁,独占资源﹐其他线程必须等待，使用后释放锁即可.存在以下问题:

  • 一个线程持有锁会导致其他所有需要此锁的线程挂起;
  • 在多线程竞争下,加锁﹐释放锁会导致比较多的上下文切换和调度延时,引起性能问题;
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置﹐引起性能问题﹒

所以结合我们的理解，我们对刚刚的抢票问题进行修改

public class testGaotieSoldTicket implements Runnable{

    private Integer ticketNum = 10;

    private Boolean flag=true;
    @Override
    public void run() {
        while(flag){
            soldTicket();
        }
    }

    public static void main(String[] args) {
        testGaotieSoldTicket gts = new testGaotieSoldTicket();
        //创建三个线程
        new Thread(gts,"售票窗口1").start();
        new Thread(gts,"售票窗口2").start();
        new Thread(gts,"售票窗口3").start();
    }

    public synchronized void soldTicket(){
        while (ticketNum > 0) {
            try {
//                延时
                Thread.sleep(300);
                System.out.println(Thread.currentThread().getName() + "--->售出第" + ticketNum + "张票");
                ticketNum--;
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        flag=false;
    }
}

从上面的结果我们可以看到，没有出现重复取票的行为，因为我们已经在售票的方法前加上了synchronized，对每一次购票行为都加上了锁。

那接下来我们再看一个案例，银行取钱的问题

public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "结婚基金");
        Thread you = new Thread(new Drawing(account, 50, "你"));
        Thread girlFriend = new Thread(new Drawing(account, 100, "girlFriend"));

        you.start();
        girlFriend.start();
    }
}


class Account {
    int money; // 账户余额
    String name; // 卡名称

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

class Drawing extends Thread {
    Account account;
    int drawingMoney;
    int nowMoney;
    
    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public void run() {
    
        // 判断是否有钱
        if (account.money - drawingMoney < 0) {
            System.out.println(Thread.currentThread().getName() + "钱不够,取不了");
            return;
        }

        // sleep 放大问题的发生性
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 卡内的钱 = 余额 - 取的钱
        account.money = account.money - drawingMoney;
        // 你手上的钱
        nowMoney = nowMoney + drawingMoney;
        System.out.println(account.name + "余额为:" + account.money);
        // this.getName = Thread.currentThread().getName()
        System.out.println(this.getName() + "手里的钱为:" + nowMoney);
    }
}

输出结果就不给出了，由于没有做同步这里的输出结果可能会误导你们以为这段代码是错误~

那接下来我们给这段代码加上锁（要明白在哪儿加上锁，即当前程序对什么进行增删改查操作，以这个案例为例，对account进行处理，所以我们对acount加锁，而不是银行）

public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "结婚基金");
        Thread you = new Thread(new Drawing(account, 50, "你"));
        Thread girlFriend = new Thread(new Drawing(account, 100, "girlFriend"));

        you.start();
        girlFriend.start();
    }
}


class Account {
    int money; // 账户余额
    String name; // 卡名称

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

class Drawing extends Thread {
    Account account;
    int drawingMoney;
    int nowMoney;

    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public void run() {
        synchronized (account) {
            // 判断是否有钱
            if (account.money - drawingMoney < 0) {
                System.out.println(Thread.currentThread().getName() + "钱不够,取不了");
                return;
            }

            // sleep 放大问题的发生性
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 卡内的钱 = 余额 - 取的钱
            account.money = account.money - drawingMoney;
            // 你手上的钱
            nowMoney = nowMoney + drawingMoney;
            System.out.println(account.name + "余额为:" + account.money);
            // this.getName = Thread.currentThread().getName()
            System.out.println(this.getName() + "手里的钱为:" + nowMoney);
        }
    }
}

        好了，以上就是全部内容了，重点理解一下synchronized在哪儿进行加锁，要不然加错了是不能起到同步作用的~

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1682768.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Python实现天气数据采集

Python实现天气数据采集

Python实现天气数据采集 一、需求介绍二、完整代码一、需求介绍 本次天气数据采集的需求是获取每日的最高温、最低温、风力、风向、天气状况、AQI指数，如图所示，完整代码附后： 本次采集的目标网址是2345天气网： 上图的URL中，beijing是城市名称的缩写，54511即为城市代码…
阅读更多...
跨域计算芯片，一把被忽视的汽车降本尖刀

跨域计算芯片，一把被忽视的汽车降本尖刀

作者 |王博 编辑 |德新 2019年前后&#xff0c;「中央运算单元区域控制」的架构被提出。基于这一趋势&#xff0c;从板级的多芯片&#xff0c;到板级的单芯片&#xff0c;集成度越来越高&#xff0c;跨域计算芯片随之来到聚光灯下。 跨域计算芯片的特点是&#xff0c;与专为智…
阅读更多...
java8总结

java8总结

java8总结 java8新特性总结1. 行为参数化2. lambda表达式2.1 函数式接口2.2 函数描述符 3. Stream API3.1 付诸实践 java8新特性总结 行为参数化lambda表达式Stream Api 1. 行为参数化 定义&#xff1a;行为参数化&#xff0c;就是一个方法接受多个不同的行为作为参数&#x…
阅读更多...
如何巧妙利用APP广告变现策略，提升用户参与度并实现盈利增长？

如何巧妙利用APP广告变现策略，提升用户参与度并实现盈利增长？

如何巧妙利用APP广告变现策略&#xff0c;提升用户参与度并实现盈利增长&#xff1f; 在竞争激烈的移动应用市场中&#xff0c;APP广告变现已成为开发者重要的盈利模式之一。为了吸引用户使用APP并实现有效的变现&#xff0c;开发者需要采取一系列巧妙的策略&#xff0c;确保…
阅读更多...
【Qt问题】QStringLiteral、QString、QLatin1String简单区分

【Qt问题】QStringLiteral、QString、QLatin1String简单区分

【Qt问题】QStringLiteral、QString、QLatin1String简单区分 最近在看项目代码的时候&#xff0c;一个频繁使用的关键词——“QStringLiteral”&#xff0c;引起了我的注意&#xff0c;关键是我竟然对它非常模糊&#xff0c;这不是一个Qter能够轻易接受的事情。 于是我秉承着…
阅读更多...
【kubernetes】多 master 高可用集群架构部署

【kubernetes】多 master 高可用集群架构部署

目录 前言 一、环境部署 二、master02 节点部署 1、拷贝相关文件 2、修改配置文件 3、启动各服务并设置开机自启 4、 查看node节点状态 三、负载均衡部署 1、部署 nginx 服务 1.1 编译安装 nginx 1.2 修改 nginx 配置文件 2、部署 keepalived 服务 2.1 yum安装 ke…
阅读更多...
笔记88：LeetCode_134_加油站

笔记88：LeetCode_134_加油站

前言&#xff1a; 前言1&#xff1a;这个题的题目条件给的不太严谨&#xff0c;题目描述中说“如果存在解&#xff0c;则保证它是唯一的”&#xff0c;通过我的实践&#xff0c;我发现这句话的意思其实是本题的所有样例只有两种情况&#xff0c;无解/有唯一解&#xff1b;而不可…
阅读更多...
医院是自建档案室还是档案寄存好呢

医院是自建档案室还是档案寄存好呢

医院可以选择自建档案室或档案寄存&#xff0c;具体选择取决于医院的需求和资源。 自建档案室意味着医院会拥有自己的档案空间和设施&#xff0c;可以更方便地管理和保管档案。这种方式可以确保医院对档案的访问和控制有更多的自主权&#xff0c;同时也能够根据医院的需求进行档…
阅读更多...
5月23日学习记录

5月23日学习记录

[CSAWQual 2019]Unagi 涉及&#xff1a;xxe漏洞&#xff0c;外来编码xml绕过 打开环境&#xff0c;发现存在文件上传 简单上传一个php 毫无疑问上传失败&#xff0c;说是存在waf&#xff0c;绕过waf才能上传&#xff0c;点击here看看 xml编码&#xff0c;可能存在xxe漏洞&…
阅读更多...
Java并发: 锁和同步

Java并发: 锁和同步

在Java并发: 面临的挑战那一篇中我们提到锁和同步是实现并发安全(可见性/原子性)的方法之一。这一章我们来讲讲Java中的锁和同步的各种工具&#xff0c;包括: LockSupportAbstractQueuedSynchronizerJava内置的锁实现 1. LockSupport LockSupport是基于Unsafe的park/unpark实…
阅读更多...
57. UE5 RPG 处理AI敌人转向以及拾取物品的问题

57. UE5 RPG 处理AI敌人转向以及拾取物品的问题

在上一篇文章中&#xff0c;我们实现了使用AI行为树控制敌人进行移动&#xff0c;它们可以一直跟随玩家&#xff0c;虽然现在还未实现攻击。但在移动过程中&#xff0c;我发现了有两个问题&#xff0c;第一个是敌人转向的时候很僵硬&#xff0c;可以说是瞬间转向的&#xff0c;…
阅读更多...
鸿蒙开发接口应用程序包管理：【ApplicationInfo】

鸿蒙开发接口应用程序包管理：【ApplicationInfo】

ApplicationInfo 说明&#xff1a; 本模块首批接口从API version 7 开始支持。后续版本的新增接口&#xff0c;采用上角标单独标记接口的起始版本。 开发前请熟悉鸿蒙开发指导文档&#xff1a; gitee.com/li-shizhen-skin/harmony-os/blob/master/README.md点击或者复制转到。…
阅读更多...
vue3结合element-plus之如何优雅的使用表单组件

vue3结合element-plus之如何优雅的使用表单组件

背景 在日常开发中，我们会经常使用 element-ui 或者是 antdesign 或者是 element-plus 等组件库实现搜索功能 这里就需要用到相关表单组件 下面就以 element-plus 为例，我们实现一个搜索功能的组件，并且随着屏幕尺寸的变化，其布局也会跟随变化 最终大致效果如下： 这里…
阅读更多...
MySQL之Schema与数据类型优化(三)

MySQL之Schema与数据类型优化(三)

Schema与数据类型优化 BLOB和TEXT类型 BLOB和TEXT都是为存储很大的数据而设计的字符串数据类型&#xff0c;分别采用二进制和字符方式存储。 实际上它们分别属于两组不同的数据类型家族:字符类型是TINYTEXT&#xff0c;SMALLTEXT,TEXT&#xff0c;MEDIUMTEXT&#xff0c;LONG…
阅读更多...
成都爱尔周进院长提醒当双眼度数差距过大，我们该做些什么

成都爱尔周进院长提醒当双眼度数差距过大，我们该做些什么

每个人的用眼方式、用眼习惯且两只眼睛“天生条件”不一定相同&#xff0c;当发生近视&#xff0c;双眼近视程度也就可能不同&#xff0c;双眼度数必然会变得不一样。当双眼度数产生差异&#xff0c;尤其是当双眼度数差别过大时会引发哪些问题&#xff1f; 双眼度数不一致&…
阅读更多...
Qt快速入门到熟练(电子相册项目(二))

Qt快速入门到熟练(电子相册项目(二))

上一节我们成功实现了创建项目的向导界面的开发&#xff0c;这节我们继续去实现电子相册的其他功能。 新建DirTreeWidget类 还记得在Qt快速入门到熟练(电子相册项目(一))-CSDN博客里面&#xff0c;我们是在QDockWidget中添加了一个treeWidget作为以后显示目录树的空间…
阅读更多...
OpenHarmony集成OCR三方库实现文字提取

OpenHarmony集成OCR三方库实现文字提取

1. 简介 Tesseract(Apache 2.0 License)是一个可以进行图像OCR识别的C库&#xff0c;可以跨平台运行 。本样例基于Tesseract库进行适配&#xff0c;使其可以运行在OpenAtom OpenHarmony&#xff08;以下简称“OpenHarmony”&#xff09;上&#xff0c;并新增N-API接口供上层应…
阅读更多...
[算法] 优先算法(二): 双指针算法(下)

[算法] 优先算法(二): 双指针算法(下)

&#x1f338;个人主页:https://blog.csdn.net/2301_80050796?spm1000.2115.3001.5343 &#x1f3f5;️热门专栏:&#x1f355; Collection与数据结构 (91平均质量分)https://blog.csdn.net/2301_80050796/category_12621348.html?spm1001.2014.3001.5482 &#x1f9c0;Java …
阅读更多...
Rust学习心得

Rust学习心得

我分享一下一年的Rust学习经历&#xff0c;从书到代码都一网打尽。 关于新手如何学习Rust&#xff0c;我之前在Hacker News上看到了这么一篇教程&#xff1a; 这篇教程与其他教程不同的时&#xff0c;他不是一个速成教程&#xff0c;而是通过自己的学习经历&#xff0c;向需要…
阅读更多...
mac安装两个版本谷歌浏览器；在mac运行不同版本的chrome浏览器

mac安装两个版本谷歌浏览器；在mac运行不同版本的chrome浏览器

场景 正常情况下&#xff0c;mac上只能安装一个版本的chrome浏览器&#xff0c;即使你安装了两个版本的&#xff0c;打开老旧版本时候也会自动切换成最新版的浏览器 故本文主要解决如何下载和在mac运行不同版本的chrome浏览器 文章目录 场景一、下载1.mac本身就有一个最新版ch…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023