java——多线程

最新推荐文章于 2024-05-18 16:42:38 发布
最新推荐文章于 2024-05-18 16:42:38 发布
阅读量70 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jkgojzlolzj/article/details/131776120
版权

1. 进程和线程

进程：有独立的内存空间和系统资源

线程：进程中执行运算的最小单位，可以完成一个独立的顺序控制流程

2. 多线程

在一个进程中同时运行了多个线程，用来完成不同的工作，则称之为“多线程”。

多个线程交替占用CPU资源，而非真正的并行执行。

2.1 java中创建线程的两种方式

1.继承java.lang.Thread类

请添加图片描述

2.实现java.lang.Runnable接口

请添加图片描述

2.2 使用线程的步骤

1.定义线程

2.创建线程对象

3.启动线程

4.终止线程

2.3 继承Thread类创建线程

public class MyRunnable extends Thread{

    @Override
    public void run() {
        System.out.println("这是一个线程");
    }

    public static void main(String[] args) {

        Thread thread = new MyRunnable();
        thread.start();

    }

}

优点：1.编写简单，可以直接操作线程

​ 2.适用于单继承

2.4 实现Runnable接口创建线程

public class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println("这是一个线程");
    }

    public static void main(String[] args) {

        Runnable runnable = new MyRunnable();

        Thread thread = new Thread(runnable);
        thread.start();

        Thread thread1 = new Thread(runnable);
        thread1.start();

    }

}

优点：1.避免单继承局限性

​ 2.便于共享资源

推荐使用实现Runnable接口的方式创建线程。

2.5 线程的状态

请添加图片描述

2.6 线程调度

线程调度按照指定机制为多个线程分配CPU的使用权
请添加图片描述

2.6.1 setPriority() （设置线程优先级）

线程优先级最小为1，最大为10

public class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println("这是一个线程");
    }

    public static void main(String[] args) {

        Runnable runnable = new MyRunnable();

        Thread thread = new Thread(runnable);
        thread.setPriority(10);
        thread.start();

        Thread thread1 = new Thread(runnable);
        thread1.setPriority(1);
        thread1.start();

    }

}

2.6.2 sleep() （设置线程休眠时间）

