多线程java

多线程的创建

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

方式一: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();
        }
    }
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

数据库体系概述：详述其基本概念、多样分类、关键作用及核心特性

数据库体系概述：详述其基本概念、多样分类、关键作用及核心特性

数据库是一个用于存储、管理和检索数据的系统&#xff0c;它按照特定的数据结构和模式组织数据&#xff0c;确保数据的一致性、安全性和高效访问。 数据库&#xff08;Database, DB&#xff09;是一个长期存储在计算机内&#xff0c;用来组织、存储和管理大量数据的集合。数据…
阅读更多...
spispi

spispi

数据手册里面有这么一段解释&#xff0c;就是说如果我们开启了看门狗&#xff0c;那么LSI就会跟随强制打开&#xff0c;等待LSI稳定之后就可以自动为独立看门狗提供时钟了。所以这里的第一步开启时钟不需要我们写代码来执行 2.写入预分频器和重装寄存器 在写入这两个寄存器之前…
阅读更多...
第十三届蓝桥杯真题：x进制减法，数组切分，gcd，青蛙过河

第十三届蓝桥杯真题：x进制减法，数组切分，gcd，青蛙过河

目录 x进制减法 数组切分 gcd 青蛙过河 x进制减法 其实就是一道观察规律的题。你发现如果a这个位置上的数x&#xff0c;b这个位置上的数是y&#xff0c;那么此位置至少是max(x,y)1进制。一定要把位置找对啊 #include <bits/stdc.h> using namespace std; typedef l…
阅读更多...
题目:建造房屋 (蓝桥OJ3362)

题目:建造房屋 (蓝桥OJ3362)

问题描述: 代码: #include<bits/stdc.h> using namespace std; int n, m, k, ans, mod 1e9 7; long long dp[55][2605]; /*dp[i][j]&#xff1a;第i个街道上建j个房屋的总方案数枚举所有的转移&#xff0c;累加到dp[n][k]即总方案数 */ int main() {cin >> n &…
阅读更多...
秋招数据库学习2（20240408-20240412共10道）

秋招数据库学习2（20240408-20240412共10道）

由于感觉数据库难度可能暂时面试用不到&#xff0c;就先不刷啦 20240408 1.从不订购的客户 SELECT Name AS Customers FROM Customers C LEFT JOIN Orders O ON C.Id O.CustomerId WHERE CustomerId is nullselect customers.name as Customers from Customers wher…
阅读更多...
蓝桥杯-最大子矩阵

蓝桥杯-最大子矩阵

问题描述 下面是一个 20x20 的矩阵&#xff0c;矩阵中的每个数字是一个1到9之间的数字&#xff0c;请注意显示时去除了分隔符号。 6985924183938786894117615876963131759284373473483266274834855367125655616786474316121686927432329479135474133499627734472797994592984…
阅读更多...
导入导出之使用EasyExcel快速进行表格导出

导入导出之使用EasyExcel快速进行表格导出

使用 EasyExcel 快速进行表格导入导出操作 在日常工作中&#xff0c;表格的导入和导出是常见的需求。针对这种情况&#xff0c;EasyExcel 提供了便捷的解决方案&#xff0c;可以快速地实现 Excel 表格的导入和导出操作。本文将介绍如何使用 EasyExcel 进行表格导出&#xff0c…
阅读更多...
path环境变量的作用

path环境变量的作用

当我把一个运行文件的路径加入到了path环境变量&#xff0c;就可以在cmd命令行随时使用运行。 在path中有两个path上面的是用户的path&#xff0c;下面的是计算机的path
阅读更多...
【图像处理】-小议YUV色彩空间-YUV和RGB格式的来由，相互关系以及转换方式，并对编程实现的YUV转为RGB程序进行介绍

【图像处理】-小议YUV色彩空间-YUV和RGB格式的来由，相互关系以及转换方式，并对编程实现的YUV转为RGB程序进行介绍

小议YUV色彩空间 摘要: 在视频图像处理等相关相关领域&#xff0c;YUV是一个经常出现的格式。本文主要以图解的资料形式详细描述YUV和RGB格式的来由&#xff0c;相互关系以及转换方式&#xff0c;并对编程实现的YUV转为RGB程序进行介绍。 1 引言 自然界的颜色千变万化&#xff…
阅读更多...
C# Solidworks二次开发：模型中实体Entity相关操作API详解

C# Solidworks二次开发：模型中实体Entity相关操作API详解

大家好&#xff0c;今天要讲的一些API是关于实体的相关API。 在开发的过程&#xff0c;很多地方会涉及到实体的相关操作&#xff0c;比如通过实体选中节点。下面就直接开始介绍API&#xff1a; &#xff08;1&#xff09;第一个API为Select4&#xff0c;这个API的含义为选中一…
阅读更多...
编译器领域一些特别好的文章

