Java阶段一Day21

Java阶段一Day21

文章目录

  • Java阶段一Day21
    • 多线程
      • 并发原理
      • 使用场景
      • 创建并启动线程
      • 创建线程的方法
    • 进程
      • 线程的生命周期
      • 获取线程信息的方法
  • 教师总结
    • 新单词
    • 多线程
      • 概念
          • 线程:一个顺序的单一的程序执行流程就是一个线程。代码一句一句的有先后顺序的执行。
          • 多线程:多个单一顺序执行的流程并发运行。造成"感官上同时运行"的效果。
          • 并发:
          • 用途:
      • 线程的生命周期图
      • 线程的创建
        • 方式一
          • 优缺点
        • 方式二
        • 匿名内部类形式的线程创建
      • 主线程
        • java中的代码都是靠线程运行的，执行main方法的线程称为"主线程"。
      • 使用多线程实现多客户端连接服务端
        • 服务端代码改造
      • 线程API
        • 获取线程相关信息的方法
        • 线程优先级
        • sleep阻塞
          • 完成一个倒计时程序
          • sleep阻塞(续)
      • 守护线程
          • 概念
          • 用途
          • 例
    • 总结
      • 多线程
        • 线程的创建方式
        • 线程Thread类的常用方法

多线程

  • 线程：程序中单一的顺序执行流程
  • 多线程：软件或硬件中实现多个线程并发“同时”执行的技术

并发原理

  • 微观上是走走停停的，宏观上都在运行。这种现象叫并发，因此不是绝对意义上的“同时运行”
  • 操作系统将时间划分为很多时间片段（时间片），尽可能均匀分配给每一个线程，得到时间片段的线程被CPU运行，而其他线程全部等待，CPU在用高性能模拟“同时”

使用场景

  • 互不干扰，多线程通常用于在一个程序中需要同时处理多个互不干扰的任务。
  • 多线程更快，单线程中可以完成，但是多线程可以更快。

创建并启动线程

  • 定义一个类继承Thread
  • 重写run方法来定义线程要执行的任务代码
  • 调用线程的start方法启动线程

创建线程的方法

  • Thread
    • 优点：结构简单，利于匿名内部类创建
    • 缺点：
      1. 继承冲突问题：由于java单继承，导致继承Thread就无法再继承其他类实现复用，实际开发中不方便
      2. 继承Thread并重写run方法，在run方法中定义线程要执行的任务，导致线程和任务存在一个必然的耦合关系，不利于线程的重用
  • Runnable
    • 优点：没有继承Thread类，所以可以继承其他的类，适合多线程访问同一资源的情况，将cpu和数据分开，形成清晰的模型，较好的体现了面向对象的思想
    • 缺点：编程相对复杂，要想获得当前线程对象，需要使用Thread.currentThread()方法
  • Callable
    • 优点：也可以继承其他的类，多线程可以共享同一个target对象，适合多线程访问同一资源的情况，将cpu和数据分开，形成清晰的模型，较好的体现了面向对象的思想，还有返回值
    • 缺点：编程稍显复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法

进程

  • 进程是操作系统中运行的一个任务(一个应用程序运行在一个进程中)。
  • 进程(process)是一块包含了某些资源的内存区域。操作系统利用进程把它的工作划分为一些功能单元。
  • 进程中所包含的一个或多个执行单元称为线程(thread)。进程还拥有一个私有的虚拟地址空间，该空间仅能被它所包含的线程访问。
  • 线程只能归属于一个进程并且它只能访问该进程所拥有的资源。当操作系统创建一个进程后，该进程会自动申请一个名为主线程或首要线程的线程。

线程的生命周期

在这里插入图片描述

  • 新建：刚被new了的线程还未start运行
  • 就绪：线程start后还未获得时间片
  • 运行：线程获取时间片后进入运行
  • 阻塞：在线程运行过程中遇到阻塞
  • 终止：运行结束后，被GC回收

获取线程信息的方法

