Java_21_多线程01

最新推荐文章于 2024-06-14 15:02:13 发布
最新推荐文章于 2024-06-14 15:02:13 发布
阅读量47 收藏
点赞数
分类专栏： Java基础教程 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a_shmily_/article/details/131781996
版权

多线程

  1. 什么是进程？
    程序是静止的，运行中的程序就是进程。

  2. 进程的三个特征：

    1. 动态性 ： 进程是运行中的程序，要动态的占用内存，CPU和网络等资源。
    2. 独立性 ： 进程与进程之间是相互独立的，彼此有自己的独立内存区域。
    3. 并发性 ： 假如CPU是单核，同一个时刻其实内存中只有一个进程在被执行。
      CPU会分时轮询切换依次为每个进程服务，因为切换的速度非常
      快，给我们的感觉这些进程在同时执行，这就是并发性。

  3. 并行:同一个时刻同时有多个在执行。

  4. 什么是线程？
    线程是属于进程的。一个进程可以包含多个线程，这就是多线程。
    线程是进程中的一个独立执行单元。
    线程创建开销相对于进程来说比较小。
    线程也支持“并发性”。

  5. 线程的作用：
    可以提高程序的效率，线程也支持并发性，可以有更多机会得到CPU。
    多线程可以解决很多业务模型。
    大型高并发技术的核心技术。
    设计到多线程的开发可能都比较难理解。
    多线程是很有用的，我们在进程中创建线程的方式有三种:
    （1）直接定义一个类继承线程类Thread，重写run()方法，创建线程对象
    调用线程对象的start()方法启动线程。
    （2）定义一个线程任务类实现Runnable接口，重写run()方法，创建线程任务对象，把
    线程任务对象包装成线程对象， 调用线程对象的start()方法启动线程。
    （3）实现Callable接口（拓展）。

线程的创建方式

多线程是很有用的，我们在进程中创建线程的方式有三种:
（1）直接定义一个类继承线程类Thread，重写run()方法，创建线程对象
调用线程对象的start()方法启动线程。
（2）定义一个线程任务类实现Runnable接口，重写run()方法，创建线程任务对象，把
线程任务对象包装成线程对象， 调用线程对象的start()方法启动线程。
（3）实现Callable接口（拓展）。

创建方式一

  1. 继承Thread类的方式

    1. 定义一个线程类继承Thread类。
    2. 重写run()方法
    3. 创建一个新的线程对象。
    4. 调用线程对象的start()方法启动线程。

  2. 继承Thread类的优缺点：

    1. 优点：编码简单。
    2. 缺点：线程类已经继承了Thread类无法继承其他类了，功能不能通过继承拓展（单继承的局限性）
      小结：

  3. 线程类是继承了Thread的类。
    启动线程必须调用start()方法。
    多线程是并发抢占CPU执行，所以在执行的过程中会出现并发随机性。

注意事项
  1. 线程的启动必须调用start()方法。否则当成普通类处理。
    - 如果线程直接调用run()方法，相当于变成了普通类的执行，此时将只有主线程在执行他们！
    - start()方法底层其实是给CPU注册当前线程，并且触发run()方法执行
  2. 建议线程先创建子线程，主线程的任务放在之后。否则主线程永远是先执行完！
线程常用的API

Thread类的API:

  1. public void setName(String name):给当前线程取名字。
  2. public void getName():获取当前线程的名字。
    – 线程存在默认名称，子线程的默认名称是：Thread-索引。
    – 主线程的默认名称就是：main
  3. public static Thread currentThread()
    – 获取当前线程对象，这个代码在哪个线程中，就得到哪个线程对象。
public class ThreadDemo01 {
    //启动后的ThreadDemo当成一个进程
    // main方法是由主线程执行的，理解成main方法就是一个主线程
    public static void main(String[] args){
        //创建线程对象
        Thread t = new MyThread();
        t.setName("Thread-01");
        //启动线程
        t.start();
        Thread t1 = new MyThread();
        t1.setName("Thread-02");
        t1.start();
        for(int i = 0;i < 50;i ++) System.out.println(Thread.currentThread().getName() + "==>" + i);
    }
}
//定义一个线程类继承Thread类
class MyThread extends Thread{
    //重写run方法
    @Override
    public void run(){
        //线程的执行方法
        for(int i = 0;i < 50; i ++){
            System.out.println(Thread.currentThread().getName() + "==>" + i);
        }
    }
}
线程休眠