编译器领域一些特别好的文章

xz​​​​​​​s​​​​​​​cv_note/cv算法工程师成长路线.md at master HarleysZhang/cv_note GitHub记录cv算法工程师的成长之路&#xff0c;分享计算机视觉和模型压缩部署技术栈笔记。https://harleyszhang.github.io/cv_note/ - cv_note/cv算法工程师成长路线.md at…
阅读更多...
Llama2模型本地部署(Mac M1 16G)

Llama2模型本地部署(Mac M1 16G)

环境准备 环境&#xff1a;Mac M1 16G、Conda Conda创建环境配置 使用Anaconda-Navigator创建python 3.8环境 切换到新建的conda环境&#xff1a; conda activate llama38 llama.cpp 找一个目录&#xff0c;下载llama.cpp git clone https://github.com/ggerganov/llama.…
阅读更多...
【汇编】计算机系统构成

【汇编】计算机系统构成

计算机系统构成 计算机系统包括硬件和软件两部分 硬件 典型的计算机结构包括 中央处理器(CPU)、存储器和输入输出(I/O)子系统 三个主要组成部分&#xff0c;用系统总线把它们连接在一起 计算机硬件组成与各部分之间的联系 软件 计算机软件可以分为系统软件和用户软件两大类 …
阅读更多...
​​​​网络编程学习探索系列之——广播原理剖析

​​​​网络编程学习探索系列之——广播原理剖析

hello &#xff01;大家好呀&#xff01; 欢迎大家来到我的网络编程系列之广播原理剖析&#xff0c;在这篇文章中&#xff0c; 你将会学习到如何在网络编程中利用广播来与局域网内加入某个特定广播组的主机&#xff01; 希望这篇文章能对你有所帮助&#xff0c;大家要是觉得我写…
阅读更多...
集运公司代购系统|轻松为国外客户代购转运中国电商平台货物

集运公司代购系统|轻松为国外客户代购转运中国电商平台货物

做集运的公司会有大量的在国外的客户&#xff0c;客户会有需求购买中国电商平台&#xff0c;如淘宝、1688、京东等的货物。使用代购系统可以实现让客户在系统中搜索查找国内电商平台的货源&#xff0c;自动下单付款&#xff0c;支持多语言多货币支付。 查看演示网站 前台/会员中…
阅读更多...
常用组合逻辑电路模块(3)：数据选择器

常用组合逻辑电路模块(3)：数据选择器

数据选择器概述 数据选择&#xff1a;指经过选择&#xff0c;将多路数据中的某一路数据传到公共数据线上。(相当于多个输入的单刀多掷开关) 数据选择器&#xff1a;能实现数据选择功能的逻辑电路。也称多路选择器或多路开关。如下图为4选1数据选择器&#xff1a; 对于4选1数据…
阅读更多...
电大搜题：为您解锁学习的新大门

电大搜题：为您解锁学习的新大门

近年来&#xff0c;随着社会的不断进步和教育的普及化&#xff0c;广大民众对学习的需求也越来越迫切。在这个信息爆炸的时代&#xff0c;大家对于获取准确、可靠学习资料的渴望日益增长。正是基于这样的背景&#xff0c;黑龙江开放大学&#xff08;简称黑开大&#xff09;与广…
阅读更多...
Linux学习_进程等待和替换

Linux学习_进程等待和替换

1.进程等待 概述&#xff1a;父进程通过进程等待的方式&#xff0c;回收子进程资源&#xff0c;获取子进程退出信息 1.1等待方法 wait&#xff1a; #include<sys/types.h> #include<sys/wait.h> pid_t wait(int*status); 返回值&#xff1a; 成功返回被等待进程…
阅读更多...
【MATLAB基础】频谱分析

【MATLAB基础】频谱分析

01.引言 频率是单位时间内某事件重复发生的次数,用ω表示,单位是赫兹(Hz)。设m时间内某事件重复发生n次,则此事件发生的频率ω为一。又因为周期定义为重复事件发生的最小时间间隔,故频率也可以表示为周期的倒数:ωn/m,T表示周期。频率是一个很重要的概念,在工程数学中常用于分…
阅读更多...
BST：一款功能强大的二进制字符串代码格式转换工具

BST：一款功能强大的二进制字符串代码格式转换工具

关于BST BST是一款功能强大的二进制字符串代码格式转换工具&#xff0c;该工具可以将二进制字符串转换为能够兼容不同语言源代码的各种格式&#xff0c;以满足各种安全开发领域中的渗透测试或漏洞利用开发场景。 功能介绍 1、将二进制文件转换并转储为二进制字符串格式的标准输…
阅读更多...
最新文章

Copyright @ 2022~2023