多线程java

news2024/11/25 10:27:26

多线程的创建

前两种方法无法返回直接结果,而有的线程执行完毕后需要返回结果

方式一:java是通过java.lang.Thread类的对象来代表线程的
  • 启动线程必须调用strat方法,不是调用run方法
  • 不要把主线程任务放在启动子线程之前
//1.让子类继承Thread线程类
public class MyThread extends Thread{
    //2.必须重写Thread类的run方法
    @Override
    public void run(){
        for (int i = 0; i < 5; i++) {
            System.out.println("MyThread线程输出:"+i);
        }
    }
}

public class ThreadTest1 {
    //main
    public static void main(String[] args) {
        //3.创建MyThread线程类的对象代表一个线程
        Thread t = new MyThread();
        //4.启动线程
        t.start();
    }
}
方式二:实现Runnable接口
  • 优点:任务类只是实现接口,可以继续继承其他类,实现其它接口,扩展性强
//1.实现Runnable接口
public class MyRunnable implements Runnable{
    //2.重写run方法
    @Override
    public void run() {
        //3.线程要执行的任务
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程输出:"+i);
        }
    }
}
public class ThreadTest2 {
    public static void main(String[] args) {
        //4.创建任务对象
        Runnable target = new MyRunnable();
        //5.把任务对象交给一个线程处理
        new Thread(target).start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程输出:"+i);
        }
    }
}
线程创建方式二的匿名内部类写法
  1. 可以创建Runable的匿名内部类对象
  2. 再交给Thread线程对象
  3. 在调用线程对象的Strat()启动线程
public class ThreadTest2_2 {
    public static void main(String[] args) {
        //1.直接创建Runnable接口的匿名内部类形式(任务对象)
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程1输出:"+i);
                }
            }
        };
        new Thread(target).start();

        //简化形式
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程2输出:"+i);
                }
            }
        }).start();

        //再次简化
        new Thread(() -> {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程3输出:"+i);
                }
        }).start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程输出:"+i);
        }
    }
}
方式三:实现Callable接口
  • JDK5.0提供了Cabble接口和FutureTask类来实现
  • 可以返回线程执行完毕后的结果

过程

  1. 定义一个类实现Callable接口,重写Call方法,封装要做的事,和要返回的数据结果
  2. 把Callable类型的对象封装成FutureTask(线程任务对象)
  3. 把线程任务对象交给Thread对象
  4. 调用start方法启动线程
  5. 线程执行完毕后,通过FutureTask对象的get方法去获取线程任务执行的结果
public class ThreadTest3 {
    public static void main(String[] args) throws Exception {
        //3.创建一个Callable对象
        Callable<String> callable  = new MyCallable(100);
        //4.把Callable对象封装成一个FutureTask对象
        //未来任务对象
        //1.是一个任务对象,实现了Runnable接口
        //2.可以在线程执行完毕之后,用未来任务对象调用get方法获取线程完毕后的结果
        FutureTask<String> futureTask = new FutureTask(callable);

        new Thread(futureTask).start();

        //6.获取线程执行完毕后的结果
        System.out.println(futureTask.get());
    }
}

//1.让这个类实现Callable接口
public class MyCallable implements Callable {
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    //2.重写call方法
    //求1-n的和

    int sum = 0;
    @Override
    public String call() throws Exception {
        for (int i = 1; i <=n; i++) {
            sum=sum+i;
        }
        return "线程求出了1-n的和是:"+sum;
    }
}

线程的方法

public class MyThread extends Thread{
    public MyThread(String name) {
        super(name);

    }