public static void sleep(long time): 让当前线程休眠多少毫秒再继续执行。

public class ThreadDemo02 {
    public static void main(String[] aregs){
        for(int i = 0;i < 10;i ++){
            System.out.println(i);
            try{
                Thread.sleep(1000);
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}
通过有参构造器取名字

通过Thread类的有参数构造器为当前线程对象取名字。
– public Thread()
– public Thread(String name):创建线程对象并取名字。

在这里插入图片描述

创建方式二

  1. 多线程是很有用的，我们在进程中创建线程的方式有三种:
    （1）直接定义一个类继承线程类Thread，重写run()方法，创建线程对象
    调用线程对象的start()方法启动线程。
    （2）定义一个线程任务类实现Runnable接口，重写run()方法，创建线程任务对象，把
    线程任务对象包装成线程对象， 调用线程对象的start()方法启动线程。
    （3）实现Callable接口（拓展）。

  2. 实现Runnable接口的方式。

    1. 创建一个线程任务类实现Runnable接口。
    2. 重写run()方法
    3. 创建一个线程任务对象。
    4. 把线程任务对象包装成线程对象
    5. 调用线程对象的start()方法启动线程。
      Thread的构造器：
      – public Thread(){}
      – public Thread(String name){}
      – public Thread(Runnable target){}
      – public Thread(Runnable target,String name){}

  3. 实现Runnable接口创建线程的优缺点：
    缺点：代码复杂一点。
    优点：

    1. 线程任务类只是实现了Runnable接口，可以继续继承其他类，而且可以继续实现其他接口（避免了单继承的局限性）
    2. 同一个线程任务对象可以被包装成多个线程对象
    3. 适合多个多个线程去共享同一个资源（后面内容）
    4. 实现解耦操作，线程任务代码可以被多个线程共享，线程任务代码和线程独立。
    5. 线程池可以放入实现Runable或Callable线程任务对象。(后面了解)

  4. 注意：其实Thread类本身也是实现了Runnable接口的。
    – 不能直接得到线程执行的结果！

//实现Runnable接口的方式创建线程
public class ThreadDemo03 {
    public static void main(String[] args){
        //3.创建线程任务对象 不是线程对象 仅负责执行线程任务
        Runnable target = new MyRunnable();
        //4.将线程任务对象包装成线程对象
        Thread t = new Thread(target,"Thread-01");
        //5.调用start启动线程
        t.start();
        //主线程任务
        for(int i = 0;i < 50;i ++)
            System.out.println(Thread.currentThread().getName() + "==>" + i);
    }
}
// 1.创建一个线程任务类实现Runnable接口。
class MyRunnable implements Runnable{
    // 2.重写run()方法
    @Override
    public void run(){
        for(int i = 0;i < 50;i ++)
            System.out.println(Thread.currentThread().getName() + "==>" + i);
    }
}
方式二的匿名内部类写法
//3.创建线程任务对象 不是线程对象 仅负责执行线程任务
        Runnable target = new Runnable(){  //使用匿名内部类写法
            @Override
            public void run(){
                for(int i = 0;i < 50;i ++)
                    System.out.println(Thread.currentThread().getName() + "==>" + i);
            }
        };

创建方式三

  1. 多线程是很有用的，我们在进程中创建线程的方式有三种:
    （1）直接定义一个类继承线程类Thread，重写run()方法，创建线程对象
    调用线程对象的start()方法启动线程。
    （2）定义一个线程任务类实现Runnable接口，重写run()方法，创建线程任务对象，把
    线程任务对象包装成线程对象， 调用线程对象的start()方法启动线程。
    （3）实现Callable接口（拓展）。

  2. 线程的创建方式三: 实现Callable接口。
    – 1,定义一个线程任务类实现Callable接口 ， 申明线程执行的结果类型。
    – 2,重写线程任务类的call方法，这个方法可以直接返回执行的结果。
    – 3,创建一个Callable的线程任务对象。
    – 4,把Callable的线程任务对象包装成一个未来任务对象。
    – 5.把未来任务对象包装成线程对象。
    – 6.调用线程的start()方法启动线程

  3. 优缺点：
    优点：全是优点。
    – 线程任务类只是实现了Callable接口，可以继续继承其他类，而且可以继续实现其他接口（避免了单继承的局限性）
    – 同一个线程任务对象可以被包装成多个线程对象
    – 适合多个多个线程去共享同一个资源（后面内容）
    – 实现解耦操作，线程任务代码可以被多个线程共享，线程任务代码和线程独立。
    – 线程池可以放入实现Runable或Callable线程任务对象。(后面了解)
    – 能直接得到线程执行的结果！
    缺点：编码复杂。

public class ThreadDemo {
    public static void main(String[] args) {
        // 3.创建一个Callable的线程任务对象
        Callable call = new MyCallable();
        // 4.把Callable任务对象包装成一个未来任务对象
        //      -- public FutureTask(Callable<V> callable)
        // 未来任务对象是啥，有啥用？
        //      -- 未来任务对象其实就是一个Runnable对象:这样就可以被包装成线程对象！
        //      -- 未来任务对象可以在线程执行完毕之后去得到线程执行的结果。
        FutureTask<String> task = new FutureTask<>(call);
        // 5.把未来任务对象包装成线程对象
        Thread t = new Thread(task);
        // 6.启动线程对象
        t.start();

        for(int i = 1 ; i <= 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+" => " + i);
        }

        // 在最后去获取线程执行的结果,如果线程没有结果，让出CPU等线程执行完再来取结果
        try {
            String rs = task.get(); // 获取call方法返回的结果（正常/异常结果）
            System.out.println(rs);
        }  catch (Exception e) {
            e.printStackTrace();
        }

    }
}

// 1.创建一个线程任务类实现Callable接口，申明线程返回的结果类型
class MyCallable implements Callable<String>{
    // 2.重写线程任务类的call方法！
    @Override
    public String call() throws Exception {
        // 需求：计算1-10的和返回
        int sum = 0 ;
        for(int i = 1 ; i <= 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+" => " + i);
            sum+=i;
        }
        return Thread.currentThread().getName()+"执行的结果是："+sum;
    }
}

线程安全

