多线程——学习笔记 1

目录

        • 多线程的了解
        • 多线程并行和并发的区别
        • Java程序运行原理
        • 多线程程序实现的方式
          • 1.继承Thread
          • 2.实现Runnable
        • 多线程(实现Runnable的原理）
        • 实现多线程两种方式的区别
        • 匿名内部类实现线程的两种方式
        • 获取线程名字和设置名字
        • 获取当前线程的对象——hread.currentThread()
        • 休眠线程——Thread.sleep
        • 守护线程——setDaemon
        • 加入线程——join
        • 礼让线程——yield
        • 设置线程的优先级——setPriority
        • 同步代码块
        • 线程安全问题
        • 死锁
        • 线程安全

多线程的了解

  • 什么是线程

    • 线程是程序执行的一条路径, 一个进程中可以包含多条线程
    • 多线程并发执行可以提高程序的效率, 可以同时完成多项工作

  • 多线程的应用场景

    • 红蜘蛛同时共享屏幕给多个电脑
    • 迅雷开启多条线程一起下载
    • QQ同时和多个人一起视频
    • 服务器同时处理多个客户端请求

    多线程并行和并发的区别

  • 并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)

  • 并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。

  • 比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行。

  • 如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。

Java程序运行原理

  • Java程序运行原理

    • Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。

  • JVM的启动是多线程的吗

    • JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。

多线程程序实现的方式

1.继承Thread
  • 定义类继承Thread
  • 重写run方法
  • 把新线程要做的事写在run方法中
  • 创建线程对象
  • 开启新线程, 内部会自动执行run方法
public class Demo2_Thread {
	public static void main(String[] args) {
		MyThread mt = new MyThread();							//4,创建自定义类的对象
		mt.start();												//5,开启线程
		
		for(int i = 0; i < 3000; i++) {
			System.out.println("bb");
		}
	}

}
class MyThread extends Thread {									//1,定义类继承Thread
	public void run() {											//2,重写run方法
		for(int i = 0; i < 3000; i++) {							//3,将要执行的代码,写在run方法中
			System.out.println("aaaaaaaaaaaaaaa");
		}
	}
}
2.实现Runnable
  • 定义类实现Runnable接口
  • 实现run方法
  • 把新线程要做的事写在run方法中
  • 创建自定义的Runnable的子类对象
  • 创建Thread对象, 传入Runnable
  • 调用start()开启新线程, 内部会自动调用Runnable的run()方法
public class Demo3_Runnable {
     	public static void main(String[] args) {
     		MyRunnable mr = new MyRunnable();						//4,创建自定义类对象
     		Thread t = new Thread(mr);								//5,将其当作参数传递给Thread的构造函数
     		t.start();												//6,开启线程
for(int i = 0; i < 3000; i++) {
			System.out.println("bb");
		}
	}
}

class MyRunnable implements Runnable {							//1,自定义类实现Runnable接口
	@Override
	public void run() {											//2,重写run方法
		for(int i = 0; i < 3000; i++) {							//3,将要执行的代码,写在run方法中
			System.out.println("aaaaaaaaaaaaaaaaaa");
		}
	}
	
}