    @Override
    public void run(){
        Thread m = Thread.currentThread();

        for (int i = 0; i < 3; i++) {
            System.out.println(m.getName()+"子线程输出:"+i);
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        Thread t1 = new MyThread("一号线程");
        //设置名字
//        t1.setName("一号线程");
        t1.start();
        System.out.println(t1.getName());

        //构造器设置名字
        Thread t2 = new MyThread("二号线程");
        t2.start();
        System.out.println(t2.getName());

        //主线程对象的名字
        Thread m = Thread.currentThread();//那个线程执型它,他就会得到哪个对象
        System.out.println(m.getName());

        for (int i = 0; i < 4; i++) {
            System.out.println("main线程输出:"+i);
        }
    }
}

//sleep  join   的作用
public class ThreadTest2 {
    public static void main(String[] args) throws Exception {
        for (int i = 0; i < 5; i++) {
            //到3的时候休眠五秒
            if(i==3){
                Thread.sleep(5000);
            }
            System.out.println(i);
        }

        //join方法的作用:让调用这个方法的线程先执行完
        Thread t1 = new MyThread("1号线程");
        t1.start();
        t1.join();
        Thread t2 = new MyThread("2号线程");
        t2.start();
        t2.join();
        Thread t3 = new MyThread("3号线程");
        t3.start();
        Thread t4 = new MyThread("4号线程");
        t4.start();

    }
}

线程安全问题

加锁:每次只允许一个线程加锁,加锁后才能访问进入,访问完毕后自动解锁,然受其他线程才能在加锁进来

同步代码块
synchronized (同步锁){
    访问共享资源的核心代码
}
同步锁的注意事项
  • 对于当前同时执行的线程来说,同步锁必须是同一把(同一个对象),否则会出bug
  • 建议使用共享资源作为锁对象,对于实例方法建议使用this作为锁对象
  • 对于静态方法使用字节码(类名.class)对象作为锁对象
public class Account {
    private String id;//卡号
    private double money;//余额

    public Account() {
    }

    public Account(String id, double money) {
        this.id = id;
        this.money = money;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;

    }

    public void drawMoney(int i) {
        //先搞清楚是谁来取钱
        String name = Thread.currentThread().getName();
        //1判断余额是否足够
        //this 正好可以代表共享资源
        synchronized (this) {
            if(this.money>=i){
                System.out.println(name+"来取钱"+i+"成功");
                this.money-=i;
                System.out.println(name+"取钱后,余额是"+this.money);
            }else{
                System.out.println(name+"来取钱:余额不足");
            }
        }
    }
}

public class DrawThread extends Thread{
    private Account acc;
    public  DrawThread(Account acc, String name){
        super(name);
        this.acc = acc;
    }
    @Override
    public void run(){
        //取钱
        acc.drawMoney(100000);
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        //创建一个账户对象
        Account acc = new Account("123456",100000);
        //2.创建两个线程分别代表小明小红,再去同一个账户中取钱
        new DrawThread(acc,"小明").start();//小明
        new DrawThread(acc,"小红").start();//小红
    }
}
同步方法

作用:把访问共享核心资源的核心方法给上锁,以此保证线程安全

