2021-10-20

最新推荐文章于 2024-07-12 15:51:39 发布
最新推荐文章于 2024-07-12 15:51:39 发布
阅读量86 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q20011/article/details/120873477
版权

并发/多线程: 工作基本不用，面试使劲问

进程和线程 Java没有多进程，也不能操纵进程。 Java只有多线程

程序是死的，安装/存放在硬盘上而已。 进程：程序的一次动态执行过程就是进程。

随着程序越来越大，进程也就会占用更多的资源，CPU在对其进行调度时也就会越发吃力。 比如30万人移动基地。

正是由于以上原因，我们发明了更加轻量级别的进程，即线程。 一个进程可以派生出多个线程。

这种拆分后，进程不再被进行调度，而是成为了资源持有的单位。 线程反而成为了资源调度的单位（只带有一点点运行所必须的资源）

线程是轻量级的进程，线程是调度的基本单元，进程是资源持有的基本单元。

写多线程
1. 写一个任务，任务是多线程到底要做什么事情。
任务应该写一个类实现Runnable接口，将任务的具体操作放入这个接口的run方法中。

public class PrintChar implements Runnable {
    private char c;

    public PrintChar(char c) {
        this.c = c;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.printf("%-3c", c);
        }
    }
}

public class PrintNum implements Runnable {
    private int num;

    public PrintNum(int num) {
        this.num = num;
    }

    @Override
    public void run() {
        for (int i = 1; i <= num; i++) {
            System.out.printf("%-3d", i);
        }
    }
}

 start: 开始执行

构造一个Thread对象，将任务放入这个Thread对象

调用Thread对象的start方法

 public static void main(String[] args) {
        PrintChar printChar = new PrintChar('A');
        PrintNum printNum = new PrintNum(5);

//        printChar.run();
//        printNum.run();

        Thread t1 = new Thread(printChar); // 构造了一个线程对象，这个线程的任务是打印A
        Thread t2 = new Thread(printNum); // 构造了一个线程对象，但是这个线程并没有执行

        t1.start(); // start才是让这个线程去执行对应的任务
        // 这句话开始执行时，此时的程序
        t2.start();


    }
public class AccountWithoutSync {
    private static Account account = new Account();

    private static class Account{
        private int balance = 0; // 余额

        public int getBalance() { // 去除余额
            return balance;
        }

        public synchronized void deposit(int amount) { // 存amount金额的钱
            int newBalance = balance + amount;
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            balance = newBalance;
        }
    }

    public static class AddPennyTask implements Runnable {

        @Override
        public void run() {
            account.deposit(1);
        }
    }

    public static void main(String[] args) {
        // newCachedThreadPool根据需求开设线程
        ExecutorService executorService = Executors.newCachedThreadPool();

        for (int i = 0; i < 100; i++)
            executorService.execute(new AddPennyTask());

        executorService.shutdown();

        while (!executorService.isTerminated());
//        Thread.sleep(1000);
        System.out.println(account.getBalance());
    }
}

ExecutorService线程池

newCachedThreadPool：根据需求开设线程 

x.join(); // 插入
Thread.sleep(100); // 睡眠

用Lambda表达式改写上面的代码

public static void main(String[] args) {
        new Thread(() -> {
            Thread x = new Thread(new PrintChar('X'));
            x.start();
            for (int i = 1; i <= 10; i++) {
                if (i == 4){
                    try {
                        x.join(); // 插入
//                        Thread.sleep(100); // 睡眠
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
//                Thread.yield(); // 让出CPU给其他线程优先执行，但是并不绝对
                System.out.printf("%-3c", 'A');
            }
        }).start();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                System.out.printf("%-3d", i);
            }
        }).start();
    }

Thread类中的常见方法：

  1. sleep ：睡眠
  2. yield ：让出CPU给其他线程先执行
  3. join ：//插入，这个线程无论如何在被加塞的线程前优先做完。

sleep()和对象.join的结果一定是可以确定的