public void run() {
        System.out.println("这是一个线程");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

2.6.3 join()

public void run() {
        System.out.println("这是一个线程");
        try {
            Thread.currentThread().join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("结束该线程");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

2.7 锁机制

2.7.1 使用synchronized修饰的方法控制对类成员变量的访问

请添加图片描述

3. 等待和唤醒

//BunStore类
public class BunStore extends Thread{

    private List<String> list;

    public BunStore(List<String> list){
        this.list = list;
    }

    public void run(){
        while (true){

            synchronized (list){
                if (list.size() > 0){
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }

                list.add("生产了一个包子");

                System.out.println("包子铺生产了一个包子");

                list.notify();
            }

        }

    }



}

//Customer类
public class Customer extends Thread{

    private List<String> list;

    public Customer(List<String> list){
        this.list = list;
    }

    public void run(){
        while (true){
            synchronized (list){

                if (list.size() == 0){
                    try {
                        list.wait();

                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }

                list.remove(0);

                System.out.println("消费者吃了一个包子");

                list.notify();


            }
        }

    }


}

//Test测试类
public class Test {

    public static void main(String[] args) {

        List<String> list = new ArrayList<>();

        BunStore bunStore = new BunStore(list);
        Customer customer = new Customer(list);


        customer.start();
        bunStore.start();

    }

}

4. volatile关键字

同一个案例

不加volatile关键字

//MyVolatile类
public class MyVolatile extends Thread{

    private boolean flag = false;

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        this.flag = true;
        System.out.println("flag=" + flag);

    }
}



//Test测试类

public class Test {

    public static void main(String[] args) {

        //创建线程对象
        MyVolatile myVolatile = new MyVolatile();
        myVolatile.start();


        while (true){

            if (myVolatile.isFlag()){

                System.out.println("执行");
            }

        }

    }

}

结果为：

请添加图片描述

添加关键字volatile

//MyVolatile类
public class MyVolatile extends Thread{

    private volatile boolean flag = false;

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        this.flag = true;
        System.out.println("flag=" + flag);

    }
}



//Test测试类

public class Test {

    public static void main(String[] args) {

        //创建线程对象
        MyVolatile myVolatile = new MyVolatile();
        myVolatile.start();


        while (true){

            if (myVolatile.isFlag()){

                System.out.println("执行");
            }

        }

    }

}

结果为：

请添加图片描述

flag可以拿到更改后的值

4.1 JMM

JMM(Java Memory Model)Java内存模型,是java虚拟机规范中所定义的一种内存模型。

请添加图片描述

4.2 问题分析

未使用volatile关键字时，分析此时的程序运行情况

请添加图片描述

1.第一个线程从主内存中读取到数据，将读取到的数据放入对应的工作内存中

2.第一个线程从主内存中读取到数据后，将flag的值改为true，但还没有将更改的值写入主内存

3.此时，第二个线程也从主内存中读取到了flag = false

4.第二个线程中存在循环，而flag一直为false，所以一直在做循环，无法跳出

使用volatile关键字

请添加图片描述

5. 原子性

5.1 错误实例

public class VolatileThread implements Runnable{
    //定义数据类型为int的变量
    private int count;

    @Override
    public void run() {
        for (int i = 0; i < 5000; i++) {
            count ++;
            System.out.println("count=" + count);
        }
    }

}

public class Test {

    public static void main(String[] args) {
        VolatileThread volatileThread = new VolatileThread();

        //启动100个线程
        for (int i = 0; i < 100; i++) {
            new Thread(volatileThread).start();
        }
    }

}

结果为：

请添加图片描述

不准确

5.2 正确案例

给count++操作加锁

public class VolatileThread implements Runnable{
    //定义数据类型为int的变量
    private int count;
    
    private static final Object obj = new Object();

    @Override
    public void run() {
        for (int i = 0; i < 5000; i++) {
            synchronized (obj){
                count ++;
                System.out.println("count=" + count);
            }
        }
    }

}

public class Test {

    public static void main(String[] args) {
        VolatileThread volatileThread = new VolatileThread();

        //启动100个线程
        for (int i = 0; i < 100; i++) {
            new Thread(volatileThread).start();
        }
    }

}

结果：

请添加图片描述

5.3 问题原理

请添加图片描述

请添加图片描述

6. 并发包

6.1 ConcurrentHashMap

使用Map创建集合

public class CommonDB {

    //创建一个Map集合
    public static Map<String,String> map = new HashMap<>();

}

public class HashMapTest extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 500000; i++) {
            CommonDB.map.put(this.getName() + (i + 1), this.getName() + i + 1);
        }
        System.out.println(this.getName() + " 结束！");
    }

}

public class Test {

    public static void main(String[] args) throws InterruptedException {

        HashMapTest a1 = new HashMapTest();
        HashMapTest a2 = new HashMapTest();
        a1.setName("线程1");
        a2.setName("线程2");

        a1.start();
        a2.start();

        Thread.sleep(1000*3);

        System.out.println("Map大小：" + CommonDB.map.size());
    }

}

结果：

请添加图片描述

无法得到预期的结果

使用Hashtable创建集合

public class CommonDB {

    //创建一个Hashtable集合
    public static Hashtable<String,String> map = new Hashtable<>();

}

public class HashMapTest extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 500000; i++) {
            CommonDB.map.put(this.getName() + (i + 1), this.getName() + i + 1);
        }
        System.out.println(this.getName() + " 结束！");
    }

}

public class Test {

    public static void main(String[] args) throws InterruptedException {

        HashMapTest a1 = new HashMapTest();
        HashMapTest a2 = new HashMapTest();
        a1.setName("线程1");
        a2.setName("线程2");

        a1.start();
        a2.start();

        Thread.sleep(1000*3);

        System.out.println("Map大小：" + CommonDB.map.size());
    }

}

结果：

请添加图片描述

相比之下，线程安全了很多

使用ConcurrentHashMap创建集合

public class CommonDB {

    //创建一个ConcurrentHashMap集合
    public static ConcurrentHashMap<String,String> map = new ConcurrentHashMap<>();

}

public class HashMapTest extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 500000; i++) {
            CommonDB.map.put(this.getName() + (i + 1), this.getName() + i + 1);
        }
        System.out.println(this.getName() + " 结束！");
    }

}

public class Test {