  • 如果是实例方法,同步方法默认使用this作为所得对象
  • 如果方法是静态方法,同步方法默认使用类名.class作为所得对象
修饰符 synchronized 返回值类型 方法名称(形参列表){
操作共享资源的代码
}
 public synchronized void drawMoney(int i) {
        //先搞清楚是谁来取钱
        String name = Thread.currentThread().getName();

        //1判断余额是否足够
            if(this.money>=i){
                System.out.println(name+"来取钱"+i+"成功");
                this.money-=i;
                System.out.println(name+"取钱后,余额是"+this.money);
            }else{
                System.out.println(name+"来取钱:余额不足");
            }
    }
lock锁
package d4_thread_synchronized;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Account {
    private String id;//卡号
    private double money;//余额
    //创建了一个锁对象
    private final Lock lk = new ReentrantLock();

    public Account() {
    }

    public Account(String id, double money) {
        this.id = id;
        this.money = money;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;

    }

    public void drawMoney(int i) {
        //先搞清楚是谁来取钱
        String name = Thread.currentThread().getName();

        lk.lock();
        try {
            //1判断余额是否足够
            if(this.money>=i){
                System.out.println(name+"来取钱"+i+"成功");
                this.money-=i;
                System.out.println(name+"取钱后,余额是"+this.money);
            }else{
                System.out.println(name+"来取钱:余额不足");
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            lk.unlock();
        }
        
    }
}

线程池

计算密集型的任务:核心线程数量 = CPU的核数 + 1

IO密集型的任务: 核心线程数量 = CPU的核数 * 2

创建线程池对象
1. 方式一:使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象

临时线程什么时候创建

  • 新任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程

什么时候开始拒绝新任务

  • 核心线程和临时线程都在忙,任务队列也满了,新的任务过来时才会开始拒绝任务
public ThreadPoolExecutor(int corePoolSize,  //指定线程池的核心线程数量
                          int maximumPoolSize,  //指定线程池的最大线程数量
                          long keepAliveTime,  //制定临时线程的存活时间
                          TimeUnit unit,  //指定临时线程的存活的时间单位(秒,分,时,天)
                          BlockingQueue<Runnable> workQueue,  //指定线程池的任务队列
                          ThreadFactory threadFactory,  //指定线程池的线程工厂
                          RejectedExecutionHandler handler  //指定线程池的任务拒绝策略(线程都在忙,任务队列也满了的时候,新任务来了该怎么处理)
                         ) {}
ExecutorService pool = new ThreadPoolExecutor(3,5,8,TimeUnit.SECONDS,
                                              new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),
                                              new ThreadPoolExecutor.AbortPolicy());
2. 方式二:使用Executors(线程池的工具类)调用方法返回特点的线程池对象
package d6_threadPoolExecutor;

import d1_create_thread.MyCallable;

import java.util.concurrent.*;

public class ThreadPoolTest3 {
    public static void main(String[] args) throws Exception {

        //通过Executors创建一个线程池对象
        ExecutorService pool = Executors.newFixedThreadPool(3);

        //使用线程处理Callable任务
        Future<String> f1 = pool.submit(new d1_create_thread.MyCallable(100));
        Future f2 = pool.submit(new d1_create_thread.MyCallable(200));
        Future f3 = pool.submit(new d1_create_thread.MyCallable(300));
        Future f4 = pool.submit(new d1_create_thread.MyCallable(400));
        Future f5 = pool.submit(new MyCallable(500));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());


    }
}
线程池处理Runnable任务
package d6_threadPoolExecutor;

import java.util.concurrent.*;

public class ExecutorTest1 {
    public static void main(String[] args) {
        ExecutorService pool = new ThreadPoolExecutor(3,5,8,TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        MyRunnable target = new MyRunnable();
        pool.execute(target); //线程池会自动创建一个新线程,自动处理这个任务,自动执行
        pool.execute(target);//线程池会自动创建一个新线程,自动处理这个任务,自动执行
        pool.execute(target);//线程池会自动创建一个新线程,自动处理这个任务,自动执行
        pool.execute(target);//复用前面的线程
        pool.execute(target);//复用前面的线程
        
        pool.shutdown();//等待线程池的任务全部执行完毕后,关闭线程池
        pool.shutdownNow();//立即关闭线程池,不管任务是否执行完毕

    }
}

package d6_threadPoolExecutor;

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //描述人物任务
        System.out.println(Thread.currentThread().getName()+"输出666--");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}
线程池处理Callable任务
package d6_threadPoolExecutor;

import java.util.concurrent.Callable;

//1.让这个类实现Callable接口
public class MyCallable implements Callable {
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    //2.重写call方法
    //求1-n的和

    int sum = 0;
    @Override
    public String call() throws Exception {
        for (int i = 1; i <=n; i++) {
            sum=sum+i;
        }
        return Thread.currentThread().getName()+"线程求出了1-n的和是:"+sum;
    }
}

package d6_threadPoolExecutor;

import d1_create_thread.MyCallable;

import java.util.concurrent.*;