方法介绍
long getId()返回该线程的标识符
String getName()返回该线程的名称
int getPriority():返回线程的优先级
Thread.state getState()获取线程的状态
boolean isAlive()测试线程是否处于活动状态
boolean isDaemon()测试线程是否为守护线程
boolean isInterrupted()测试线程是否已经中断

教师总结

新单词

  • handl-处理
  • Thread-线程
  • start-开始
  • DaemonThread-守护线程
  • sleep-睡眠
  • interrupt-中断
  • alive-活着
  • priority-优先级
  • current-当前的

多线程

概念

线程的生命周期图

在这里插入图片描述

线程的创建

  1. 继承Thread并重写run方法
  2. 单独定义线程任务

方式一

继承Thread并重写run方法

定义一个线程类，重写run方法，在其中定义线程要执行的任务(希望和其他线程并发执行的任务)。

注:启动该线程要调用该线程的start方法，而不是run方法！！！

package thread;

/**
 * 多线程
 * 线程:程序中一个单一的顺序执行流程，即：线性流程
 * 多线程:多个线性流程"一起"执行。
 *
 * 线程是并发运行的。
 * 并发：线程间的代码在微观世界都是走走停停的，宏观上给我们的感受是在一起执行
 *
 * 线程的创建
 * 第一种方式:继承Thread并重写run方法
 *
 */
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t1 = new MyThread1();
        Thread t2 = new MyThread2();
        //启动线程要调用start方法，而不是直接调用run方法!!
        /*
            当我们调用线程的start方法后，线程会纳入到线程调度器中被统一管理。
            当线程第一次分配时间片后会自动调用它的run方法开始执行。
         */
        t1.start();
        t2.start();
    }
}

/**
 * 第一种创建线程的方式的优点:结构简单，利于匿名内部类创建
 * 缺点:
 * 1:存在继承冲突问题，由于java是单继承的，这导致如果我们继承了Thread就无法再
 *   继承其他类去复用方法。这在实际开发中是极其不方便的
 * 2:当我们继承Thread并重写run方法，在run方法中定义线程要执行的任务。这会导致
 *   线程与任务存在一个必然的耦合关系，不利于线程的重用。
 */
class MyThread1 extends Thread{
    public void run(){
        for (int i = 0; i < 1000; i++) {
            System.out.println("你是谁啊?");
        }
    }
}
class MyThread2 extends Thread{
    public void run(){
        for (int i = 0; i < 1000; i++) {
            System.out.println("开门，查水表的!");
        }
    }
}
优缺点

优点:

在于结构简单，便于匿名内部类形式创建。

缺点:

  • 1:直接继承线程，会导致不能在继承其他类去复用方法，这在实际开发中是非常不便的。
  • 2:定义线程的同时重写了run方法，会导致线程与线程任务绑定在了一起，不利于线程的重用。

方式二

实现Runnable接口单独定义线程任务

package thread;

/**
 * 第二种创建线程的方式:单独定义线程任务
 * 定义任务:
 * 1:实现Runnable接口
 * 2:实现Callable接口(如果线程执行完毕后需要返回值时使用，多用于线程池)
 *
 */
public class ThreadDemo2 {
    public static void main(String[] args) {
        //1创建线程要执行的任务
        Runnable r1 = new MyRunnable1();
        Runnable r2 = new MyRunnable2();
        //2创建线程
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        //3启动
        t1.start();
        t2.start();
    }
}
class MyRunnable1 implements Runnable{
    public void run(){
        for (int i = 0; i < 1000; i++) {
            System.out.println("你是谁啊?");
        }
    }
}
class MyRunnable2 implements Runnable{
    public void run(){
        for (int i = 0; i < 1000; i++) {
            System.out.println("查水表的!");
        }
    }
}

匿名内部类形式的线程创建

package thread;

/**
 * 使用匿名内部类形式完成线程的两种创建
 */
