JAVA多线程_2021学习理解_SXL

最新推荐文章于 2022-02-16 19:22:07 发布
最新推荐文章于 2022-02-16 19:22:07 发布
阅读量334 收藏
点赞数 1
分类专栏： java 文章标签： 多线程 java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43230154/article/details/116302256
版权

JAVA多线程_2021学习理解_SXL

引言

做个俗人，贪财好色，一身正气。

一、多线程理解（基本概念整理）

1.1 线程和进程

进程
一个内存中运行的应用程序，每个进程都有一个独立的内存空间。

线程
进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程。

线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程。

1.2 线程调度

分时调度
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度
优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

1.3 同步与异步

同步:排队执行 , 效率低但是安全
异步:同时执行 , 效率高但是数据不安全

二、线程的实现方式

每个线程都有自己的一份栈空间，共用一份堆内存。

2.1 继承Thread

public class Test {

    public static void main(String[] args) {
        MyThread m = new MyThread();
        // 启动m线程
        m.start();

		// 以匿名内部类实现的线程
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("匿名内部类实现的线程" + i);
            }
        }).start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程" + i);
        }

    }

}

class MyThread extends Thread {

    /**
     * run方法是线程要执行的方法
     */
    @Override
    public void run() {
        // 此处是一条新的执行路径
        // 执行此处不是调用run()方法，而是调用Thread对象的start()方法来启动任务线程
        for (int i = 0; i < 10; i++) {
            System.out.println("MyThread线程" + i);
        }
    }
}

2.2 实现Runnable（频率多）

实现Runnable 和 继承Thread相比有如下优势：

  1. 通过创建任务，然后给线程分配的方式实现的多线程，更适合多个线程执行相同任务的情况
  2. 可以避免单继承所带来的局限性，接口是可以多实现的
  3. 任务和程序是分离的，提高了程序的健壮性
  4. 线程池技术，接受Runnable类型的任务，不接受Thread类型的线程
public class Test{

    public static void main(String[] args) {
        // 实现Runnable
        // 创建一个任务对象
        MyRunnable r = new MyRunnable();
        // 创建一个线程，分配一个任务
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t1.start();
        t2.start();
    }

}

class MyRunnable implements Runnable {

    /**
     * run方法是线程要执行的方法
     */
    @Override
    public void run() {
        // 此处是一条新的执行路径
        // 执行此处不是调用run()方法，而是调用Thread对象的start()方法来启动任务线程
        for (int i = 0; i < 10; i++) {
            System.out.println("MyRunnable线程" + i);
        }
    }
}

2.3 实现Callable（频率少）

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class test1 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // Callable写法实现
        Callable<Integer> c = new MyCallable();
        FutureTask<Integer> task = new FutureTask<>(c);
        Thread t = new Thread(task, "子线程");
        t.start();
        // 主线程不进行参与直到完成
        Integer j = task.get();
        System.out.println("分割线===================" + j);

        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + i);
        }
    }

}

class MyCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        // Thread.sleep(3000);
        for (int i = 0; i < 10; i++) {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + i);
        }
        return 100;
    }

}

三、Thread类

线程分为守护线程和用户线程

  • 用户线程：当一个进程不包含任何的存活的用户线程时，进行结束
  • 守护线程：守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡
public class Test2 {

    public static void main(String[] args) throws InterruptedException {
        // 线程的休眠 sleep
        // 输出 每隔一秒循环输出数字
        /*for (int i = 0; i < 10; i++) {
            System.out.println(i);
            Thread.sleep(1000);
        }*/

        Thread t0 = new Thread(new MyRunnable(), "守护线程");
        // 设置守护线程
        t0.setDaemon(true);
        t0.start();

        Thread t1 = new Thread(new MyRunnable());
        t1.start();
        // 添加中断标记
        t1.interrupt();

        // 获取线程名称
        // currentThread() 获取当前线程对象
        // 输出main
        System.out.println(Thread.currentThread().getName());
        // 输出MyRunnable子线程 Thread-num等形式
        // new Thread(new MyRunnable(), "MyRunnable子线程").start();

        for (int i = 0; i < 3; i++) {
            System.out.println(i);
            Thread.sleep(1000);
        }
    }

}

