Java阶段一Day21

news2024/7/6 21:10:55

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进程中所有的普通线程都结束时进程会结束，在结束前会杀死所有还在运行的守护线程。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

最新！AI第一次有了国家标准，北大、华为、百度等单位共同编制

最新！AI第一次有了国家标准，北大、华为、百度等单位共同编制

最近&#xff0c;国家标准全文公开系统网站正式发布了国家标准《神经网络表示与模型压缩 第一部分&#xff1a;卷积神经网络》&#xff08;GB/T 42382.1-2023&#xff09;&#xff0c;此标准由北京大学、鹏城实验室、华为、百度等16家单位共同编制。 &#xff08;来源&#xff…
阅读更多...
考试前临时抱佛脚有用吗？这篇复习攻略会告诉你答案

考试前临时抱佛脚有用吗？这篇复习攻略会告诉你答案

夏天来了&#xff0c;大家的期末考试也将不远了。不知平时大家是如何准备考试的&#xff0c;是平时学习计划有序进行复习&#xff0c;还是考试前临时抱佛脚呢&#xff1f;今天就来跟大家讲一讲&#xff0c;学习中很重要的一个环节&#xff0c;如何复习。所以敲黑板&#xff0c;…
阅读更多...
基于 AT89C51 单片机的数字时钟设计

基于 AT89C51 单片机的数字时钟设计

目录 1.设计目的、作用 2.设计要求 3.设计的具体实现 3.1 设计原理 3.2 硬件系统设计 3.2.1 AT89C51 单片机原理 3.2.2 晶振电路设计 3.2.3 复位电路设计 3.2.4 LED 数码管显示 3.3 系统实现 3.3.1 系统仿真与调试 3.3.2 演示结果 4.总结 附录 附录 1 附录 2 1.…
阅读更多...
【JVM】常量池

【JVM】常量池

常量池&#xff08;Runtime Constant Poo&#xff09; 常量池Java中可以分为三种&#xff1a;字符串常量池&#xff08;堆&#xff09;、Class文件常量池、运行时常量池&#xff08;堆&#xff09;。 1.字符串常量池&#xff08;String Pool&#xff09; 为了提升性能和减少…
阅读更多...
C++变量限定

C++变量限定

C的变量限定指可以在变量类型的基础上加上特殊的限定条件&#xff0c;主要包括&#xff1a;是不是const&#xff0c;是不是volatile&#xff0c;是左值还是右值&#xff0c;是不是引用&#xff0c;是左值引用还是右值引用&#xff0c;等等。 1. 为什么要研究这个东西 主要是c…
阅读更多...
练习之烦人的递归

练习之烦人的递归

文章目录1.删除公共字符2.读入一串以?结束的字符串&#xff0c;逆序输出。法一&#xff1a;常规递归法二&#xff1a;投机取巧3.递归将整数输出为字符串4.递归输出1--n的平方和5.递归计算222222...6.递归求最大公约数7.递归输出x的n次方8. 递归计算下列式子的值1.删除公共字符…
阅读更多...
从FPGA说起的深度学习（六）-任务并行性

从FPGA说起的深度学习（六）-任务并行性

这是新的系列教程&#xff0c;在本教程中&#xff0c;我们将介绍使用 FPGA 实现深度学习的技术&#xff0c;深度学习是近年来人工智能领域的热门话题。在本教程中&#xff0c;旨在加深对深度学习和 FPGA 的理解。用 C/C 编写深度学习推理代码高级综合 (HLS) 将 C/C 代码转换为硬…
阅读更多...
还在回想Midjourney的参数，Claude来帮你

还在回想Midjourney的参数，Claude来帮你

本来是想整理一份Midjourne使用的参数表&#xff0c;看来是不用了&#xff0c;Claude很方便的就能帮到我们。 问下Claude: 你知道 Midjourne 的参数吗 Claude 回答如下&#xff1a; 是回答出来了&#xff0c;但是并不是非常的好&#xff0c;我们继续引导他一下&#xff1a; 你…
阅读更多...
堆的实际应用(topk问题以及堆排序)

堆的实际应用(topk问题以及堆排序)

目录 前言&#xff1a; 一:解决topk问题 二:堆排序 【1】第一种方法(很少用) 【2】第二种方法(很实用) 前言&#xff1a; 上一次我们进行了二叉树的初步介绍并实现了堆的基本功能&#xff0c;但堆的作用并不是存储数据&#xff0c;它可以用来解决topk问题(求一组数据较大或…
阅读更多...
【C语言】9000字长文操作符详解

【C语言】9000字长文操作符详解