  1. 线程安全问题：多个线程同时操作同一个共享资源的时候可能会出现线程安全问题。

  2. 模拟出取款问题的案例：
    注意：用高度面向对象的思想设计。
    分析：
    （1）提供一个账户类Account.java作为创建共享资源账户对象的类。
    （2）定义一个线程类来用于创建2个线程分别代表小明和小红来取钱。
    小结：
    多个线程同时操作同一个共享资源的时候可能会出现线程安全问题。

举例：
在这里插入图片描述
线程类

//定义线程类创建两个线程分别代表两个人来取钱
public class DrawThread implements Runnable {

    private Account Share_acc;
    public DrawThread(Account Share_acc){
        this.Share_acc = Share_acc;
    }
    @Override
    public void run(){
        //小明、小红都来取100000
        Share_acc.drawMoney(100000);
    }
}

账户类

//账户类--作为创建共享资源账户对象的类
public class Account {
    private String cardID;
    private double money;

    public Account() {
    }

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

    /**
     * 获取
     * @return cardID
     */
    public String getCardID() {
        return cardID;
    }

    /**
     * 设置
     * @param cardID
     */
    public void setCardID(String cardID) {
        this.cardID = cardID;
    }

    /**
     * 获取
     * @return money
     */
    public double getMoney() {
        return money;
    }

    /**
     * 设置
     * @param money
     */
    public void setMoney(double money) {
        this.money = money;
    }

    public String toString() {
        return "Account{cardID = " + cardID + ", money = " + money + "}";
    }