class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("又是风评梁静的一天。==");
                // 结束run方法，等于线程执行完成。
                return;
            }
        }
    }
}

四、线程安全问题

同步代码块和同步方法都属于隐式锁。

Java默认的是非公平锁
公平锁：多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。（实现方法：Lock l = new ReentrantLock(true); 显示锁构造方法中参数为true表示为公平锁）
非公平锁：多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，如果能获取到，就直接获取到锁。

4.1 同步代码块和同步方法

public class Test {

    public static void main(String[] args) {
        Runnable runnable = new Ticket();
        Thread t1 = new Thread(runnable,"窗口1");
        Thread t2 = new Thread(runnable,"窗口2");
        Thread t3 = new Thread(runnable,"窗口3");

        t1.start();
        t2.start();
        t3.start();
    }

}

class Ticket implements Runnable {

    // 票数
    private int count = 1000;

    @Override
    public void run() {

        // 解决方案2：同步方法
        /*while (true) {
            Boolean flag = sale();
            if (!flag) {
                break;
            }
        }*/

        // 解决方案1：同步代码块
        // 格式： synchronized(锁对象) {}
        while (true) {
            synchronized (this) {
                if (count > 0) {
                    // 票数
                    count--;
                    System.out.println(Thread.currentThread().getName() + "余票：" + count);
                } else {
                    break;
                }
            }
        }
    }

    // synchronized 锁住对象 非静态this 静态为类.class
    public synchronized boolean sale() {
        if (count > 0) {
        // 票数
        count--;
        System.out.println(Thread.currentThread().getName() + "余票：" + count);
        return true;
        }
        return false;
    }
}

4.2 显式锁

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

public class Test {

    public static void main(String[] args) {
        // 线程不安全
        // 解决方案1：同步代码块
        // 格式： synchronized(锁对象) {}
        Runnable runnable = new Ticket();
        Thread t1 = new Thread(runnable,"窗口1");
        Thread t2 = new Thread(runnable,"窗口2");
        Thread t3 = new Thread(runnable,"窗口3");

        t1.start();
        t2.start();
        t3.start();
    }

}

class Ticket implements Runnable {

    // 票数
    private int count = 1000;

    // 显示锁
    Lock l = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
        	// 此处最好有try catch 防止死锁等异常
            l.lock();
            if (count > 0) {
                // 票数
                count--;
                System.out.println(Thread.currentThread().getName() + "余票：" + count);
            } else {
                break;
            }
            l.unlock();
        }
    }
}

4.3 notifyAll 和 wait

public class test {

    public static void main(String[] args) {
        Food food = new Food();
        new Cooker(food).start();
        new Waiter(food).start();
    }

}

/**
 * 厨师
 */
class Cooker extends Thread {

    private Food food;

    public Cooker(Food food) {
        this.food = food;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                food.setNameAndTaste("馒头", "淡的");
            } else {
                food.setNameAndTaste("酸菜", "酸的");
            }
        }
    }
}

/**
 * 服务生
 */
class Waiter extends Thread {

    private Food food;

    public Waiter(Food food) {
        this.food = food;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            food.get();
        }
    }

}

/**
 * 食物
 */
class Food {

    private String name;

    private String taste;

    private Boolean flag = true;