public class ThreadDemo3 {
    public static void main(String[] args) {
        //继承Thread重写run方法
        Thread t1 = new Thread(){
            public void run(){
                for (int i = 0; i < 1000; i++) {
                    System.out.println("你是谁啊?");
                }
            }
        };
        //实现Runnable接口重写run方法
//        Runnable r2 = new Runnable() {
//            public void run() {
//                for (int i = 0; i < 1000; i++) {
//                    System.out.println("我是查水表的!");
//                }
//            }
//        };
//        Thread t2 = new Thread(r2);

        //lambda表达式
//        Runnable r2 = ()->{
//            for (int i = 0; i < 1000; i++) {
//                System.out.println("我是查水表的!");
//            }
//        };
//        Thread t2 = new Thread(r2);

        Thread t2 = new Thread(()->{
            for (int i = 0; i < 1000; i++) {
                System.out.println("我是查水表的!");
            }
        });


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

主线程

java中的代码都是靠线程运行的，执行main方法的线程称为"主线程"。

线程提供了一个方法:

  • static Thread currentThread()

    该方法可以获取运行这个方法的线程

package thread;

/**
 * 主线程
 * java程序启动后，JVM会创建一条线程来执行main方法。并且JVM为该线程取名为"main"
 * 因此我们称执行main方法的线程为主线程
 *
 * 线程提供了一个静态方法:
 * static Thread currentThread()
 * 该方法可以获取运行这个方法的线程
 */
public class CurrentThreadDemo {
    public static void main(String[] args) {
        //让主线程执行该方法，此时该方法返回的就是主线程
        Thread main = Thread.currentThread();
        System.out.println(main);
        dosome();//主线程执行dosome方法

        Thread myThread = new Thread(){
            public void run(){
                dosome();//自定义线程执行dosome
            }
        };
        myThread.start();
    }

    public static void dosome(){
        //获取执行dosome方法的线程
        Thread t = Thread.currentThread();
        System.out.println("执行dosome方法的线程是:"+t);
    }
}

使用多线程实现多客户端连接服务端

若想使一个服务端可以支持多客户端连接，我们需要解决以下问题

  • 循环调用accept方法侦听客户端的连接
  • 使用线程来处理单一客户端的数据交互

因为需要处理多客户端，所以服务端要循环调用accept方法，但该方法会产生阻塞，且读取客户端的消息也是依靠一个循环完成的，这会导致它接近是一个死循环，不结束的话也会影响服务端再次调用accept方法。所以与某个客户端的交互就需要使用线程来并发处理。

在这里插入图片描述

服务端代码改造

package socket;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

/**
 * 聊天室服务端
 */
public class Server_V2 {
    /**
     * java.net.ServerSocket
     * 运行在服务端的ServerSocket主要有两个工作:
     * 1:打开服务端口，客户端就是通过这个端口与服务端建立连接的
     * 2:监听服务端口，一旦一个客户端连接，则立即返回一个Socket实例
     */
    private ServerSocket serverSocket;

    public Server_V2(){
        try {
            /*
                ServerSocket实例化的同时指定服务端口
                如果该端口被其他程序占用则会抛出异常:
                java.net.BindException:address already in use
                此时我们需要更换端口，或者杀死占用该端口的进程。

                端口号范围:0-65535
             */
            System.out.println("正在启动服务端...");
            serverSocket = new ServerSocket(8088);
            System.out.println("服务端启动完毕!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 服务端开始工作的方法
     */
    public void start(){
        try {
            /*
                ServerSocket的一个重要方法:
                Socket accept()
                该方法用于接受客户端的连接。这是一个阻塞方法，调用后会"卡住"，直到
                一个客户端与ServerSocket连接，此时该方法会立即返回一个Socket实例
                通过这个Socket实例与该客户端对等连接并进行通讯。
                相当于"接电话"的动作
             */
            while(true) {
                System.out.println("等待客户端连接...");
                Socket socket = serverSocket.accept();
                System.out.println("一个客户端连接了!");
                //启动一个线程负责与该客户端交互
                ClientHandler handler = new ClientHandler(socket);
                //创建线程
                Thread t = new Thread(handler);
                //启动线程
                t.start();

            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        Server_V2 server = new Server_V2();
        server.start();
    }

    /**
     * 第二种创建线程的方式:实现Runnable接口单独定义线程任务
     * 这个线程任务就是让一个线程与指定的客户端进行交互
     */
    private class ClientHandler implements Runnable{
        private Socket socket;

        public ClientHandler(Socket socket){
            this.socket = socket;
        }

        public void run(){
            try {
                InputStream in = socket.getInputStream();
                InputStreamReader isr = new InputStreamReader(in, StandardCharsets.UTF_8);
                BufferedReader br = new BufferedReader(isr);
                String line;
                while ((line = br.readLine()) != null) {
                    System.out.println("客户端说:" + line);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

线程API

获取线程相关信息的方法

package thread;

/**
 * 获取线程相关信息的一组方法
 */
public class ThreadInfoDemo {
    public static void main(String[] args) {
        Thread main = Thread.currentThread();//获取主线程

        String name = main.getName();//获取线程的名字
        System.out.println("名字:"+name);

        long id = main.getId();//获取该线程的唯一标识
        System.out.println("id:"+id);

        int priority = main.getPriority();//获取该线程的优先级
        System.out.println("优先级:"+priority);

        boolean isAlive = main.isAlive();//该线程是否活着
        System.out.println("是否活着:"+isAlive);

        boolean isDaemon = main.isDaemon();//是否为守护线程
        System.out.println("是否为守护线程:"+isDaemon);

        boolean isInterrupted = main.isInterrupted();//是否被中断了
        System.out.println("是否被中断了:"+isInterrupted);

    }
}

线程优先级

线程start后会纳入到线程调度器中统一管理,线程只能被动的被分配时间片并发运行,而无法主动索取时间片.线程调度器尽可能均匀的将时间片分配给每个线程.

线程有10个优先级,使用整数1-10表示

  • 1为最小优先级,10为最高优先级.5为默认值
  • 调整线程的优先级可以最大程度的干涉获取时间片的几率.优先级越高的线程获取时间片的次数越多,反之则越少.
  • Thread提供了对应的常量:MAX_PRIORITY表示最高优先级10，MIN_PRIORITY表示最低优先级，NORM_PRIORITY表示默认优先级5
package thread;

public class PriorityDemo {
    public static void main(String[] args) {
        Thread max = new Thread(){
            public void run(){
                for(int i=0;i<10000;i++){
                    System.out.println("max");
                }
            }
        };
        Thread min = new Thread(){
            public void run(){
                for(int i=0;i<10000;i++){
                    System.out.println("min");
                }
            }
        };
        Thread norm = new Thread(){
            public void run(){
                for(int i=0;i<10000;i++){
                    System.out.println("nor");
                }
            }
        };
        min.setPriority(Thread.MIN_PRIORITY);
        max.setPriority(Thread.MAX_PRIORITY);
        min.start();
        norm.start();
        max.start();
    }
}

sleep阻塞

线程提供了一个静态方法:

  • static void sleep(long ms)
  • 使运行该方法的线程进入阻塞状态指定的毫秒,超时后线程会自动回到RUNNABLE状态等待再次获取时间片并发运行.
package thread;

public class SleepDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了!");
        try {
            Thread.sleep(5000);//主线程阻塞5秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("程序结束了!");
    }
}
完成一个倒计时程序
package thread;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

/**
 * sleep阻塞
 * 线程提供了一个静态方法:
 * static void sleep(long ms)
 * 该方法可以让执行该方法的线程处于阻塞状态指定毫秒，超时后线程会再次回到RUNNABLE状态
 * 再次并发
 */
public class SleepDemo {
    public static void main(String[] args) throws IOException {
        System.out.println("程序开始了");
        /*
            简易的倒计时程序
            程序启动后在控制台上输入一个整数，从该数字开始每秒递减，到0时输出时间到
         */
//        BufferedReader br = new BufferedReader(
//                new InputStreamReader(
//                        System.in
//                )
//        );
//        System.out.println("请输入一个数字");
//        int num = Integer.parseInt(br.readLine());

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个数字");
        for(int num = scanner.nextInt();num>0;num--) {
            System.out.println(num);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("程序结束了");
    }
}
sleep阻塞(续)

sleep方法处理异常:InterruptedException.

当一个线程调用sleep方法处于睡眠阻塞的过程中,该线程的interrupt()方法被调用时,sleep方法会抛出该异常从而打断睡眠阻塞.

package thread;

/**
 * sleep方法要求必须处理中断异常
 * 当一个线程调用sleep方法处于睡眠阻塞的过程中，如果此时该线程的interrupt()方法被
 * 调用，此时会中断该线程的睡眠阻塞，那么sleep方法就会抛出中断异常。
 */
public class SleepDemo2 {
    public static void main(String[] args) {
        Thread lin = new Thread("林永健"){
            public void run(){
                System.out.println(getName()+":刚美完容，睡一会吧...");
                try {
                    Thread.sleep(500000000);
                } catch (InterruptedException e) {
                    System.out.println(getName()+":干嘛呢!干嘛呢!干嘛呢!都破了相了!");
                }
                System.out.println(getName()+":醒了");
            }
        };

        Thread huang = new Thread("黄宏"){
            public void run(){
                System.out.println(getName()+":大锤80，小锤40，开始砸墙！");
                for(int i=0;i<5;i++){
                    System.out.println(getName()+":80!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("咣当！！！");
                System.out.println(getName()+":大哥！搞定！");
                lin.interrupt();//中断lin线程的睡眠阻塞
            }
        };
        lin.start();
        huang.start();
    }
}

守护线程

概念

守护线程也称为:后台线程

  • 守护线程是通过普通线程调用setDaemon(boolean on)方法设置而来的,因此创建上与普通线程无异.
  • 守护线程的结束时机上有一点与普通线程不同,即:进程的结束.
  • 进程结束:当一个进程中的所有普通线程都结束时,进程就会结束,此时会杀掉所有正在运行的守护线程.
用途
  • GC就是运行在守护线程上的
  • 当我们有一个任务不需要关注何时结束，当程序需要结束时可以一起结束的任务就可以放在守护线程上执行
例
package thread;

/**
 * 守护线程
 * 线程提供了一个方法:
 * void setDaemon(boolean on)
 * 如果参数为true，则会将当前线程设置为守护线程。
 *
 * 守护线程与普通的用户线程(线程创建出来时默认就是用户线程)的区别在于进程结束
 *
 * 进程结束:
 * 当一个JAVA进程中所有的用户线程都结束时，进程就会结束，此时会强制杀死所有还在运行
 * 的守护线程。
 *
 * GC就是运行在一条守护线程上的。
 */
public class DaemonThreadDemo {
    public static void main(String[] args) {
        Thread rose = new Thread("rose"){
            public void run(){
                for(int i=0;i<5;i++){
                    System.out.println(getName()+":let me go !!!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                    }
                }
                System.out.println(getName()+":啊啊啊啊啊AAAAAAaaaaa....");
                System.out.println("噗通！");
            }
        };

        Thread jack = new Thread("jack"){
            public void run(){
                while(true){
                    System.out.println(getName()+":you jump!i jump!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                    }
                }
            }
        };

        rose.start();
        jack.setDaemon(true);//设置守护线程必须在线程启动前进行
        jack.start();


    }
}

总结

多线程

线程:单一的顺序执行流程就是一个线程，顺序执行:代码一句一句的先后执行。

多线程:多个线程并发执行。线程之间的代码是快速被CPU切换执行的，造成一种感官上"同时"执行的效果。

线程的创建方式

  1. 继承Thread，重写run方法，在run方法中定义线程要执行的任务

    优点:

    • 结构简单，便于匿名内部类创建

    缺点:

    • 继承冲突:由于java单继承，导致如果继承了线程就无法再继承其他类去复用方法
    • 耦合问题:线程与任务耦合在一起，不利于线程的重用。

  2. 实现Runnable接口单独定义线程任务

    优点:

    • 犹豫是实现接口，没有继承冲突问题
    • 线程与任务没有耦合关系，便于线程的重用

    缺点:

    • 创建复杂一些(其实也不能算缺点)

线程Thread类的常用方法

void run():线程本身有run方法，可以在第一种创建线程时重写该方法来定义线程任务。

void start():启动线程的方法。调用后线程被纳入到线程调度器中统一管理，并处于RUNNABLE状态，等待分配时间片开始并发运行。

      注:线程第一次获取时间片开始执行时会自动执行run方法。

              **启动线程一定是调用start方法，而不能调用run方法!**

String getName():获取线程名字

long getId():获取线程唯一标识

int getPriority():获取线程优先级，对应的是整数1-10

boolean isAlive():线程是否还活着

boolean isDaemon():是否为守护线程

boolean isInterrupted():是否被中断了

void setPriority(int priority):设置线程优先级，参数可以传入整数1-10。1为最低优先级，5为默认优先级，10为最高优先级

优先级越高的线程获取时间片的次数越多。可以使用Thread的常量MIN_PRIORITY,NORM_PRIORITY,MAX_PRIORITY。
他们分别表示最低，默认，最高优先级

static void sleep(long ms):静态方法sleep可以让运行该方法的线程阻塞参数ms指定的毫秒。

static Thread currentThread():获取运行该方法的线程。

void setDaemon(boolean on):设置线程是否为守护线程，当参数为true时当前线程被设置为守护线程。该操作必须在线程启动前进行

守护线程与普通线程的区别主要体现在当java进程中所有的普通线程都结束时进程会结束，在结束前会杀死所有还在运行的守护线程。

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

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

相关文章

Nacos 客户端服务注册源码分析-篇二

Nacos 客户端服务注册源码分析-篇二

Nacos 客户端服务注册源码分析-篇二 继续接上回&#xff0c;上回分析到 NacosNamingService 的整个注册的流程&#xff0c;其实是通过 NacosFactory.createNamingService 方法&#xff0c;反射获取 NacosNamingService 接口的实现类 NacosNamingService &#xff0c;而 NacosN…
阅读更多...
【计算方法】正交区域查询---KD-Tree概念

【计算方法】正交区域查询---KD-Tree概念

一、说明 kd 树是一种二叉树数据结构&#xff0c;可以用来进行高效的 kNN 计算。kd 树算法偏于复杂&#xff0c;本篇将先介绍以二叉树的形式来记录和索引空间的思路&#xff0c;以便读者更轻松地理解 kd 树。 二、正交区域查找 2.1 定义 对于k维空间的张量数据表格&#xff0…
阅读更多...
一键生成元宇宙 AI又杀疯了

一键生成元宇宙 AI又杀疯了

人类十几年的进步水平&#xff0c;AI用几个月就能轻易实现。在展示了超强的文本对话能力和一键生图功能后&#xff0c;AI大模型不打算停下&#xff0c;开始挑战搭建3D空间这一更高难度的动作。 这次&#xff0c;Facebook母公司Meta想当一把主导者。几天前&#xff0c;它的首席…
阅读更多...
信号生成和可视化——周期性/非周期性波形

信号生成和可视化——周期性/非周期性波形

信号生成和可视化 此示例说明如何使用 Signal Processing Toolbox™ 中提供的函数生成广泛使用的周期和非周期性波形、扫频正弦波和脉冲序列。尝试此示例Copy Command Copy Code 周期性波形 除了 MATLAB 中的 sin 和 cos 函数外&#xff0c;Signal Processing Toolbox™ 还…
阅读更多...
redis主从复制详解

redis主从复制详解

文章目录 主从复制概述主从复制的作用主要包括&#xff1a;数据冗余故障恢复负载均衡高可用基石 主从库之间采用的是读写分离的方式读操作写操作 主从复制原理全量复制确立主从关系全量复制的三个阶段第一阶段是主从库间建立连接、协商同步的过程&#xff0c;主要是为全量复制做…
阅读更多...
MobileNetV3详细原理（含torch源码）

MobileNetV3详细原理（含torch源码）

作者&#xff1a;爱笑的男孩。 个人简介&#xff1a;打工人。 持续分享&#xff1a;机器学习、深度学习、python相关内容、日常BUG解决方法及Windows&Linux实践小技巧。 如发现文章有误&#xff0c;麻烦请指出&#xff0c;我会及时去纠正。有其他需要可以私信我或者发我邮箱…
阅读更多...
Linux系统上如何禁用 USB 存储

Linux系统上如何禁用 USB 存储

Linux系统上如何禁用 USB 存储 为了保护数据不被泄漏&#xff0c;我们使用软件和硬件防火墙来限制外部未经授权的访问&#xff0c;但是数据泄露也可能发生在内部。 为了消除这种可能性&#xff0c;机构会限制和监测访问互联网&#xff0c;同时禁用 USB 存储设备。 我是艾西&…
阅读更多...
uni-app常用配置

uni-app常用配置

保存自动格式化 工具》设置》编辑器设置》保存时自动格式化 JS语法检查 安装eslint-js插件eslint-js - DCloud 插件市场用于校验js和html中的js代码https://ext.dcloud.net.cn/plugin?id2037工具》设置》插件配置》eslint-js 启用实时校检 Vue语法检查 安装eslint-vue插件…
阅读更多...
如何突破LinkedIn领英限制，导出非好友邮箱等社交方式

如何突破LinkedIn领英限制，导出非好友邮箱等社交方式

相信做外贸的朋友都有使用过Linkedin&#xff0c;如果还没有使用过的话&#xff0c;我只能说您错过一个很好的平台。只要是厉害的外贸人都特别擅长用Linkedin找客户。 那为什么说Linkedin是外贸业务员开发客户最有效的途径呢&#xff1f;主要基于以下几点&#xff1a; 第一&a…
阅读更多...
强训之【井字棋和密码强度等级】

强训之【井字棋和密码强度等级】

目录 1.井字棋1.1题目1.2思路讲解1.3代码展示 2.密码强度判断2.1题目2.2思路讲解2.3代码 3.选择题 1.井字棋 1.1题目 链接: link 描述 给定一个二维数组board&#xff0c;代表棋盘&#xff0c;其中元素为1的代表是当前玩家的棋子&#xff0c;0表示没有棋子&#xff0c;-1代表…
阅读更多...
禅道OpenAI更新至1.2版本，超多实用功能惊喜上线！

禅道OpenAI更新至1.2版本，超多实用功能惊喜上线！

广受欢迎的禅道OpenAI插件近日成功发布&#xff0c;截至目前已更新至1.2版本。 截至本版本发布&#xff0c;禅道OpenAI已经拥有了神奇海螺&#xff08;ChatGPT聊天&#xff09;、需求润色、任务润色、Bug润色及本次的需求一键生成用例功能&#xff0c;仍有更多实用的新功能正在…
阅读更多...
计算机视觉__基本图像操作（显示、读取、保存）

计算机视觉__基本图像操作（显示、读取、保存）

计算机视觉__基本图像操作&#xff08;显示、读取、保存&#xff09; 本文目录&#xff1a; ✨ 一、前言 ✨ 二、图像显示&#xff08;使用OpenCV和Matplotlib显示图像&#xff09; &#xff08;1&#xff09;、使用OpenCV显示图像 &#xff08;2&#xff09;、使用Matplotl…
阅读更多...
电磁兼容（EMC）的标准与测试内容

电磁兼容（EMC）的标准与测试内容

在国际范围上&#xff0c;电磁兼容标准的制定已经有了70多年的发展历程&#xff0c;最早为了保护无线电通信和广播&#xff0c;国际无线电干扰特别委员会&#xff08;CISPR&#xff09;对各种用电设备和系统提出了相关的电磁干扰发射限值和测量方法。到了20世纪60&#xff5e;7…
阅读更多...
被裁了，39 岁阿里 P9，攒下 1.5 亿....

被裁了，39 岁阿里 P9，攒下 1.5 亿....

今天刷知乎&#xff0c;在问题 “40 岁因为财务自由决定不上班的人&#xff0c;个人资产总和到底有多少” 下看到一位阿里 P9 的匿名回答让我狠狠的酸了一把~ 这刚刚失业的四十岁高级码农自曝了自己的人生经历&#xff0c;作为一名“阿里 P9”的程序员&#xff0c;他讲述了自己…
阅读更多...
聚观早报|阿里云正式推出通义千问；京东零售开启5年最大组织变革

聚观早报|阿里云正式推出通义千问；京东零售开启5年最大组织变革

今日要闻&#xff1a;国家网信办规范生成式人工智能服务&#xff1b;阿里云正式推出通义千问&#xff1b;京东零售开启5年来最大组织变革&#xff1b;飞书将推出智能AI助手「My AI」&#xff1b;乐高将继续扩大在华零售布局 国家网信办规范生成式人工智能服务 4 月 11 日&…
阅读更多...
redis——使用

redis——使用

session缓存缓存更新方式删除缓存vs更新缓存缓存和数据库操作原子性缓存和数据库操作顺序结论 缓存问题缓存穿透缓存雪崩缓存击穿 全局唯一ID数据并发线程安全单体分布式redis分布式锁的问题 redis消息队列listpubsubstream 消息推送 session 问题&#xff1a;session存在tomca…
阅读更多...
nginx简单使用与配置

nginx简单使用与配置

nginx简单使用与配置 Nginx 是一个高性能的HTTP和反向代理web服务器、一个邮件代理服务器&#xff0c;一个通用的 TCP/UDP 代理服务器。支持FastCGI、SSL、Virtual Host、URL Rewrite、Gzip等功能。并且支持很多第三方的模块扩展。 前端可以通过nginx实现以下功能&#xff1a…
阅读更多...
DAY 34 正则表达式

DAY 34 正则表达式

正则表达式 REGEXP&#xff1a; Regular Expressions&#xff0c;由一类特殊字符及文本字符所编写的模式&#xff0c; 其中有些字符&#xff08;元字符&#xff09;不表示字符字面意义&#xff0c;而表示控制或通配的功能&#xff0c; 类似于增强版的通配符功能&#xff0c;但…
阅读更多...
Linux--tty

Linux--tty

Linux 终端(TTY) TTY 是 Teletype 或 Teletypewriter 的缩写&#xff0c;原来是指电传打字机&#xff0c;后来这种设备逐渐键盘和显示器取代。不管是电传打字机还是键盘显示器&#xff0c;都是作为计算机的终端设备存在的&#xff0c;所以 TTY 也泛指计算机的终端(terminal)设…
阅读更多...
【面试】你在项目中遇到过慢查询问题吗？你是怎么做SQL优化的？

【面试】你在项目中遇到过慢查询问题吗？你是怎么做SQL优化的？

文章目录 前言一、找出有问题的SQL1、系统层面2、SQL语句层面 二、查看SQL执行计划三、SQL优化案例慢查询优化步骤 SQL优化小结 前言 我在面试的时候很喜欢问候选人这样一个问题&#xff1a;“你在项目中遇到过慢查询问题吗&#xff1f;你是怎么做SQL优化的&#xff1f;” 很多…
阅读更多...
最新文章

Copyright @ 2022~2023