yield()的结果是完全不确定的

 public static void main(String[] args) {
        // ExecutorService 或者其父类接口 Executor 就被认为是线程池
        // Executors 是一个用于创建线程池的工具类
        // newFixedThreadPool 用于创建一个具有固定数量的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 一个三线程的线程池只是说可以同时开三个线程，多余的任务可以等等
        // execute方法类似于start方法，用于执行一个线程
        executor.execute(new PrintChar('A'));
        executor.execute(new PrintChar('B'));
        executor.execute(new PrintChar('C'));
        executor.execute(new PrintChar('D'));

        // shutdown用于关闭线程池，这个关闭虽然不是阻塞的，但是它会等待线程池中所有线程全部执行完毕后才关闭线程池
        executor.shutdown();
    }

线程同步： 让多个线程按照我们的要求有序执行

public class AccountWithoutSync {
    private static Account account = new Account();

    private static class AddPennyTask implements Runnable {
        @Override
        public void run() {
            account.deposit(1);
        }
    }
    
    private static class Account{
        private int balance = 0; //余额
        public int getBalance() { //取出余额
            return balance;
        }
        public void deposit(int amount) { //存amount金额的钱
            int newBalance = balance + amount;
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            balance = newBalance;
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        //newCachedThreadPool根据需求开设线程
        for (int i = 0; i < 100; i++)
            executorService.execute(new AddPennyTask());
    
        executorService.shutdown();
    
        while (!executorService.isTerminated());
        //isTerminated用于判断线程池是否已经全部做完
    
        System.out.println(account.getBalance());
    }

}
public class Account {
    private final Object o = new Object();
    private int balance = 0; //余额, 多个线程进行争抢的资源被称作“临界资源”
    public int getBalance() { //取出余额
        return balance;
    }
    public void deposit(int amount) { //存amount金额的钱
        //用于操纵临界资源的代码段被称作“临界区”
        synchronized (o) {  //同步块
            int newBalance = balance + amount;
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            balance = newBalance;
        }
    }
}
public class AddPennyTask implements Runnable{
    private final Account account;

    public AddPennyTask(Account account) {
        this.account = account;
    }
    
    @Override
    public void run() {
        account.deposit(1);
    }

}
public class AccountWithoutSync {

    public static void main(String[] args) throws InterruptedException {
        Account account = new Account();
    
        ExecutorService executorService = Executors.newCachedThreadPool();
        //newCachedThreadPool根据需求开设线程
        for (int i = 0; i < 100; i++)
            executorService.execute(new AddPennyTask(account));
    
        executorService.shutdown();
    
        while (!executorService.isTerminated());
        //isTerminated用于判断线程池是否已经全部做完
    
        System.out.println(account.getBalance());
    }

}

线程间协作：两个线程根据具体情况有条不紊的相互合作。

public class Account {
    private int balance = 0; //余额, 多个线程进行争抢的资源被称作“临界资源”
    private Lock lock = new ReentrantLock(); //获得一把锁
    private Condition condition = lock.newCondition(); //锁的条件，也叫条件锁

    public int getBalance() { //取出余额
        return balance;
    }
    