    public synchronized void setNameAndTaste(String name, String taste) {
        if (flag) {
            this.name = name;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.taste = taste;
            flag = false;
            // notifyAll唤醒此对象所有线程
            this.notifyAll();
            // wait此线程等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    public synchronized void get() {
        if (!flag) {
            System.out.println("服务生菜名称：" + name + ",味道:" + taste);
            flag = true;
            // notifyAll唤醒此对象所有线程
            this.notifyAll();
            // wait此线程等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getTaste() {
        return taste;
    }

    public void setTaste(String taste) {
        this.taste = taste;
    }
}

五、线程池

线程池 Executors
并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，创建线程和销毁线程需要时间，频繁的创建线程就会大大影响系统的效率。线程池容纳了多个线程，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

线程池的好处

  • 降低资源消耗。
  • 提高响应速度。
  • 提高线程的可管理性。

5.1 缓存线程池

/**
*  缓存线程池.
*  (长度无限制)
*  执行流程:
*  1. 判断线程池是否存在空闲线程
*  2. 存在则使用
*  3. 不存在,则创建线程并放入线程池, 然后使用
*/
public class test {

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

        // 向线程池中加入新的任务
        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(() -> System.out.println(Thread.currentThread().getName()));
        service.execute(() -> System.out.println(Thread.currentThread().getName()));
        service.execute(() -> System.out.println(Thread.currentThread().getName()));

        Thread.sleep(1000);
        // 输出结果是上面三个空闲的线程
        service.execute(() -> System.out.println(Thread.currentThread().getName()));
    }

}

5.2 定长线程池

/**
*  定长线程池.
*  (长度是指定的数值)
*  执行流程:
*  1. 判断线程池是否存在空闲线程
*  2. 存在则使用
*  3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
*  4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*/
public class test {

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

        // 向线程池中加入新的任务
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        });

        service.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        });

        service.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread.sleep(1000);
        service.execute(() -> {
            System.out.println(Thread.currentThread().getName());
        });
    }

}

5.3 单线程线程池

/**
*  效果与定长线程池创建时传入数值1效果一致.
*  单线程线程池.
*  执行流程:
*  1. 判断线程池的那个线程是否空闲
*  2. 空闲则使用
*  3. 不空闲,则等待池中的单个线程空闲后使用
*/
public class test {

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

        // 向线程池中加入新的任务
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(() -> {
            System.out.println(Thread.currentThread().getName());
        });

        service.execute(() -> {
            System.out.println(Thread.currentThread().getName());
        });

        service.execute(() -> {
            System.out.println(Thread.currentThread().getName());
        });

        Thread.sleep(1000);
        service.execute(() -> {
            System.out.println(Thread.currentThread().getName());
        });
    }

}

5.4 周期定长线程池

/**
* 周期任务 定长线程池.
* 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程并放入线程池, 然后使用
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*
*  周期性任务执行时:
*  定时执行, 当某个时机触发时, 自动执行某任务
*/
public class test {

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

        // 向线程池中加入新的任务
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        /*
         * 1. 定时执行一次
         *
         * 参数1：定时执行的任务
         * 参数2：时长数字
         * 参数3：时长数字的时间单位， TimeUnit的常量指定
         */
        service.schedule(() -> {
            System.out.println(Thread.currentThread().getName());
        }, 5, TimeUnit.SECONDS);

        /*
         * 2. 周期性执行
         *
         * 参数1：定时执行的任务
         * 参数2：延迟时长数字
         * 参数3：周期时长数字
         * 参数4：时长数字的时间单位， TimeUnit的常量指定
         */
        service.scheduleAtFixedRate(() -> {
            System.out.println(Thread.currentThread().getName());
        }, 5, 1, TimeUnit.SECONDS);
    }

}

总结

人生无限，缓缓起航，修正改错，在满足完成任务的条件下，追求完善，全身而退。