    public static void main(String[] args) throws InterruptedException {

        HashMapTest a1 = new HashMapTest();
        HashMapTest a2 = new HashMapTest();
        a1.setName("线程1");
        a2.setName("线程2");

        a1.start();
        a2.start();

        Thread.sleep(1000*3);

        System.out.println("Map大小：" + CommonDB.map.size());
    }

}

结果：

请添加图片描述

使用ConcurrentHashMap创建集合与使用Hashtable创建集合线程都比较安全

经过测试，使用ConcurrentHashMap创建集合比使用Hashtable创建集合性能高一点

6.2 CountDownLatch

CountDownLatch允许一个或多个线程等待其他线程完成操作，再执行自己。

public CountDownLatch(int count)// 初始化一个指定计数器的CountDownLatch对象

重要方法

public void await() throws InterruptedException// 让当前线程等待
public void countDown() // 计数器进行减1

案例

public class ThreadA extends Thread {
    private CountDownLatch down ;
    public ThreadA(CountDownLatch down) {
        this.down = down;
    }
    @Override
    public void run() {
        System.out.println("A");
        try {
            down.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("C");
    }
}

public class ThreadB extends Thread {
    private CountDownLatch down ;
    public ThreadB(CountDownLatch down) {
        this.down = down;
    }
    @Override
    public void run() {
        System.out.println("B");
        down.countDown();
    }
}


public class Demo {
    public static void main(String[] args) {
        CountDownLatch down = new CountDownLatch(1);//创建1个计数器
        new ThreadA(down).start();
        new ThreadB(down).start();
    }
}

结果：

按照

​ A

​ B

​ C

的顺序打印。

6.3 CyclicBarrier

构造方法

public CyclicBarrier(int parties, Runnable barrierAction)

重要方法

public int await();

案例

public class PersonThread extends Thread {
    private CyclicBarrier cbRef;

    public PersonThread(CyclicBarrier cbRef) {
        this.cbRef = cbRef;
    }