public class ThreadPoolTest2 {
    public static void main(String[] args) throws Exception {
        ExecutorService pool = new ThreadPoolExecutor(3,5,8, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        //使用线程处理Callable任务
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future f2 = pool.submit(new MyCallable(200));
        Future f3 = pool.submit(new MyCallable(300));
        Future f4 = pool.submit(new MyCallable(400));
        Future f5 = pool.submit(new MyCallable(500));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());


    }
}
线程的生命周期

乐观锁
package d7_tx;

import java.util.concurrent.atomic.AtomicInteger;

public class MyRunnable2 implements Runnable{

    //整数修改的乐观锁:原子类实现的
    private AtomicInteger number = new AtomicInteger();
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {

                System.out.println(number.incrementAndGet());

        }
    }
}

package d7_tx;

public class Test2 {
    public static void main(String[] args) {
        //悲观锁,乐观锁原理
        //悲观锁:一上来就加锁,没有安全感,每次只能一个线程进入访问完毕后,在解锁 .线程安全,性能较差
        //乐观锁:一开始不上锁,认为是没有问题的,大家一起跑,要等出现线程安全问题才开始控制,线程安全,性能较好

        //需求:一个静态变量,100个线程,每个线程对其加100次
        Runnable target = new MyRunnable2();
        for (int i = 1; i <= 100; i++) {
            new Thread(target).start();
        }
    }
    }
悲观锁
package d7_tx;

public class MyRunnable implements Runnable{
    private int number ;//记录浏览人次
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //悲观锁
            synchronized(this) {
                System.out.println(++number);
            }
        }
    }
}

package d7_tx;

import d7_tx.MyRunnable;

public class Test {
    public static void main(String[] args) {
        //悲观锁,乐观锁原理
        //悲观锁:一上来就加锁,没有安全感,每次只能一个线程进入访问完毕后,在解锁 .线程安全,性能较差
        //乐观锁:一开始不上锁,认为是没有问题的,大家一起跑,要等出现线程安全问题才开始控制,线程安全,性能较好

        //需求:一个静态变量,100个线程,每个线程对其加100次
        Runnable target = new MyRunnable();
        for (int i = 1; i <= 100; i++) {
            new Thread(target).start();
        }
    }
}

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

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

相关文章

逻辑卷和磁盘配额

逻辑卷和磁盘配额

文章目录 一、逻辑卷二、磁盘配额 一、逻辑卷 为什么会出现技术&#xff1f; 分区的缺点&#xff1a; 没有备份功能无法扩容性能取决于硬盘本身 相关概念 LVM 是 Logical Volume Manager 的简称&#xff0c;译为中文就是逻辑卷管理。它是 Linux 下对硬盘分区的一种管理机制。…
阅读更多...
HarmonyOS开发学习：【DevEco Device Tool 安装配置（问题全解）】

HarmonyOS开发学习：【DevEco Device Tool 安装配置（问题全解）】

本文介绍如何在Windows主机上安装DevEco Device Tool工具。 坑点总结&#xff1a; 国内部分网络环境下&#xff0c;安装npm包可能会很慢或者超时&#xff0c;推荐使用国内npm源&#xff08;如淘宝源、华为源等&#xff09;&#xff1b;serialport这个npm包安装的过程中需要编…
阅读更多...
STC8H8K64U 库函数学习笔记 —— GPIO 点灯

STC8H8K64U 库函数学习笔记 —— GPIO 点灯

STC8H8K64U 库函数学习笔记 —— GPIO 点灯 环境说明&#xff1a; 芯片&#xff1a;STC8H8K64U 软件&#xff1a; KeilC51 μVersion V5.38.00STCAI-ISP (V6.94) 不得不说&#xff0c;Keil 是我用过的 IDE 中&#xff0c;最让人头疼的事情&#xff0c;写代码就像是在记事本里编…
阅读更多...
【进阶篇】三、Java Agent实现自定义Arthas工具