    public void drawMoney(double money) {
        /**开始判断取钱逻辑*/
        //1.谁来取钱
        String name = Thread.currentThread().getName();
        //2.判断余额是否足够
        if(this.money >= money)
        {
            System.out.println(name + "来取钱,余额充足！取出" + money);
            //3.更新余额
            this.money -= money;
            System.out.println(name + "取出钱后,剩余" + this.money);
        }else System.out.println(name + "来取钱,余额不足！");

    }
}

主函数

public class ThreadSafe {
    public static void main(String[] args){
        
        //创建共享资源账户对象
        //创建两个线程对象去账户对象中取钱
        Account Share_acc = new Account("ICBC-01",100000);
        Runnable Little_Ming = new DrawThread(Share_acc);
        Thread Ming = new Thread(Little_Ming,"LittleMing");
        Ming.start();

        Runnable Little_Hong = new DrawThread(Share_acc);
        Thread Hong = new Thread(Little_Hong,"LittleHong");
        Hong.start();
        
        /*Thread Little_Ming = new Thread( Share_acc,"LittleMing");
        Little_Ming.start();

        Thread Little_Hong = new Thread( Share_acc,"LittleHong");
        Little_Hong.start();*/
    }
}

由上可知,两个账户同时取共享账户的100000块钱,会发生冲突！！！账户就不安全了。

线程同步

  1. 线程同步的作用：就是为了解决线程安全问题的方案。

  2. 线程同步解决线程安全问题的核心思想：
    让多个线程实现先后依次访问共享资源，这样就解决了安全问题。

  3. 线程同步的做法：加锁
    是把共享资源进行上锁，每次只能一个线程进入访问完毕以后，其他线程才能进来。

  4. 线程同步的方式有三种：
    （1）同步代码块。
    （2）同步方法。
    （3）lock显示锁。

  5. 同步代码块。

    1. 作用：把出现线程安全问题的核心代码给上锁，每次只能一个线程进入
      执行完毕以后自动解锁，其他线程才可以进来执行。

    2. 格式：
      synchronized(锁对象){
      // 访问共享资源的核心代码
      }

    3. 锁对象：理论上可以是任意的“唯一”对象即可。

    4. 原则上：锁对象建议使用共享资源。
      – 在实例方法中建议用this作为锁对象。此时this正好是共享资源！必须代码高度面向对象
      – 在静态方法中建议用类名.class字节码作为锁对象。

同步代码块

代码如下：

    public void drawMoney(double money) {
        /**开始判断取钱逻辑*/
        //1.谁来取钱
        String name = Thread.currentThread().getName();
        //2.判断余额是否足够  synchronized上锁
        synchronized("Lock"){
            if(this.money >= money)
            {
                System.out.println(name + "来取钱,余额充足！取出" + money);
                //3.更新余额
                this.money -= money;
                System.out.println(name + "取出钱后,剩余" + this.money);
            }else System.out.println(name + "来取钱,余额不足！");
        }
    }

将取钱代码块上锁即可！！！

运行结果：
LittleMing来取钱,余额充足！取出100000.0
LittleMing取出钱后,剩余0.0
LittleHong来取钱,余额不足！

在这里插入图片描述

在synchronized代码块中,synchronized就像是一个门,只允许一个线程通过,多个线程要排队！

同步方法

同步方法

  1. 作用：把出现线程安全问题的核心方法给锁起来，
    每次只能一个线程进入访问，其他线程必须在方法外面等待。
  2. 用法：直接给方法加上一个修饰符 synchronized.
  3. 原理: 同步方法的原理和同步代码块的底层原理其实是完全一样的，只是
    同步方法是把整个方法的代码都锁起来的。
    同步方法其实底层也是有锁对象的：
    如果方法是实例方法：同步方法默认用this作为的锁对象。
    如果方法是静态方法：同步方法默认用类名.class作为的锁对象。
	//直接将方法锁起来
    public synchronized void drawMoney(double money) {
        /**开始判断取钱逻辑*/
        //1.谁来取钱
        String name = Thread.currentThread().getName();
        //2.判断余额是否足够  synchronized上锁
        if(this.money >= money)
        {
            System.out.println(name + "来取钱,余额充足！取出" + money);
            //3.更新余额
            this.money -= money;
            System.out.println(name + "取出钱后,剩余" + this.money);
        }else System.out.println(name + "来取钱,余额不足！");
    }

Lock锁

lock显示锁。