    public void withdraw(int amount) {
        lock.lock();
        try{
            while(balance < amount) {
                System.out.printf("\t\t\t现在我打算取%d元，但是余额不足，暂时等待\n", amount);
                condition.await(); //await将当前这个线程自我阻塞
            }
            balance -= amount;
            System.out.printf("\t\t\t已经取了%d元钱，账户余额是%d.\n", amount,  getBalance());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    
    public void deposit(int amount) {
        lock.lock();
        try {
            balance += amount;
            System.out.println("已经存入" + amount);
            condition.signalAll(); //signal用于随机释放一个正在阻塞的进程，加all用于释放所有被阻塞的进程
        } finally {
            lock.unlock();
        }
    }

}


public class DepositTask implements Runnable{
    private final Account account;

    public DepositTask(Account account) {
        this.account = account;
    }
    
    @Override
    public void run() {
        while(true) {
            account.deposit((int)(Math.random() * 10));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}


public class WithdrawTask implements Runnable{
    private final Account account;

    public WithdrawTask(Account account) {
        this.account = account;
    }
    
    @Override
    public void run() {
        while(true)
            account.withdraw((int)(Math.random() * 10));
    }

}


public class AccountWithoutSync {

    public static void main(String[] args) throws InterruptedException {
        Account account = new Account();
    
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        executorService.execute(new DepositTask(account));
        executorService.execute(new WithdrawTask(account));
        executorService.shutdown();
    
    }

}

使用synchronized改写上面的代码

public class Account {
    private int balance = 0; //余额, 多个线程进行争抢的资源被称作“临界资源”

    public int getBalance() { //取出余额
        return balance;
    }
    
    public synchronized void withdraw(int amount) {
        try {
            while (balance < amount) {
                System.out.printf("\t\t\t现在我打算取%d元，但是余额不足，暂时等待\n", amount);
                wait();
            }
            balance -= amount;
            System.out.printf("\t\t\t已经取了%d元钱，账户余额是%d.\n", amount, getBalance());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public synchronized void deposit(int amount) {
        balance += amount;
        System.out.println("已经存入" + amount);
        notifyAll();
    }

}

改成同步块之后的版本：

public class Account {
    private int balance = 0; //余额, 多个线程进行争抢的资源被称作“临界资源”
    public int getBalance() { //取出余额
        return balance;
    }

    public  void withdraw(int amount) {
        synchronized (this) {
            try {
                while (balance < amount) {
                    System.out.printf("\t\t\t现在我打算取%d元，但是余额不足，暂时等待\n", amount);
                    wait();
                }
                balance -= amount;
                System.out.printf("\t\t\t已经取了%d元钱，账户余额是%d.\n", amount, getBalance());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public synchronized void deposit(int amount) {
        synchronized (this) {
            balance += amount;
            System.out.println("已经存入" + amount);
            notifyAll();
        }
    }

}

生产者和消费者

public class Buffer {
    private static final int CAPACITY = 1;
    private final Queue<Integer> queue = new ArrayDeque<>(CAPACITY);
    private final Lock lock = new ReentrantLock();
    private final Condition write = lock.newCondition();
    private final Condition read = lock.newCondition();
    

    public void write(int value) {
        lock.lock();
        try{
            while(queue.size() == CAPACITY) {
                System.out.println("生产者现在暂停");
                write.await();
            }
            //程序如果能执行到此处，就意味着仓库中是不满的，可以生产
            queue.offer(value);
            read.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    } 
    
    public int read() {
        int value = 0;
        lock.lock();
        try{
            while (queue.isEmpty()) {
                System.out.println("\t\t\t仓库中为空，暂停消费");
                read.await();
            }
            //程序运行到此处，意味着仓库中非空，可以消费，同时也可以生
            value = queue.poll();
            write.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return value;
    }

}
public class ProducerTask implements Runnable { private Buffer buffer;

public ProducerTask(Buffer buffer) {
    this.buffer = buffer;
}
​
@Override
public void run() {
    int i = 1;
    while(true) {
        buffer.write(i);
        System.out.println("生产了对象：" + i++);
        try {
            Thread.sleep((int)(Math.random()*10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

}
public class ConsumerTask implements Runnable{ private Buffer buffer;

public ConsumerTask(Buffer buffer) {
    this.buffer = buffer;
}
​
@Override
public void run() {
    while(true) {
        System.out.println("\t\t\t消费者消费了: " + buffer.read());
        try {
            Thread.sleep((int)(Math.random()*10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

}
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors;

public class Test { public static void main(String[] args) { Buffer buffer = new Buffer(); ExecutorService executorService = Executors.newFixedThreadPool(2); executorService.execute(new ProducerTask(buffer)); executorService.execute(new ConsumerTask(buffer)); executorService.shutdown(); } }

阻塞队列 删除Buffer类，变成阻塞队列。 package com.example;

import java.util.concurrent.ArrayBlockingQueue;

public class ProducerTask implements Runnable { private ArrayBlockingQueue<Integer> buffer;

public ProducerTask(ArrayBlockingQueue<Integer>  buffer) {
    this.buffer = buffer;
}
​
@Override
public void run() {
    int i = 1;
    while(true) {
        try {
            buffer.put(i);
            System.out.println("生产者生产了对象：" + i++);
            Thread.sleep((int)(Math.random()*10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

}
import java.util.concurrent.ArrayBlockingQueue;

public class ConsumerTask implements Runnable{ private ArrayBlockingQueue<Integer> buffer;

public ConsumerTask(ArrayBlockingQueue<Integer> buffer) {
    this.buffer = buffer;
}
​
@Override
public void run() {
    while(true) {
        try {
            System.out.println("\t\t\t消费者消费了: " + buffer.take());
            Thread.sleep((int)(Math.random()*10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

}
public class Test { 
    public static void main(String[] args) { 
        ArrayBlockingQueue<Integer> buffer = new ArrayBlockingQueue<>(1);         
        ExecutorService executorService = Executors.newFixedThreadPool(2);             
        executorService.execute(new ProducerTask(buffer)); 
        executorService.execute(new ConsumerTask(buffer)); 
        executorService.shutdown(); } 
    }

阻塞队列

删除Buffer类，变成阻塞队列

public class ProducerTask implements Runnable { private ArrayBlockingQueue<Integer> buffer;

public ProducerTask(ArrayBlockingQueue<Integer>  buffer) {
    this.buffer = buffer;
}
​
@Override
public void run() {
    int i = 1;
    while(true) {
        try {
            buffer.put(i);
            System.out.println("生产者生产了对象：" + i++);
            Thread.sleep((int)(Math.random()*10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

  

public class ConsumerTask implements Runnable{ private ArrayBlockingQueue<Integer> buffer;

public ConsumerTask(ArrayBlockingQueue<Integer> buffer) {
    this.buffer = buffer;
}
​
@Override
public void run() {
    while(true) {
        try {
            System.out.println("\t\t\t消费者消费了: " + buffer.take());
            Thread.sleep((int)(Math.random()*10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

 

  

public class Test { 
    public static void main(String[] args) { 
        ArrayBlockingQueue<Integer> buffer = new ArrayBlockingQueue<>(1);     
        ExecutorService executorService = Executors.newFixedThreadPool(2);         
        executorService.execute(new ProducerTask(buffer)); 
        executorService.execute(new ConsumerTask(buffer)); 
        executorService.shutdown(); 
    } 
}

信号量

信号量就好比是一把锁有1个或多个钥匙。 比如一个被信号量包起来的代码（类似于同步块）可以限制有几个线程能够同时访问。

死锁：多个线程为了争抢有限的资源，从而导致谁都没办法获得全部资源得以运行。 哲学家就餐

线程的几种状态及其之间的转换

  1. 新建（新生）——一个线程被新建，就是new一个Thread
  2. 就绪——一个线程已经拥有了运行所需要的全部资源，唯独只差CPU yield（）
  3. 运行——同一时间只能有一个线程是运行的。 run()
  4. 阻塞（等待）——线程因为缺乏某种资源导致无法就绪 4.1 等待目标完成——某个线程在等待某个事件结束，join加塞的必须先做完 4.2 等待超时——某个线程因为时间问题导致无法运行，sleep睡眠 4.3 等待通知——等待其余线程通知其继续运行，wait自我阻塞
  5. 结束（死亡）——线程运行结束了

操作系统中规定，只有就绪态才能转为运行态 在操作系统中，会有很多线程处于就绪状态，这些线程通常都被放在一个就绪队列中

public class AddTask implements Runnable{ private List<Integer> list; AtomicInteger num;

public AddTask(List<Integer> list, AtomicInteger num) {
    this.list = list;
    this.num = num;
}
​
@Override
public void run() {
    System.out.println(num.incrementAndGet());
    for (int i = 0; i < list.size(); i++) {
        list.set(i, list.get(i) + 1); //+1操作不是多线程安全的，此处只有get和set方法才是多线程安全的
    }
}

  

public class Test { public static void main(String[] args) { List<Integer> list = new ArrayList<>(); list.add(1);list.add(1);list.add(1); AtomicInteger num = new AtomicInteger(0);

    List<Integer> syncList = Collections.synchronizedList(list);
​
    ExecutorService executorService = Executors.newFixedThreadPool(100);
    for (int i = 0; i < 100; i++) {
        executorService.execute(new AddTask(syncList, num));
    }
    executorService.shutdown();
​
    while(!executorService.isShutdown());
​
    System.out.println(num);


}

q20011
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2021-10-20 python安装第三方库，报错Failed to build
bailian的博客
10-20 7501
python安装第三方库，报错Failed to build prophet 系统：WIN10 软件：Anaconda Prompt 起因与问题 执行 pip install prophet 或 python -m pip install prophet 安装失败,报错有点长， Looking in indexes: https://pypi.tuna.tsinghua.edu.cn/simple Collecting prophet Using cached https://pypi.tuna.t
域内提权 (CVE-2021-42278 & CVE-2021-42287) 漏洞利用
Captain_RB的博客
07-03 2935
2021年11月，Microsoft 曝出了两个关于 Windows AD 域提权的漏洞：CVE-2021-42278 & CVE-2021-42287，CVSS V3.1评分均为8.8，两个漏洞组合可导致域内普通用户提升至域管权限，文章主要对漏洞利用使用的两种自动化脚本进行介绍。...............
IllegalArgumentException: Parameter value [2021-10-20] did not match expected type [java.util.Date (
qq_44209563的博客
10-20 2556
问题 在使用JPA时， 数据库表的日期字段city_date数据类型为 date 数据库表对应类的属性cityDate 类型为Date 使用jpa的方法查询，但是以cityDate的值作为查询条件时，参数类型定义成了String 使用到该方法进行查询时，显示错误 IllegalArgumentException: Parameter value [2021-10-20] did not match expected type [java.util.Date (n/a)] 解决 把方法的参数类型从Str
CVE-2021-36934复现
江左盟的博客
07-24 1万+
漏洞简介 微软在7月20日发布紧急安全公告，公开了一个Windows提权漏洞。由于对多个系统文件（包括安全帐户管理器 (SAM) 数据库）的访问控制列表 (ACL) 过于宽松，攻击者可读取SAM，SYSTEM，SECURITY等文件内容，进而获取用户NTLM Hash值，从而通过解密Hash值或Hash传递等方法造成特权提升漏洞。成功利用此漏洞的攻击者可以使用 SYSTEM 权限运行任意代码。 影响范围 微软确认此问题会影响 Windows 10 版本 1809 和更新的操作系统，其他版本还在确认中。 环境
CVE-2021-4034：Linux Polkit 权限提升漏洞复现及修复
热门推荐
一只爱吃橙子的羊
01-27 2万+
本文仅为验证漏洞，在本地环境测试验证，无其它目的 CVE 编号： CVE-2021-4034 漏洞说明： 近期，国外安全研究团队在 polkit 的 pkexec 中发现存在的本地权限提升漏洞（CVE-2021-4034） 关于 Polkit pkexec for Linux Polkit（以前称为 PolicyKit）是一个用于在类 Unix 操作系统中控制系统范围权限的组件。它为非特权进程与特权进程通信提供了一种有组织的方式。也可以使用 polkit 执行具有提升权限的命令，使用命令 pkexec 后
CVE-2021-40116|CVE-2021-34783等——Cicso多个安全漏洞
LiBai'S BLOG
11-14 6672
漏洞复现漏洞概述影响版本漏洞复现漏洞详情处置建议 漏洞概述 2021年10月27日，Cisco发布安全公告，修复了Cisco Firepower 威胁防御 (FTD)、Cisco思科自适应安全设备 (ASA)和Firepower 管理中心 (FMC)中的多个安全漏洞。 CISCO ASA远程任意文件读取 Cisco Adaptive Security Appliance (ASA)是思科的一种防火墙设备。 Cisco Adaptive Security Appliance (ASA)防火墙设备以及Ci
时间类型转换的问题“2021-01-20T10:09:11Z”
JavaWHD的博客
02-22 6336
关于新手碰到时间类型转换的问题： 拿到的时间为字符串，格式为：“2021-01-20T10:09:11Z”。 容易理解的解决方法： 先将该字符串转换为Date类型： SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd’T’HH:mm:ss’Z’”); Date applyDate = sdf.parse(“2021-01-20T10:09:11Z”); 再将Date类型转换为需要的字符串类型： SimpleDateFormat sdf1 = new
2021-10-30
java557的博客
10-30 5130
1、 当Leader崩溃或者Leader失去大多数的Follower，这时候ZooKeeper会进行什么操作？ B、 恢复模式 2、 以下关于云计算安全性描述中，正确的是？ B、 尽管云计算提供各项安全服务，但是我们仍然需要注意备份 3、 下面哪个公司是OpenShift的开发公司？ D、  红帽 4、 在mdadm管理RAID阵列的动作当中，Assemble的作用是什么？ D、 监控状态 5、 下列选项当中，哪个不属于数据库的性能优化？ A、 数据库配置优
Linux Polkit本地权限提升漏洞处理（CVE-2021- 4034）
企业实战系列集 ●●● https://ximenjianxue.blog.csdn.net
02-07 1万+
一、背景   安全部门近期发出安全预警，提示：常见发现版本的 CentOS、Ubuntu及Debian Linux系统中默认安装的Polkit工具集存在本地权限提升的漏洞CVE-2021- 4034），目前漏洞利用代码已在互联网公开；    Linux Polkit工具集是Linux系统在安装过程中自带的系统工具集，其中包括大量运维常用工具。该工具集中的pkexec在特定情况下无法正确处理调用参数计数，因此会尝试将环境变量作为命令执行。攻击者可以通过控制环境变量，使自身从系统普通用户权限提升至管理员权限，对
内网渗透：六、CVE-2021-42287/CVE-2021-42278 域内提权
liu_jia_liang的博客
02-22 1378
0x01简介 2021 年 11 月 9 日，国外研究员在推特上发布了 Active Directory 相关的 CVE，CVE-2021-42278 & CVE-2021-42287 ，两个漏洞组合可导致域内普通用户权限提升至域管权限。0x02 影响0x02范围 CVE-2021-42287： Windows Server 2012 R2 (Server Core installation) Windows Server 2012 R2 Windows Server 2...
2021-10-20Dll.zip
10-26
标题 "2021-10-20Dll.zip" 提示我们这是一个包含DLL文件的压缩包，可能是一个由C#编写的动态链接库（Dynamic Link Library），并且这个DLL是为跨平台使用设计的，既支持Delphi也支持C#进行调用。描述中提到的“调用...
log-aggregated-2021-10-20-080516.0005.ips
10-26
log-aggregated-2021-10-20-080516.0005.ips
2021医疗人工智能行业报告[2021-10-20]（62页）.pdf
05-19
2021医疗人工智能行业报告[2021-10-20]（62页）.pdf
CVE-2021-22192:CVE-2021-22192靶场：未授权用户RCE漏洞
03-30
CVE-2021-22192 CVE-2021-22192靶场：未授权用户RCE漏洞0x10靶场环境0x20目录结构CVE-2021-22192├── README.md ............... [此 README 说明]├── imgs .................... [辅助 README 说明的图片]├─...
【UNITED NATIONS】2021年数字经济报告（英文）[2021-10-20]（238页）.pdf
05-07
【UNITED NATIONS】2021年数字经济报告（英文）[2021-10-20]（238页）.pdf
配置Java开发环境
Broken_x的博客
07-10 1587
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
最新发布
baina666的博客
07-12 544
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
elk部署springboot
Chihirozy的博客
07-11 409
elk部署springboot。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 290
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
2021-2022年收藏的精品资料信用社考试《计算机》历年试卷二.doc
12-14
10. **磁盘清理与修复** - 清理工具可以帮助释放空间，而磁盘检查（chkdsk）用于修复磁盘错误。 11. **Word文档操作** - 在Word中插入分节符使用的是"插入"菜单中的"分页符"或"分节符"命令。 12. **格式一致性** -...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值