多线程(实现Runnable的原理）

  • 1、看Thread类的构造函数,传递了Runnable接口的引用
  • 2、通过init()方法找到传递的target给成员变量的target赋值
  • 3、查看run方法，发现run方法中有判断,如果target不为null就会调用Runnable接口子类对象的run方法

实现多线程两种方式的区别

  • 查看源码的区别:

  • a.继承Thread : 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法

  • b.实现Runnable : 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法

  • 继承Thread

  • 好处是:可以直接使用Thread类中的方法,代码简单

  • 弊端是:如果已经有了父类,就不能用这种方法

  • 实现Runnable接口

  • 好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的

  • 弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂

    匿名内部类实现线程的两种方式

  • 继承Thread类

 new Thread() {                                                               //1.继承Thread类
            public void run() {                                                      //2.重写run方法
                for (int i = 0; i < 1000; i++) {                                     //3.将要执行的代码写在run方法中
                    System.out.println("saaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
                }
            }
        }.start();                                                                   //4.开启线程
  • 实现Runnable接口
        new Thread(new Runnable() {                                                  //1.将Runnable的子类对象传递给Thread
            @Override
            public void run() {                                                      //2.重写run方法
                for (int i = 0; i < 1000; i++) {                                     //3.将要执行的代码写在run方法中
                    System.out.println("bbbbbbbbbbb");
                }
            }
        }).start();                                                                  //4.开启线程

获取线程名字和设置名字

  • 通过getName()方法获取线程对象的名字
new Thread() {                                                               //1.继承Thread类
            public void run() {                                                      //2.重写run方法
                for (int i = 0; i < 1000; i++) {                                     //3.将要执行的代码写在run方法中
                    System.out.println("线程名为:"+getName());
                }
            }
        }.start();                                                                   //4.开启线程

在这里插入图片描述

  • 通过构造函数可以传入String类型的名字
new Thread("主线程1") {                                                               //1.继承Thread类
            public void run() {                                                      //2.重写run方法
                for (int i = 0; i < 1000; i++) {                                     //3.将要执行的代码写在run方法中
                    System.out.println("线程名为:"+getName());
                }
            }
        }.start();                                                                   //4.开启线程

在这里插入图片描述

  • 通过setName(String)方法可以设置线程对象的名字
Thread t1 = new Thread() {                                                   //1.继承Thread类
            public void run() {                                                      //2.重写run方法
                for (int i = 0; i < 1000; i++) {                                     //3.将要执行的代码写在run方法中
                    System.out.println("线程名为:"+getName());
                }
            }
        };                                                                          //4.开启线程

        t1.setName("设置线程名1");
        t1.start();

在这里插入图片描述

获取当前线程的对象——hread.currentThread()

  • hread.currentThread()，获取当前线程的对象，主线程也可以获取
Thread.currentThread().setName("1001");                                        //获取主函数线程的引用,并改名字
        System.out.println(Thread.currentThread().getName());                      //获取主函数线程的引用,并获取名字

        new Thread(new Runnable() {                                                  //1.将Runnable的子类对象传递给Thread
            @Override
            public void run() {                                                      //2.重写run方法
                for (int i = 0; i < 10; i++) {                                     //3.将要执行的代码写在run方法中
                    System.out.println("bbbbbbbbbbb");
                }
            }
        }).start();                                                                //4.开启线程

在这里插入图片描述

休眠线程——Thread.sleep

    • Thread.sleep(毫秒), 控制当前线程休眠若干毫秒1秒= 1000毫秒
  • Thread.sleep(毫秒,纳秒), 控制当前线程休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000纳秒 1000000000
 new Thread(new Runnable() {                                                  //1.将Runnable的子类对象传递给Thread
            @Override
            public void run() {                                                      //2.重写run方法
                for (int i = 0; i < 10; i++) {                                     //3.将要执行的代码写在run方法中
                    System.out.println("倒计时"+i+"秒");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();                                                                //4.开启线程

在这里插入图片描述

守护线程——setDaemon

  • setDaemon(), 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出
public static void main(String[] args) {
     Thread t1 = new Thread() {                                                   //1.继承Thread类
            public void run() {                                                      //2.重写run方法
                for (int i = 0; i < 2; i++) {                                     //3.将要执行的代码写在run方法中
                    System.out.println("线程名为:" + getName());
                    }
                }
        };                                                                          //4.开启线程

     Thread t2 = new Thread() {                                                  //1.将Runnable的子类对象传递给Thread
            @Override
            public void run() {                                                      //2.重写run方法
                for (int i = 0; i < 5; i++) {                                     //3.将要执行的代码写在run方法中
                    System.out.println("倒计时"+i+"秒");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };                                                                //4.开启线程

        t2.setDaemon(true);                                                //将t2设置为守护线程

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

在这里插入图片描述
有时间缓冲，所以非守护线程有时也会执行

加入线程——join

  • join()，当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
  • join(int)， 可以等待指定的毫秒之后继续
 public static void main(String[] args) {
     final Thread t1 = new Thread() {                                                   //1.继承Thread类
            public void run() {                                                      //2.重写run方法
                for (int i = 0; i < 5; i++) {                                     //3.将要执行的代码写在run方法中
                    System.out.println("线程名为:" + getName());
                    }
                }
        };                                                                          //4.开启线程

     Thread t2 = new Thread() {                                                  //1.将Runnable的子类对象传递给Thread
            @Override
            public void run() {                                                      //2.重写run方法
                for (int i = 0; i < 5; i++) {                                     //3.将要执行的代码写在run方法中
                  if (i==2){
                      try {
                         // t1.join();                                                //匿名内部类在使用它所在方法中的局部变量时必须用final修饰
                          t1.join(1);                                           //插队指定时间，在指定时间执行完后，两条线程继续交替执行
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }

                    System.out.println("倒计时"+i+"秒");


                }
            }
        };                                                                //4.开启线程
        t1.start();
        t2.start();
    }

在这里插入图片描述

礼让线程——yield

  • yield让出cpu
public static void main(String[] args) {
        new MyThread().start();
        new MyThread().start();                                  
    }
}
    class MyThread extends Thread{
        public void run(){
            for (int i = 0 ;i<1000;i++){
                if (i % 10 ==0){
                    Thread.yield();

                }
                System.out.println(getName()+"线程"+i);
            }
        }
    }

在这里插入图片描述

设置线程的优先级——setPriority

  • setPriority()设置线程的优先级
public static void main(String[] args) {
        Thread t1 = new Thread() {                                                   //1.继承Thread类
            public void run() {                                                      //2.重写run方法
                for (int i = 0; i < 100; i++) {                                     //3.将要执行的代码写在run方法中
                    System.out.println("线程名为:" + getName()+"____"+i);
                }
            }
        };                                                                          //4.开启线程

        Thread t2 = new Thread() {                                                  //1.将Runnable的子类对象传递给Thread
            @Override
            public void run() {                                                      //2.重写run方法
                for (int i = 0; i < 100; i++) {                                     //3.将要执行的代码写在run方法中
                    System.out.println(getName()+"倒计时" + i + "秒");
                }
            }
        };                                                                //4.开启线程
        t1.setPriority(Thread.MIN_PRIORITY);//设置最小优先级
        t2.setPriority(Thread.MAX_PRIORITY);//设置最大优先级

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

在这里插入图片描述

同步代码块

  • 1.什么情况下需要同步
    • 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
    • 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.
  • 2.同步代码块
    • 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
    • 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的
public class Synchronized {
    public static void main(String[] agr) {
        final printer p = new printer();
        new Thread() {
            public void run() {
                while (true) {
                    p.print1();
                }
            }
        }.start();
        new Thread() {
            public void run() {
                while (true) {
                    p.print2();
                }
            }
        }.start();
    }
}

class printer {
    public void print1() {
        demo d = new demo();
        synchronized (d) {   //锁对象可以是任意对象,但是被锁的代码需要保证是同一把锁,不能用匿名对象
            System.out.print("北");
            System.out.print("京");
            System.out.print("欢");
            System.out.print("迎");
            System.out.print("您");
            System.out.print("\r\n");
        }
    }
    /*
     * 非静态同步函数的锁是:this
     * 静态的同步函数的锁是:字节码对象
     */
    public void print2() {
        demo d = new demo();
        synchronized (d) {
            System.out.print("武");
            System.out.print("汉");
            System.out.print("热");
            System.out.print("干");
            System.out.print("面");
            System.out.print("\r\n");
        }
    }
}

class demo {

}

在这里插入图片描述

  • 使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的
public class Synchronized {
    public static void main(String[] agr) {
        final printer p = new printer();
        new Thread() {
            public void run() {
                while (true) {
                    p.print1();
                }
            }
        }.start();
        new Thread() {
            public void run() {
                while (true) {
                    p.print2();
                }
            }
        }.start();
    }
}

/**
 * 非静态的同步方法的锁对象是this
 * 静态的同步方法的锁对象是该类的字节码对象
 */
class printer {
    public synchronized void print1() {
        //锁对象可以是任意对象,但是被锁的代码需要保证是同一把锁,不能用匿名对象
        //使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的
        System.out.print("北");
        System.out.print("京");
        System.out.print("欢");
        System.out.print("迎");
        System.out.print("您");
        System.out.print("\r\n");

    }

    /*
     * 非静态同步函数的锁是:this
     * 静态的同步函数的锁是:字节码对象
     */
    public void print2() {

        synchronized (this) {
            System.out.print("武");
            System.out.print("汉");
            System.out.print("热");
            System.out.print("干");
            System.out.print("面");
            System.out.print("\r\n");
        }
    }
}

在这里插入图片描述

线程安全问题

  • 多线程并发操作同一数据时, 就有可能出现线程安全问题
  • 使用同步技术可以解决这种问题, 把操作数据的代码进行同步, 不要多个线程一起操作
public class Demo2_Synchronized {
    public static void main(String[] args) {
        TicketsSeller t1 = new TicketsSeller();
        TicketsSeller t2 = new TicketsSeller();
        TicketsSeller t3 = new TicketsSeller();
        TicketsSeller t4 = new TicketsSeller();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t4.setName("窗口4");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

}

class TicketsSeller extends Thread {
    private static int tickets = 100;
    static Object obj = new Object();
    public TicketsSeller() {
        super();

    }
    public TicketsSeller(String name) {
        super(name);
    }
    public void run() {
        while(true) {
            synchronized(obj) {
                if(tickets <= 0)
                    break;
                try {
                    Thread.sleep(10);//线程1睡,线程2睡,线程3睡,线程4睡
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
                System.out.println(getName() + "...这是第" + tickets-- + "号票");
            }
        }
    }
}

在这里插入图片描述

多次启动一个线程是非法的

public class Demo2_Synchronized {
    public static void main(String[] args) {
        TicketsSeller ticketsSeller = new TicketsSeller();

       /* Thread t1 = new Thread(ticketsSeller);//多次启动一个线程是非法的
        t1.start();
        t1.start();
        t1.start();
        t1.start();*/

    }
}

class TicketsSeller implements Runnable {
    private static int tickets = 100;

    public void run() {
        while(true) {
            synchronized(TicketsSeller.class) {
                if(tickets <= 0)
                    break;
                try {
                    Thread.sleep(10);//线程1睡,线程2睡,线程3睡,线程4睡
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "...这是第" + tickets-- + "号票");
            }
        }
    }
}

死锁

  • 多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁

  • 尽量不要嵌套使用
    在这里插入图片描述

    private static String s1 = "筷子左";
    private static String s2 = "筷子右";

    public static void main(String[] args) {
        new Thread() {
            public void run() {
                while (true) {
                    synchronized (s1) {
                        System.out.println(getName() + "...拿到" + s1 + "等待" + s2);
                        synchronized (s2) {
                            System.out.println(getName() + "...拿到" + s2 + "开吃");
                        }
                    }
                }
            }
        }.start();

        new Thread() {
            public void run() {
                while (true) {
                    synchronized (s2) {
                        System.out.println(getName() + "...拿到" + s2 + "等待" + s1);
                        synchronized (s1) {
                            System.out.println(getName() + "...拿到" + s1 + "开吃");
                        }
                    }
                }
            }
        }.start();
    }

线程安全

  • Vector是线程安全的,ArrayList是线程不安全的
  • StringBuffer是线程安全的,StringBuilder是线程不安全的
  • Hashtable是线程安全的,HashMap是线程不安全的

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

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

相关文章

《Linux从练气到飞升》No.16 Linux 进程地址空间

《Linux从练气到飞升》No.16 Linux 进程地址空间

&#x1f57a;作者&#xff1a; 主页 我的专栏C语言从0到1探秘C数据结构从0到1探秘Linux菜鸟刷题集 &#x1f618;欢迎关注&#xff1a;&#x1f44d;点赞&#x1f64c;收藏✍️留言 &#x1f3c7;码字不易&#xff0c;你的&#x1f44d;点赞&#x1f64c;收藏❤️关注对我真的…
阅读更多...
matlab使用教程(20)—插值基础

matlab使用教程(20)—插值基础

1.网格和散点样本数据 插值是在位于一组样本数据点域中的查询位置进行函数值估算的方法。函数值是根据最接近查询点的样本数据点计算的。MATLAB 根据样本数据的结构&#xff0c;可以执行两种插值。样本数据可以形成网格&#xff0c;也可以是分散的。 网格化的样本数据使得插值…
阅读更多...
Arduino之esp8266

Arduino之esp8266

今天&#xff0c;捣鼓了Arduino和esp8266,发现有两款比较好的软件&#xff08;Arduino IDE以及Mixly软件&#xff09;可以将程序下载至esp8266中&#xff0c;而且两者的编程语言都是一样的&#xff0c;都是基于Arduino编程语言&#xff0c;只不过一个Mixly更注重图形编程&#…
阅读更多...
cuOSD(CUDA On-Screen Display Library)库的学习

cuOSD(CUDA On-Screen Display Library)库的学习

目录 前言1. cuOSD1.1 Description1.2 Getting started1.3 For Python Interface1.4 Demo1.5 Performance Table 2. cuOSD案例2.1 环境配置2.2 simple案例2.3 segment案例2.4 segment2案例2.5 polyline案例2.6 comp案例2.7 perf案例 3. cuOSD浅析3.1 simple_draw函数 4. 补充知…
阅读更多...
大数据平台需要做等保测评吗？怎么做？

大数据平台需要做等保测评吗？怎么做？

大数据时代的数据获取方式、存储规模、访问特点、关注重点都有了很大不同&#xff0c;所以保证大数据平台数据安全尤其重要。因此不少人在问&#xff0c;大数据平台需要做等保测评吗&#xff1f;怎么做&#xff1f; 大数据平台需要做等保测评吗&#xff1f; 大数据平台是需要做…
阅读更多...
创建和运行 Ansible 临时命令

创建和运行 Ansible 临时命令

创建和运行 Ansible 临时命令 作为系统管理员&#xff0c;您需要在受管节点上安装软件。 请按照正文所述&#xff0c;创建一个名为 /home/curtis/ansible/adhoc.sh 的 shell 脚本&#xff0c;该脚本将使用 Ansible 临时命令在各个受管节点上安装 yum 存储库&#xff1a; 存储库…
阅读更多...
EasyExcel 导出报空指针NullPointerException

EasyExcel 导出报空指针NullPointerException

java.lang.NullPointerException: null at sun.awt.FontConfiguration.getVersion(FontConfiguration.java:1264) at sun.awt.FontConfiguration.readFontConfigFile(FontConfiguration.java:219) 这是jdk缺少字体库问题 在官网也给出解决答案&#xff1a; 1.安装少了字体库…
阅读更多...
jvm-虚拟机栈

jvm-虚拟机栈

1.栈的存储单位 栈是运行时单位&#xff0c;而堆是存储的单位 栈解决程序的运行问题&#xff0c;即程序如何执行&#xff0c;或者说如何处理数据。堆解决的是数据存储问题&#xff0c;即数据怎么放&#xff0c;放在哪儿 java虚拟机栈 早期也叫java栈&#xff0c;每个线程在创建…
阅读更多...
lesson9: C++多线程

lesson9: C++多线程

1.线程库 1.1 thread类的简单介绍 C11 中引入了对 线程的支持 了&#xff0c;使得 C 在 并行编程时 不需要依赖第三方库 而且在原子操作中还引入了 原子类 的概念。要使用标准库中的线程&#xff0c;必须包含 < thread > 头文件 函数名 功能 thread() 构造一个线程对象…
阅读更多...
Java之抽象类

Java之抽象类

Java之抽象类 抽象类概念抽象类如何使用抽象类的特性 作者简介&#xff1a; zoro-1&#xff0c;目前大一&#xff0c;正在学习Java&#xff0c;数据结构等 作者主页&#xff1a;zoro-1的主页 欢迎大家点赞 &#x1f44d; 收藏 ⭐ 加关注哦&#xff01;&#x1f496;&#x1f49…
阅读更多...
Vue2-全局事件总线、消息的订阅与发布、TodoList的编辑功能、$nextTick、动画与过渡

Vue2-全局事件总线、消息的订阅与发布、TodoList的编辑功能、$nextTick、动画与过渡

&#x1f954;&#xff1a;高度自律即自由 更多Vue知识请点击——Vue.js VUE2-Day9 全局事件总线1、安装全局事件总线2、使用事件总线&#xff08;1&#xff09;接收数据&#xff08;2&#xff09;提供数据&#xff08;3&#xff09;组件销毁前最好解绑 3、TodoList中的孙传父&…
阅读更多...
乖宝宠物上市，能否打破外资承包中国宠物口粮的现实

乖宝宠物上市，能否打破外资承包中国宠物口粮的现实

近日&#xff0c;乖宝宠物上市了&#xff0c;这是中国宠物行业成功挂牌的第三家公司。同时&#xff0c;昨日&#xff0c;宠物行业最大的盛事“亚洲宠物展”时隔3年&#xff0c;于昨日在上海成功回归。 这两件事情的叠加可谓是双喜临门&#xff0c;行业能够走到今天实属不易&…
阅读更多...
java网络编程

java网络编程

目录 1. 什么是网络编程? 2. 网络编程三要素 2.1 IP 2.1.1 常见CMD命令 2.1.2 InetAddress 2.2 端口号 2.3 协议 3. UDP通信程序 3.1 UDP的三种通信方式 4. TCP通信程序 4.1 三次握手四次挥手 1. 什么是网络编程? 在网络通信协议下&#xff0c;不同计算机上运行的程…
阅读更多...
生成式AI和大语言模型 Generative AI LLMs

生成式AI和大语言模型 Generative AI LLMs

在“使用大型语言模型(LLMs)的生成性AI”中&#xff0c;您将学习生成性AI的基本工作原理&#xff0c;以及如何在实际应用中部署它。 通过参加这门课程&#xff0c;您将学会&#xff1a; 深入了解生成性AI&#xff0c;描述基于LLM的典型生成性AI生命周期中的关键步骤&#xff…
阅读更多...
基于Java的ssm菜匣子优选系统源码和论文

基于Java的ssm菜匣子优选系统源码和论文

基于Java的ssm菜匣子优选系统039 开发工具&#xff1a;idea 数据库mysql5.7 数据库链接工具&#xff1a;navcat,小海豚等 技术&#xff1a;ssm 摘 要 随着科学技术的飞速发展&#xff0c;各行各业都在努力与现代先进技术接轨&#xff0c;通过科技手段提高自身的优势&…
阅读更多...
unity发布WebGL遇到的坑（持续更新）

unity发布WebGL遇到的坑（持续更新）

1、unity默认字体在网页中不会显示 解决方法&#xff1a;自己新导入一个字体&#xff0c;使用导入的字体 2、之前打过包并运行过&#xff0c;后面又在unity中进行了修改&#xff0c;重新打包&#xff0c;运行发现还是修改之前的效果&#xff0c;虽然是新包&#xff0c; 解决方…
阅读更多...
Linux下gdb调试

Linux下gdb调试

1.基本命令操作 2.调试方式启动运行无参程序 以下是linux下GDB调试的一个实例&#xff0c;先给出一个示例用的小程序&#xff0c;C语言代码&#xff1a; main.c #include <stdio.h>void Print(int i){printf("hello,程序猿编码 %d\n", i); }int main(int argc…
阅读更多...
Python爬虫解析工具之xpath使用详解

Python爬虫解析工具之xpath使用详解

文章目录 一、数据解析方式二、xpath介绍三、环境安装1. 插件安装2. 依赖库安装 四、xpath语法五、xpath语法在Python代码中的使用 一、数据解析方式 爬虫抓取到整个页面数据之后&#xff0c;我们需要从中提取出有价值的数据&#xff0c;无用的过滤掉。这个过程称为数据解析&a…
阅读更多...
【实战】十一、看板页面及任务组页面开发（三） —— React17+React Hook+TS4 最佳实践，仿 Jira 企业级项目（二十五）

【实战】十一、看板页面及任务组页面开发（三） —— React17+React Hook+TS4 最佳实践，仿 Jira 企业级项目（二十五）

文章目录 一、项目起航&#xff1a;项目初始化与配置二、React 与 Hook 应用&#xff1a;实现项目列表三、TS 应用&#xff1a;JS神助攻 - 强类型四、JWT、用户认证与异步请求五、CSS 其实很简单 - 用 CSS-in-JS 添加样式六、用户体验优化 - 加载中和错误状态处理七、Hook&…
阅读更多...
GB28181国标平台测试软件NTV-GBC(包含服务器和模拟客户端)

GB28181国标平台测试软件NTV-GBC(包含服务器和模拟客户端)

GB28181国标平台测试软件NTV-GBC用于对GB28181国标平台进行测试(测试用例需要服务器软件&#xff0c;服务器软件可以是任何标准的国标平台&#xff0c;我们测试使用的是NTV-GBS&#xff09;&#xff0c;软件实现了设备注册、注销、目录查询&#xff0c;消息订阅、INVITE&#x…
阅读更多...
最新文章

Copyright @ 2022~2023