  1. java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大

  2. Lock锁也称同步锁，加锁与释放锁方法化了，如下：
    - public void lock() :加同步锁。
    - public void unlock():释放同步锁。

  3. 总结：
    线程安全，性能差。
    线程不安全性能好。假如开发中不会存在多线程安全问题，建议使用线程不安全的设计类。

public class Account {
    private String cardID;
    private double money;
    //创建锁对象：账户对象对于小明小红唯一,所以锁对象对于小明小红也唯一
    private final Lock lock = new ReentrantLock();
    public  void drawMoney(double money) {
        /**开始判断取钱逻辑*/
        //1.谁来取钱
        String name = Thread.currentThread().getName();
        //2.判断余额是否足够
        lock.lock();//上锁
        try{
            if(this.money >= money)
            {
                System.out.println(name + "来取钱,余额充足！取出" + money);
                //3.更新余额
                this.money -= money;
                System.out.println(name + "取出钱后,剩余" + this.money);
            }else System.out.println(name + "来取钱,余额不足！");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock(); //解锁
        }
    }
}

万一某个用户取钱出现异常,不加异常判断的话会被永远上锁，不严谨！

总结：
线程安全，性能差。
线程不安全性能好。假如开发中不会存在多线程安全问题，建议使用线程不安全的设计类。

沐鑫本鑫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
（38）21.3.8 线程本地存储---Java编程思想之并发笔记
njiang的专栏
12-31 529
1.防止任务在共享资源上产生冲突的第二种方式是根除对变量的共享。        线程本地存储是一种自动化机制，可以为使用相同变量的每个不同的线程都创建不同的存储。因此如果你有5个线程都要使用变量x所表示的对象，那线程本地存储就会生成5个用于x的不同的存储块。主要是，它们使得你可以将状态与线程关联起来。 2.创建和管理本地线程由java.lang.ThreadLocal类实现
Java基础21 多线程线程两种实现方式 锁
Xs943的博客
02-17 1036
多线程的概念 1.程序 ：一个固定逻辑与数据的集合 就称为程序 例如淘宝 贪吃蛇小游戏 2.CPU: 中央处理器 主要用于协调程序与硬件进行配置的工作 3.并发与并行 1.并发（高并发） 在同一个时间段 执行两个或者多个任务 单核cpu 是进行相互切换 执行某一个任务 切换速度是非常快 很容易误解是同时执行的 其实是交替执行 2.并行 在同一时刻 执行两个或者是多个任务的时候 多核cpu是同时执行多个任务 同时执行 目前的电脑都是使用多核 例子: 可以听歌 敲代码 看视频 1.进程: 运行在内存中的程序
java多线程嵌套_Java多线程进阶
weixin_36002897的博客
02-16 4170
需要理解锁是什么意思?首先是发生在多线程的情况下;线程a,线程b,共享资源share例如,share的资源一次只能被一个对象操作,这时候需要一个东西来标识(也叫监视器)出来表明该资源已经有人(指的是线程)在使用了,请还要使用的人(指的是线程)进入等待(线程等待池/队列);怎么实现呢?synchronized关键字,配合一个唯一的东西,可以是类.class,也可以是对象本身;但注意的是必须是一个引用...
万字图解Java多线程
热门推荐
qq_35598736的博客
09-06 5万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
JavaEE____多线程1
biteqq的博客
03-22 395
文章目录一. 线程使用1. 线程休眠演示打印电影字幕2.多线程性能 VS 单线程性能2.1单线程执行时间2.2 多线程执行时间3.线程3种创建方式3.1创建方式1：继承Threada) 使用 jconsole 观察线程b) 启动线程——start方法3.2创建方式2：实现Runnable接口（4种写法）3.3创建方式3：实现 Callable 接口进行实现（2种写法） 一. 线程使用 1. 线程休眠演示打印电影字幕 /* * 使用线程实现电影旁白的打印 * */ public class ThreadDem
java_Thread.rar_java 多线程_java多线程
09-21
Java多线程实例，是学习java多线程的好方法
java多线程设计模式_java_设计模式_多线程_多线程课题_
09-29
多线程与并发处理是程序设计好坏优劣的重要课题，本书通过浅显易懂的文字和示例来介绍与java线程相关的设计模式理念
javaduoxiancheng.rar_多线程 java
09-24
基于java应用语言的多线程同步机制，实现了java中的同步多线程
DownTheradsUitl.zip_java 多线程下载
07-15
自己写的Java多线程下载类，可以自己定义下载线程，自己定义下载目录，带断点续传
clientThread.rar_java 多线程_java 聊天
09-19
改开发程序是基于java开发的客户端聊天程序,实现了多线程
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 352
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 508
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
盲盒App开发时有哪些技术框架可以借鉴
最新发布
bytekj的博客
06-14 577
在开发盲盒App时，可以根据项目需求和团队技术栈选择合适的技术框架。前端可以选择微信小程序框架、React Native或Vue.js等；后端可以选择Node.js或Spring Boot等；数据库可以选择MySQL或MongoDB等。同时，还需要考虑缓存、消息队列、支付和物流接口等其他技术来完善应用的功能和性能。
【Java02】Java中数组的定义与初始化
饮冰室
06-10 626
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
SpringBoot之请求映射原理
好记性不如烂笔头
06-12 1255
我们发出的请求，SpringMVC是如何精准定位到那个Controller以及具体方法？其实这都是 HandlerMapping 发挥的作用，这篇博文我们以 RequestMappingHandlerMapping 为例并结合源码一步步进行分析。默认 HandlerMapping 主要定义在和其祖父类中获取所有类型是 Object 的 beans，并且 beanName 不以开头根据 beanName 获取 beanType如果 beanType 上存在注解则进行处理。
微型操作系统内核源码详解系列四（3）：操作系统调度算法（FreeRTOS内核篇上）
2301_77061352的博客
06-12 846
-uxTopPriority，被设定为是代表最大优先级的数字，自减操作代表从就绪列表最后一个链表（优先级最高的链表）开始查找，直到找到任务链表不为空的优先级任务，那么这个任务肯定也是所有任务中优先级最大的任务，然后获取这个任务的TCB并更新pxCurrentTCB（切换的具体函数），最后更新uxTopReadyPriority的值。容笔者说一下个人看法，从c语言和数据结构算法的层面学习，只能说是舍本逐末，透过Freertos这个小型系统，窥见庞大的操作系统架构的一角，这才是我们学习的重点。
Invalid keystore format，获取安全码SHA1值出错
yfy1907的博客
06-11 203
Invalid keystore format 错误
从零手写实现 nginx-20-placeholder 占位符 $
06-12 1155
大家好，我是老马。很高兴遇到你。我们为 java 开发者实现了 java 版本的 nginx如果你想知道 servlet 如何处理的，可以参考我的另一个项目：手写从零实现简易版 tomcatminicat除了内置变量，Nginx 还允许用户自定义变量。自定义变量可以在set指令中定义。在这个例子中，定义了一个自定义变量，其值为，并在响应中返回这个值。Nginx 支持占位符的主要目的是提供更高的灵活性和动态性，使其能够适应各种复杂的应用场景和需求。
【Hydro】SCS-CN方法中径流曲线数的确定（下）
```On Earth, Be Water, By Coding```
06-11 119
在[【Hydro】SCS-CN方法中径流曲线数的确定（上）](https://blog.csdn.net/qq_25262697/article/details/133796329)中已经介绍了SCS-CN在SWAT和HMS中的应用，以下会补充SCS-CN在XPSWMM、InfoWorks ICM中的应用。以及使用软件计算SCS-CN的步骤。
socket 多线程 java_Java Socket 通信之多线程
06-03
在 Java 中进行 Socket 通信时，我们可以使用多线程来实现同时与多个客户端进行通信。这种方式可以提高服务器的并发处理能力。 具体实现方法是，服务器端使用一个主线程监听客户端的连接请求，当有新的连接请求时，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

沐鑫本鑫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值