松小乐
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
四面美团开发岗，成功斩获offer，这份面经总结终结篇看完就是血赚！
bieber007的博客
10-10 1860
这篇文章分享我一个学弟的美团实习面试经历，万万没想到现在大厂实习面试也这么难，下面是他的面经，各位读者老哥可以参考浏览。 美团我是在拉勾网上投的简历，之前也投过一次，简历都没通过删选，后来让学姐帮我改了一下简历，重新投另一个部门，获得了面试机会。10月23日中午HR打电话过来预约了下午4点半面试，说会在线写代码，让我准备好网络环境。结果5点半还没打电话过来，被放鸽子。与hr重新沟通过后，确定下周一下午再面，可是跟hr沟通预约这一套貌似在美团并没有什么用。 美团技术一面20分钟 晚7点，因为想到下周一才
SXL-开源
04-25
1. **易读性与简洁性**：SXL的语法设计注重清晰性和简洁性，使得代码更易于理解和维护。它采用了类似自然语言的结构，降低了学习曲线，尤其适合快速原型开发和脚本编写。 2. **动态类型**：SXL支持动态类型，这意味...
（2021最新版）Java后端面试题|Java多线程与并发
工欲善其事必先利其器
05-31 220
1、线程的生命周期？线程有几种状态 线程通常有五种状态，创建，就绪，运行、阻塞和死亡状态 (1) 新建状态（New）：新创建了一个线程对象。 (2) 就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。 (3) 运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。 (4) 阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进 入就绪状态，
2024年JAVA多线程并发编程面试题（持续更新）
GEEK-BANANA
02-18 5780
这里写目录标题并发编程基础blocked 和 waiting 的区别线程的 run()和 start()有什么区别？为什么我们调用 start() 方法时会执行 run() 方法，为什么我们不能直接调用 run() 方法？说说线程的生命周期及五种基本状态？Java 中用到的线程调度算法是什么？线程同步以及线程调度相关的方法。sleep() 和 wait() 有什么区别？线程的 sleep()方法和 yield()方法有什么区别？同步方法和同步块，哪个是更好的选择？如果你提交任务时，线程池队列已满，这时会发生
JAVA面相对象_2021学习理解_SXL
松小乐的博客
04-15 226
JAVA面相对象_2021学习理解_SXL前言一 面向对象思想1.1 面向对象概念1.2 三大思想（暂时做个标记，日后机会研究）1.3 三大特征二、类、对象、方法2.１类、对象、方法定义2.2 构造方法2.3 重载2.3.1 方法的重载2.3.2 构造的重载2.4 匿名对象三、面向对象进阶3.1 封装3.2 this3.3 static 前言 资料来源： 开课吧视频学习 部分百度资料 个人学习笔记 一 面向对象思想 1.1 面向对象概念 面向对象(Object Oriented)是软件开发方法。面向
Java注解_SXL
松小乐的博客
05-10 211
Java注解_SXL
JAVA学习视频
Minifairy的博客
03-13 3419
深知广大爱好Java的人学习是多么困难，没视频没资源，上网花钱还老被骗。为此我呕心沥血整理了这套Java教程，不管你是不懂电脑的小白，还是已经步入开发的大牛，这套路线路你都值得拥有，小白看上面的视频可以成功学会Java并且顺利工作，大神看了上面的资源肯定会谆谆乐道，教程的宗旨就是分享，专业，便利，让喜爱Java的人，都能平等的学习。首先建立好开发环境非常重要，工欲善其事，必先利其器。做任何开发，首...
Java八股文--藤原豆腐店自用
weixin_45711664的博客
02-16 1356
Java跨平台的原理 基本数据类型所占字节数 Java中存储价格为啥不用doubler，而是用BigD 双精度&单精度的区别 面向对象的特征
Java游戏编程
举目沧桑的博客
01-31 1022
游戏图形界面开发基础 AWT简介 AWT(Abstract Window Toolkit,抽象窗口工具集) 它为用户提供基础的界面构件 组件类（Component） 容器类(Container) 图形类(Graphics) 布局管理器类(LayoutManager) 在AWT中存在缺少剪切板，打印支持等缺陷，甚至没有弹出式菜单和滚动窗口，因此Swing的产生也就成为必然 Swing是纯Java语言实现的轻量级组件，它不依赖系统的支持 Swing基础 与AWT组件不同，Swing组件不能直接添加到顶层容
《Java游戏编程原理与实践教程》读书笔记（第4章——Java游戏程序的基本框架）
二木成林
11-14 4100
第4章 Java游戏程序的基本框架 4.1 动画的类型及帧频 4.1.1 动画类型 动画分为影视动画和游戏动画两种。 游戏动画是在屏幕上显示一系列连续动画画图的第一帧图形，然后在每隔很短时间显示下一帧图像，如此反复，利用人眼的视觉暂留现象而感觉好像画面的物体在运动。 也就是说游戏动画就是图像在很短时间间隔内连续显示。 4.1.2 设置合理的帧频 FPS就是每秒钟的帧数，即每秒显示多少张图像，每一帧就是一幅静态图像，电影的播放速度是24FPS，游戏速度达到10FPS就能明显感觉到动画的效果了。
sxl.rar_ODE45_ode45 algorithm_sxl_龙格库塔算法_龙格库塔算法ode45
07-15
利用龙格库塔算法ode45求解三阶微分方程
SXL-1700实验室高温电炉.doc
09-09
SXL-1700实验室高温电炉 SXL-1700实验室高温电炉是一种高温电炉，主要应用于高校、科研院所、工矿企业的低温烧结、金属退火、品质检测等领域。该炉具有优质硅钼棒加热元件，双层壳体构造和智能化控温零碎，能够提供...
java反编译工具
10-24
Java反编译工具是开发者和逆向...总之，Java反编译工具是开发者工具箱中不可或缺的一部分，它们提供了对字节码的洞察力，帮助我们理解和学习Java程序。然而，正确使用这些工具，遵循相关法规和道德标准，是非常重要的。
JAVA基础 2021学习理解
松小乐的博客
04-05 3137
2021年java基础理解前言一、JVM和GC1.java跨平台运行原理二、使用步骤1.引入库2.读入数据总结 前言 提示：资料来源： 1.开课吧视频学习 2.部分网络资料 一、JVM和GC 1.java跨平台运行原理 java源码进行编译成字节码（.class文件），此文件可以被jvm虚拟机识别转化，然后通过在各个操作系统中的jvm虚拟机实现跨平台运行。 去国外旅游，找一个既懂中文（字节码），也懂其他语言（日语、英语等）的翻译，可以让你无障碍的与他人进行交流。 JVM理解 jvm可以理解成一个可运行
JAVA网络编程_基本代码实现_SXL
松小乐的博客
05-03 1838
JAVA网络编程_基本代码实现_SXL
JAVA常用类库_SXL
松小乐的博客
04-23 545
JAVA常用类库_SXL引言一、 泛型1.1 泛型类1.2 泛型接口1.3 泛型方法1.4 泛型限定1.5 泛型通配二、Objects类 引言 做个俗人，贪财好色，一身正气。 一、 泛型 泛型：指的是把类、接口或者方法等原本具有的具体类型进行参数化，然后在使用或者调用过程中传入各样参数。 使用泛型可以提高代码的复用率，而且泛型中的类型在使用时指定，不需要强制类型转换（类型安全，编译器会检查类型）。值得注意的是泛型只是在编译阶段中有效，在编译之后程序会采取去泛型化的措施，运行过程中，泛型信息是不存在的。
JAVA数据格式_SXL
松小乐的博客
05-10 460
JAVA数据格式引言一、XML1.1 XML介绍1.2 XML解析描述1.3 DOM4J解析XML（重点）1.4 Java生成XML(不常用)1.5 XStream二、JSON2.1 GSON(推荐使用，稳定)2.2 FastJson（国内喜爱）总结 引言 做个俗人，贪财好色，一身正气。 部分资料来源开课吧视频学习 一、XML 1.1 XML介绍 xml是可扩展标记性语言。 xml特性是有平台无关性（独立的标记语言）和自我描述性。 xml学习的好处是网络数据传输、数据存储和文件的配置。 xml数据可以储
IO_SXL
松小乐的博客
04-29 442
IO_SXL
nginx配置多个server_name
最新发布
08-24
要配置多个server_name，可以在nginx配置文件中的每个server块中使用server_name指令。server_name指令后面可以跟多个主机名称，用空格或逗号分隔。例如，假设我们要配置两个主机名称为www.example.com和example.com的server块，可以按照以下方式进行配置： ``` server { listen 80; server_name www.example.com example.com; location / { root /usr/www/luban; index index.html index.htm; } } ``` 在上述配置中，我们使用了两个主机名称，分别是www.example.com和example.com。这样配置后，当请求的主机名为www.example.com或example.com时，Nginx会将请求路由到该server块中的相应location。注意，server_name指令中的名称可以使用通配符和正则表达式进行匹配，以支持更多灵活的配置需求。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [Nginx 配置与使用](https://blog.csdn.net/sxl123sxl/article/details/119878924)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值