    @Override
    public void run() {
        try {
            Thread.sleep((int) (Math.random() * 1000));
            System.out.println(Thread.currentThread().getName() + " 到了! ");
            cbRef.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}

public class MeetingThread extends Thread {
    @Override
    public void run() {
    	System.out.println("好了，人都到了，开始开会......");
    }
}


public class Demo {
	public static void main(String[] args) {
		CyclicBarrier cbRef = new CyclicBarrier(5, new MeetingThread());//等待5个线程执行完毕，再执行MeetingThread
        PersonThread p1 = new PersonThread(cbRef);
        PersonThread p2 = new PersonThread(cbRef);
        PersonThread p3 = new PersonThread(cbRef);
        PersonThread p4 = new PersonThread(cbRef);
        PersonThread p5 = new PersonThread(cbRef);
        p1.start();
        p2.start();
        p3.start();
        p4.start();
        p5.start();
	}
}

6.4 Semaphore

构造方法

public Semaphore(int permits) 
    
public Semaphore(int permits, boolean fair)

重要方法

public void acquire() throws InterruptedException 
public void release()

案例

public class Service {
    private Semaphore semaphore = new Semaphore(1);//1表示许可的意思，表示最多允许1个线程执行acquire()和release()之间的内容
    public void testMethod() {
        try {
            semaphore.acquire();
            System.out.println(Thread.currentThread().getName()
                    + " 进入 时间=" + System.currentTimeMillis());
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName()
                    + " 结束 时间=" + System.currentTimeMillis());
            semaphore.release();
			//acquire()和release()方法之间的代码为"同步代码"
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


public class ThreadA extends Thread {
    private Service service;
    public ThreadA(Service service) {
        super();
        this.service = service;
    }
    @Override
    public void run() {
        service.testMethod();
    }
}

public class Demo {
    public static void main(String[] args) {
        Service service = new Service();
		//启动5个线程
        for (int i = 1; i <= 5; i++) {
            ThreadA a = new ThreadA(service);
            a.setName("线程 " + i);
            a.start();//5个线程会同时执行Service的testMethod方法，而某个时间段只能有1个线程执行
        }
    }
}

结果：

请添加图片描述

6.5 Exchanger

Exchanger（交换者）是一个用于线程间协作的工具类。Exchanger用于进行线程间的数据交换

构造方法

public Exchanger()

重要方法

public V exchange(V x)

案例

public class ThreadA extends Thread {
    private Exchanger<String> exchanger;
    public ThreadA(Exchanger<String> exchanger) {
        super();
        this.exchanger = exchanger;
    }
    @Override
    public void run() {
        try {
            System.out.println("线程A欲传递值'礼物A'给线程B，并等待线程B的值...");
            System.out.println("在线程A中得到线程B的值=" + exchanger.exchange("礼物A"));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class ThreadB extends Thread {
    private Exchanger<String> exchanger;
    public ThreadB(Exchanger<String> exchanger) {
        super();
        this.exchanger = exchanger;
    }
    @Override
    public void run() {
        try {
            System.out.println("线程B欲传递值'礼物B'给线程A，并等待线程A的值...");
            System.out.println("在线程B中得到线程A的值=" + exchanger.exchange("礼物B"));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        Exchanger<String> exchanger = new Exchanger<String>();
        ThreadA a = new ThreadA(exchanger);
        ThreadB b = new ThreadB(exchanger);
        a.start();
        b.start();
    }
}

7. 线程池

线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操 作，无需反复创建线程而消耗过多资源。

请添加图片描述

合理利用线程池能够带来三个好处：

1.降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。

**2.提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。 **

3.提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多 的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后 死机)。

7.1 线程池的使用

public class Demo04 {
    public static void main(String[] args) throws ExecutionException,
            InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(3);
        SumCallable sc = new SumCallable(100);
        Future<Integer> fu = pool.submit(sc);
        Integer integer = fu.get();
        System.out.println("结果: " + integer);
        SumCallable sc2 = new SumCallable(200);
        Future<Integer> fu2 = pool.submit(sc2);
        Integer integer2 = fu2.get();
        System.out.println("结果: " + integer2);
        pool.shutdown();
    }
}

public class SumCallable implements Callable<Integer> {
    private int n;
    public SumCallable(int n) {
        this.n = n;
    }
    @Override
    public Integer call() throws Exception {
// 求1-n的和?
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return sum;
    }
}

8. 死锁

8.1 什么是死锁

在多线程程序中,使用了多把锁,造成线程之间相互等待.程序不往下走了。

8.2 产生死锁的条件

1.有多把锁

2.有多个线程

3.有同步代码块嵌套

8.3 案例

public class Demo05 {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        new Thread(mr).start();
        new Thread(mr).start();
    }
}
class MyRunnable implements Runnable {
    Object objA = new Object();
    Object objB = new Object();
    /*
    嵌套1 objA
    嵌套1 objB
    嵌套2 objB
    嵌套1 objA
    */
    @Override
    public void run() {
        synchronized (objA) {
            System.out.println("嵌套1 objA");
            synchronized (objB) {// t2, objA, 拿不到B锁,等待
                System.out.println("嵌套1 objB");
            }
        }
        synchronized (objB) {
            System.out.println("嵌套2 objB");
            synchronized (objA) {// t1 , objB, 拿不到A锁,等待
                System.out.println("嵌套2 objA");
            }
        }
    }
}
爱吹牛的小张
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java——多线程编程技术.pdf
12-31
Java——多线程编程技术.pdf
Java多线程编程
热门推荐
life is wonderful
06-17 1万+
Java多线程编程 Java给多线程编程提供了内置的支持。一个多线程程序包含两个或多个能并发运行的部分。程序的每一部分都称作一 个线程，并且每个线程定义了一个独立的执行路径。 多线程是多任务的一种特别的形式。多线程比多任务需要更小的开销。 这里定义和线程相关的另一个术语：进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线 程不能独立的存在，它必
Java：简述Java中的多线程编程
王小二(海阔天空)
09-03 515
Java：简述Java中的多线程编程 一、基本定义 Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。这里定义和线程相关的另一个术语 - 进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部...
高并发下Java多线程编程基础
weixin_33923148的博客
07-11 110
Java线程同步与异步 线程池 无锁化的实现方案 分布锁的实现方案 分享的目的： 进一步掌握多线程编程和应用的技巧，希望对大家在平时的开发中应对高并发编程有所帮助 Java线程同步与异步 1. 同步相关的方法有 wait, notify, notifyAll 2. 关键字 synchronized 3. JDK锁的框架 AQS (AbstractQueu...
java编写多线程
码农菜鸟的博客
07-06 406
一、线程和进程1、进程：进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.2、线程：线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源. 一个线程可以
Java多线程基础——Lock类
08-31
Lock类是Java类来提供的功能，丰富的api使得Lock类的同步功能比synchronized的同步更强大。本文对此进行详细介绍，下面跟着小编一起来看下吧
Java多线程系列——-多线程的风险问题
01-08
这篇文章，我想说明一下关于Java多线程中会遇到的几种风险以及它们的 概念 1.死锁: 死锁的含义是指一组线程在执行过程中竞争资源导致的一种阻塞的现象，其原因是其中的每一个线程都在等待仅由该组中其他线程才可以...
Java进阶学习——Java多线程知识的理解
01-20
Java多线程知识的理解0.前言1.从一道题目引入2.创建线程2.1.继承Thread类2.2.实现Runnable接口3.线程的生命周期4.线程安全4.1.为什么需要线程安全？4.2.如何实现线程安全？5.线程池5.1.为什么需要线程池？5.2.创建...
JAVA面试题——多线程.docx
06-12
JAVA面试题——多线程
Java的多线程编程
BASK2311的博客
05-16 382
由于不恰当的使用了锁，且出现同时锁住多个对象时，上例中便发生了死锁，LockA 的 run() 方法执行后，率先锁住 obj1 对象，之后 LockA 中的线程进入休眠，期间 LockB 的 run() 方法中锁住 obj2 对象。：创建一个线程的第二种方法是创建一个新的类，该类继承 Thread 类，然后创建一个该类的实例。若是该线程处于某种阻塞时被调用中断方法中断，那么并不是将该线程直接中断，而是中断其阻塞状态，这时通常会抛出中断异常，通知应用程序该线程的阻塞状态被打断。每种方式用不同的方法来实现。
java-多线程编程
weixin_53700016的博客
04-18 2223
1、基本概念 程序：是为了完成某特定任务，用某语言编写的一组指令的集合。 进程：是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位。 线程：是进程中的一个实体，作为系统调度和分派的基本单位。 一个java程序的正常运行，至少需要三个线程。（main主线程、gc垃圾回收线程、议程处理线程） 并行：多个CPU同时执行多个任务。 并发：一个CPU采用时间片的方法同时执行多个任务 2、线程的状态 新建（New）：在程序中用构造方法创建一个线程对象后，新的线程对象便
学习——Java多线程编程（简要概括）
qq_52141922的博客
03-19 1101
1.多线程技能 1.什么是线程？在进程中独立运行的子任务。 2.多线程优点？可以大幅利用CPU的空闲时间来处理其他任务。 3.什么场景使用多线程？ 1.阻塞 2.依赖。 注： 1.多线程是异步的。线程被调用时机是随机的。 2.多次调用start()方法，则出现异常Exception in thread"main"java.lang.IllegalThreadStateException. 1.使用多线程 1.继承Thread类 2.实现Runnable接口 start()方法耗时的原因？ 1）通过JVM
Java实现多线程
qq_56627079的博客
12-29 2206
文章对Java多线程各个方面进行讲解，以几种经典的线程问题来讲述线程的通信和同步问题，以及线程的几种创建方法。
Java多线程编程技术总结
Yo.o
08-12 675
目录 1、StackTraceElement[] getStackTrace()方法 2、推出线程的3中方式： 2.1、判断线程是否中断？ 3、interrupt() 4、stop() 5、suspend()和resume() 6、yield() 7、线程优先级 8、守护线程 9、Synchronized实现原理 10、脏读（dirty read） 11、可重入锁 12、同步方法的弊端，同步代码块的优势 13、对象锁 14、类Class的单例性 15、String常量池 .
jar包增量更新分析
junlaiyan的专栏
05-16 261
借助jdeps分析出jar包的增量文件
SpringBoot接入Knife4j接口文档
最新发布
博主是个二次元死肥宅~
05-18 677
Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui。
java实现拼图小游戏
monkey108的博客
05-16 620
本文主要提供用java实现的拼图小游戏源代码。
命令执行漏洞（二）
XLbb的博客
05-15 905
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
java 文件多线程
07-27
- *1* *2* *3* [【Java】网络编程——多线程下载文件](https://blog.csdn.net/qq_42470947/article/details/105889839)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值