【进阶篇】三、Java Agent实现自定义Arthas工具

文章目录 0、客户端代码1、JMX2、实现&#xff1a;查看内存使用情况3、实现&#xff1a;查看直接内存4、实现&#xff1a;生成堆内存快照5、实现&#xff1a;打印栈信息6、实现&#xff1a;打印类加载器的信息7、实现&#xff1a;打印类的源码8、需求&#xff1a;打印方法的耗时…
阅读更多...
OpenHarmony开发学习：【源码下载和编译】

OpenHarmony开发学习：【源码下载和编译】

本文介绍了如何下载鸿蒙系统源码&#xff0c;如何一次性配置可以编译三个目标平台&#xff08;Hi3516&#xff0c;Hi3518和Hi3861&#xff09;的编译环境&#xff0c;以及如何将源码编译为三个目标平台的二进制文件。 坑点总结&#xff1a; 下载源码基本上没有太多坑&#xff…
阅读更多...
HarmonyOS开发实例：【菜单app】

HarmonyOS开发实例：【菜单app】

简介 分布式菜单demo 模拟的是多人聚餐点菜的场景&#xff0c;不需要扫码关注公众号等一系列操作&#xff0c;通过分布式数据库可以方便每个人可及时查看到订单详情&#xff0c;数量&#xff0c;总额等&#xff1b;效果如下 demo效果 工程目录 完整的项目结构目录如下 ├…
阅读更多...
2024年DeFi的四大主导趋势：Restaking、Layer3、AI和DePin

2024年DeFi的四大主导趋势：Restaking、Layer3、AI和DePin

DeFi&#xff08;去中心化金融&#xff09;行业在2024年将继续呈现快速增长的势头&#xff0c;驱动这一增长的主要因素将是四大主导趋势&#xff1a;Restaking、Layer3、AI和DePin。这些趋势将推动DeFi生态系统的发展&#xff0c;为用户提供更多的机会和创新。 趋势1&#xff…
阅读更多...
雨云：不只是一阵清风，更是一场暴雨的力量

雨云：不只是一阵清风，更是一场暴雨的力量

引言 在网络时代&#xff0c;服务器是任何在线业务的核心。无论你是运营一家小型博客还是承载着数百万用户的大型电商平台&#xff0c;都需要一个稳定、高效的服务器来支持你的业务。然而&#xff0c;在众多服务器提供商中&#xff0c;有一家备受推崇&#xff0c;那就是雨云。 …
阅读更多...
【C语言】双向链表详解

【C语言】双向链表详解

文章目录 关于双向链表双向链表的初始化双向链表的打印双向链表方法调用 - 尾删为例双向链表的查找 - 指定位置之后插入为例双向链表结束 - 链表的销毁小结及整体代码实现 关于双向链表 首先链表有8种基本分法 其中在笔者之前文章种详细介绍的 单链表 是不带头单项不循环链表…
阅读更多...
快速解锁3D Web渲染引擎HOOPS Communicator轻量化技术

快速解锁3D Web渲染引擎HOOPS Communicator轻量化技术

在当今数字化时代&#xff0c;三维模型的使用已经成为许多行业中不可或缺的一部分。然而&#xff0c;随着模型复杂性的增加和数据量的膨胀&#xff0c;如何在Web浏览器中高效加载和渲染这些模型成为了一个挑战。慧都3D Web渲染引擎HOOPS Communicator通过其先进的轻量化技术&am…
阅读更多...
测试过程和测试生命周期

测试过程和测试生命周期

软件测试过程是一系列有计划、有组织的活动&#xff0c;旨在识别和解决软件产品中的问题。这个过程通常包括多个阶段&#xff0c;每个阶段都有其特定的目标和方法。 需求分析&#xff1a; 分析软件需求和测试需求&#xff0c;确定测试的目标和范围。理解用户需求和业务目标&…
阅读更多...
MM-Grounding-DINO的训练推理（待更新）