简单不先于复杂&#xff0c;而是在复杂之后。 目录 1. 操作符分类 2. 算数操作符 3. 移位操作符 3.1 左移操作符 3.2 右移操作符 4. 位操作符 4.1 按位与 & 4.2 按位或 | 4.3 按位异或 ^ 4.4 一道变态的面试题 4.5 练习 5. 赋值操作符 5.1 复合赋值…
阅读更多...
主流接口测试框架对比，究竟哪个更好用

主流接口测试框架对比，究竟哪个更好用

公司计划系统的开展接口自动化测试&#xff0c;需要我这边调研一下主流的接口测试框架给后端测试&#xff08;主要测试接口&#xff09;的同事介绍一下每个框架的特定和使用方式。后端同事根据他们接口的特点提出一下需求&#xff0c;看哪个框架更适合我们。 需求 1、接口编写…
阅读更多...
项目工作分解工具WBS

项目工作分解工具WBS

WBS工作分解结构&#xff08;Work Breakdown Structure&#xff09;&#xff0c;是一个描述思路的规划和设计工具&#xff0c;它可以清晰地表示各项目之间相互联系的结构&#xff0c;详细说明为完成项目所必须完成的各项工作&#xff0c;也可以向高层管理者和客户报告项目完成的…
阅读更多...
【Redis】高可用架构之Cluster集群和分⽚

【Redis】高可用架构之Cluster集群和分⽚

高可用架构之Cluster集群和分⽚1. 前言2. Cluster 模式介绍2.1 什么是Cluster模式&#xff1f;2.2 为什么需要Cluster模式&#xff1f;2.2.1 垂直拓展&#xff08;scale up&#xff09;和水平拓展&#xff08;scale out&#xff09;2.2.2 Redis Cluster 提供的好处2.2.3 Redis …
阅读更多...
学术期刊《广西物理》简介及投稿要求

学术期刊《广西物理》简介及投稿要求

学术期刊《广西物理》简介及投稿要求 《广西物理》&#xff08;季刊&#xff09;创刊于1980年&#xff0c;是由广西师范大学&#xff1b;广西物理学会主办的物理杂志。本刊报道与物理有关的基础研究、应用研究以及与此有关的交叉学科研究领域的最新重要研究成果和发展趋势&…
阅读更多...
编码与加密基础笔记

编码与加密基础笔记

文章目录&#x1f449;1、ASCII 编码&#x1f449;2、了解Base64&#x1f449;3、MD5消息摘要算法&#x1f449;4、对称加密与 AES&#x1f449;5、非对称加密与 RSA参考书籍《Python 3 反爬虫原理与绕过实战》&#x1f449;1、ASCII 编码 ASCII编码实际上约定了字符串和二进制…
阅读更多...
Python中使用matplotlib时显示中文乱码_(或更改字体)

Python中使用matplotlib时显示中文乱码_(或更改字体)

一、问题描述 在使用matplotlib绘制可视化图表时&#xff0c;图表的中文显示乱码&#xff0c;只能正常显示英文内容&#xff0c;如下图所示&#xff1a; 二、问题分析 一般显示乱码是由于编码问题导致的&#xff0c;而matplotlib 默认使用ASCII 编码&#xff0c;但是当使用pypl…
阅读更多...
全语言通用的ASCIL表讲解，这一篇就够了

全语言通用的ASCIL表讲解，这一篇就够了

目录 ASCII码诞生背景 ASCII码特性 可显示字符 大佬们可以看这个 小白们看这个更详细 对控制字符的解释 ASCII码诞生背景 在计算机中&#xff0c;所有的数据在存储和运算时都要使用二进制表示。例如&#xff0c;像a、b、c、d这样的52个字母&#xff08;包括大写&#xf…
阅读更多...
Winnolin 绘制药时曲线图C-T

Winnolin 绘制药时曲线图C-T

文章目录前言一、各受试者C-T图1.导入数据2.设置-运行2.查看结果&#xff0c;修改参数二、各制剂C-T图1.导入数据2.设置-运行2.查看结果&#xff0c;修改参数三、平均C-T图1.计算统计量2.设置统计量计算参数&#xff08;Set Up&#xff09;3.绘图XY Plot4.查看结果&#xff0c;…
阅读更多...
Java多线程基础面试总结（三）

Java多线程基础面试总结（三）

线程的生命周期和状态 Java 线程在运行的生命周期中的指定时刻只可能处于下面 6 种不同状态的其中一个状态&#xff1a; NEW&#xff1a;初始状态&#xff0c;线程被创建出来&#xff0c;但是还没有调用start()方法。RUNABLE&#xff1a;运行中状态&#xff0c;调用了start()…
阅读更多...
Java设计模式 11-代理模式

Java设计模式 11-代理模式

代理模式 一、 代理模式(Proxy) 1、代理模式的基本介绍 代理模式&#xff1a;为一个对象提供一个替身&#xff0c;以控制对这个对象的访问。即通过代理对象访问目标对象.这样做的好处是: 可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。被代理的对象…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023