MM-Grounding-DINO的训练推理（待更新）

1、简单介绍 继前面发布的 GroundingDino 和 Open-GroundingDino的推理 和 Open-GroundingDino的训练实现&#xff0c;作为 GroundingDino延续性的文本检测网络 MM-Grounding-DINO 也发布了较详细的 训练和推理实现教程&#xff0c;而且操作性很强。作为学习内容&#xff0c;也…
阅读更多...
我对硬技能与软技能的认知

我对硬技能与软技能的认知

今天看到一个很有意思的一段话&#xff0c;假设一个人的技能有两种&#xff0c;分别是&#xff1a;硬技能和软技能。 硬技能通常指的是与工作直接相关的、可以通过教育和培训获得的技能&#xff0c;如编程语言、会计知识等,这些技能往往有明确的衡量标准&#xff0c;容易通过考…
阅读更多...
java 将 json 数据转为 java 中的对象

java 将 json 数据转为 java 中的对象

一、准备 json 数据 {"name": "mike","age": 17,"gender": 1,"subject": ["math","english"] }二、对应的java对象 package com.demo.controller;import lombok.Data; import java.util.List;Data pu…
阅读更多...
鸿蒙TypeScript学习第13天：【元组】

鸿蒙TypeScript学习第13天：【元组】

1、TypeScript 元组 我们知道数组中元素的数据类型都一般是相同的&#xff08;any[] 类型的数组可以不同&#xff09;&#xff0c;如果存储的元素数据类型不同&#xff0c;则需要使用元组。参考文档&#xff1a;qr23.cn/AKFP8k 元组中允许存储不同类型的元素&#xff0c;元组…
阅读更多...
【MATLAB第104期】基于MATLAB的xgboost的敏感性分析/特征值排序计算（针对多输入单输出回归预测模型）

【MATLAB第104期】基于MATLAB的xgboost的敏感性分析/特征值排序计算（针对多输入单输出回归预测模型）

【MATLAB第104期】基于MATLAB的xgboost的敏感性分析/特征值排序计算&#xff08;针对多输入单输出回归预测模型&#xff09; 因matlab的xgboost训练模型不含敏感性分析算法&#xff0c;本文通过使用single算法&#xff0c;即单特征因素对输出影响进行分析&#xff0c;得出不同…
阅读更多...
Python 进度显示工具（tqdm）

Python 进度显示工具（tqdm）

tqdm 是一个进度显示工具&#xff0c;当任务执行的等待时间较长时&#xff0c;通过tqdm模块可以模拟出一个进度条&#xff0c;由此可以看到任务执行进度&#xff0c;获得更好的体验。 文章目录 一、tqdm的安装二、tqdm的使用2.1 基于可迭代对象2.2 手动进度更新2.3 命令行模式 …
阅读更多...
【SpringBoot】mybatis-plus实现增删改查

【SpringBoot】mybatis-plus实现增删改查

mapper继承BaseMapper service 继承ServiceImpl 使用方法新增 save,updateById新增和修改方法返回boolean值,或者使用saveOrUpdate方法有id执行修改操作,没有id 执行新增操作 案例 Service public class UserService extends ServiceImpl<UserMapper,User> {// Au…
阅读更多...
mac配置Jmeter环境

mac配置Jmeter环境

mac配置Jmeter环境 一、安装jmeter二、Jmeter目录结构三、汉化Jmeter四、jmeter安装第三方插件 一、安装jmeter 第一步先自行配置好电脑的jdk环境 1、官网下载jar包 https://jmeter.apache.org/download_jmeter.cgi 2、解压到软件安装目录 3、启动Jmeter 启动方式1️⃣&#x…
阅读更多...
CSS特效---纯CSS实现点击切换按钮

CSS特效---纯CSS实现点击切换按钮

1、演示 2、一切尽在代码中 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8" /><meta http-equiv"X-UA-Compatible" content"IEedge" /><meta name"viewport" content"w…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023