JAVA JUC学习笔记

基础知识

1、进程和线程的对比

  • 进程基本上相互独立的，而线程存在于进程内，是进程的一个子集
  • 进程拥有共享的资源，如内存空间等，供其内部的线程共享
  • 进程间通信较为复杂
    • 同一台计算机的进程通信称为 IPC（Inter-process communication）
    • 不同计算机之间的进程通信，需要通过网络，并遵守共同的协议，例如 HTTP
  • 线程通信相对简单，因为它们共享进程内的内存，一个例子是多个线程可以访问同一个共享变量
  • 线程更轻量，线程上下文切换成本一般上要比进程上下文切换低

2、并行与并发

  • 并发（concurrent）是同一时间应对多件事情的能力
  • 并行（parallel）是同一时间动手做多件事情的能力

3、异步与同步

  • 需要等待结果返回，才能继续运行就是同步
  • 不需要等待结果返回，就能继续运行就是异

Java线程

1、创建线程

方法一：使用 T h r e a d \color{red}{Thread} Thread

// 创建线程对象
Thread t = new Thread() {public void run() {// 要执行的任务}
};
// 启动线程
t.start();

方法一：使用 R u n n a b l e \color{red}{Runnable} Runnable配合Thread

把【线程】和【任务】（要执行的代码）分开

  • Thread 代表线程
  • Runnable 可运行的任务（线程要执行的代码）
Runnable runnable = new Runnable() {public void run(){// 要执行的任务}
};
// 创建线程对象
Thread t = new Thread( runnable );
// 启动线程
t.start();

原理之 Thread 与 Runnable 的关系：

  • 方法1 是把线程和任务合并在了一起，方法2 是把线程和任务分开了
  • 用 Runnable 更容易与线程池等高级 API 配合
  • 用 Runnable 让任务类脱离了 Thread 继承体系，更灵活

方法三： F u t u r e T a s k \color{red}{FutureTask} FutureTask配合 Threa

FutureTask 能够接收 Callable 类型的参数，用来处理有返回结果的情况

// 创建任务对象
FutureTask<Integer> task = new FutureTask<>(new Callable<Integer>() {@Overridepublic Integer call() throws Exception {return null;}});// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread t = new Thread(task);
t.start();// 主线程阻塞，同步等待 task 执行完毕的结果
Integer result = task3.get();
log.debug("结果是:{}", result);

2、线程运行原理

每个线程启动后，虚拟机就会为其分配一块栈内存。

  • 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
  • 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

在这里插入图片描述

3、线程上下文切换

因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码

  • 线程的 cpu 时间片用完
  • 垃圾回收
  • 有更高优先级的线程需要运行
  • 线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

当 Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的

  • 状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等
  • Context Switch 频繁发生会影响性能

4、常见方法

在这里插入图片描述
在这里插入图片描述

5、run和start

  • 直接调用 run 是在主线程中执行了 run，没有启动新的线程
  • 使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码

6、sleep与yield

  • Sleep
    1. 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
    2. 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛InterruptedException
    3. 睡眠结束后的线程未必会立刻得到执行
    4. 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性
  • yield
    1. 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程
    2. 具体的实现依赖于操作系统的任务调度器(CPU闲，让也让不出去)

区别：

  • Runnable还是有机会被调用的，但任务调度器不会把时间片分配给Timed Waiting

7、程优先级

  • 线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它
  • 如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用
Runnable task1 = () -> {int count = 0;for (;;) {System.out.println("---->1 " + count++);}};Runnable task2 = () -> {int count = 0;for (;;) {// Thread.yield();System.out.println("              ---->2 " + count++);}};Thread t1 = new Thread(task1, "t1");Thread t2 = new Thread(task2, "t2");// t1.setPriority(Thread.MIN_PRIORITY);// t2.setPriority(Thread.MAX_PRIORITY);t1.start();t2.start();

8、join方法

等待某个进程的运行结果

static int r = 0;public static void main(String[] args) throws InterruptedException {test1();}private static void test1() throws InterruptedException {log.debug("开始");Thread t1 = new Thread(() -> {log.debug("开始");sleep(1);log.debug("结束");r = 10;});t1.start();log.debug("结果为:{}", r);log.debug("结束");}

输出：0

分析

  • 因为主线程和线程 t1 是并行执行的，t1 线程需要 1 秒之后才能算出
  • 而主线程一开始就要打印 r 的结果，所以只能打印出r=0

就想得到10，怎么办？

可以使用join，等待t1的返回结果

static int r = 0;public static void main(String[] args) throws InterruptedException {test1();}private static void test1() throws InterruptedException {log.debug("开始");Thread t1 = new Thread(() -> {log.debug("开始");sleep(1);log.debug("结束");r = 10;});t1.start();t1.join();log.debug("结果为:{}", r);log.debug("结束");}

9、interrupt方法

打断 sleep，wait，join 的线程 ，这几个方法都会让线程进入阻塞状态

打断 sleep 的线程, 会清空打断状态(变成false)，以 sleep 为例

private static void test1() throws InterruptedException {Thread t1 = new Thread(()->{sleep(1);}, "t1");t1.start();
}//main方法中
sleep(0.5);
t1.interrupt();
log.debug(" 打断状态: {}", t1.isInterrupted())

打断标记：
该线程是不是被其他的线程所干扰，打断过。

打断正常线程时，其实并没有打断，只是改变打断标记(不会清空打断状态)，线程还会继续运行，需要我们手动利用打断标记的布尔值去判断进行打断

private static void test2() throws InterruptedException {Thread t2 = new Thread(()->{while(true) {Thread current = Thread.currentThread();boolean interrupted = current.isInterrupted();if(interrupted) {log.debug(" 打断状态: {}", interrupted);break;}}}, "t2");t2.start();sleep(0.5);t2.interrupt();}

10、两阶段终止模式

在一个线程 T1 中如何“优雅”终止线程 T2？这里的【优雅】指的是给 T2 一个料理后事的机会。

在这里插入图片描述

class TPTInterrupt {private Thread thread;public void start(){thread = new Thread(() -> {while(true) {Thread current = Thread.currentThread();if(current.isInterrupted()) {log.debug("料理后事");break;}try {Thread.sleep(1000);log.debug("将结果保存");}catch (InterruptedException e) {current.interrupt();}// 执行监控操作               }},"监控线程");thread.start();}public void stop() {thread.interrupt();}}

调用

TPTInterrupt t = new TPTInterrupt();t.start();Thread.sleep(3500);log.debug("stop");t.stop()

11、不推荐使用的方法

这些方法已过时，容易破坏同步代码块，造成线程死锁

在这里插入图片描述

12、主线程与手护线程

默认情况下，Java 进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其它非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。

log.debug("开始运行...");
Thread t1 = new Thread(() -> {log.debug("开始运行...");sleep(2);log.debug("运行结束...");}, "daemon");
// 设置该线程为守护线程
t1.setDaemon(true);
t1.start();
sleep(1);
log.debug("运行结束...");

在这里插入图片描述

线程的状态

1、从操作系统层面看

在这里插入图片描述

  • 【初始状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联
  • 【可运行状态】（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行
  • 【运行状态】指获取了 CPU 时间片运行中的状态
    • 当 CPU 时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换
  • 【阻塞状态】
    • 如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入【阻塞状态】
  • 等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】
  • 与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们
  • 【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状

2、从Java API层面来描述

根据 Thread.State 枚举，分为六种状态
在这里插入图片描述

  • NEW 线程刚被创建，但是还没有调用start() 方法
  • RUNNABLE 当调用了start() 方法之后，注意，Java API 层面的 RUNNABLE 状态涵盖了 操作系统 层面的【可运行状态】、【运行状态】和【阻塞状态】（由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为是可运行）
  • BLOCKED ，WAITING ，TIMED_WAITING 都是 Java API 层面对【阻塞状态】的细分
  • TERMINATED 当线程代码运行结束

共享模型之管程

1、共享问题

在这里插入图片描述
最后可能会出现整数或者负数，原因在于上下文的切换：

  • 出现负数：
    在这里插入图片描述

  • 出现整数：
    在这里插入图片描述

2、临界区

  • 一个程序运行多个线程本身是没有问题的
  • 问题出在多个线程访问共享资源
    • 多个线程读共享资源其实也没有问题
    • 在多个线程对共享资源读写操作时发生指令交错，就会出现问题
  • 一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界

竞态条件 Race Condition

  • 多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件

3、synchronized解决方案

使用阻塞式的解决方案：synchronized，来解决上述问题，即俗称的【对象锁】，它采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文切换

在这里插入图片描述

4、方法上的synchronized

在这里插入图片描述

不加 synchronized 的方法

  • 不加 synchronzied 的方法就好比不遵守规则的人，不去老实排队（好比翻窗户进去的）

5、变量的线程安全分析

成员变量和静态变量是否线程安全？

  • 如果它们没有共享，则线程安全
  • 如果它们被共享了，根据它们的状态是否能够改变，又分两种情况
    • 如果只有读操作，则线程安全
    • 如果有读写操作，则这段代码是临界区，需要考虑线程安全
      局部变量是否线程安全？
  • 局部变量是线程安全的
  • 但局部变量引用的对象则未必
    • 如果该对象没有逃离方法的作用访问，它是线程安全的
    • 如果该对象逃离方法的作用范围，需要考虑线程安全

6、常见线程安全类

  • String
  • Integer
  • StringBuffer
  • Random
  • Vector
  • Hashtable
  • java.util.concurrent 包下的类

它们的每个方法是原子的
但注意它们多个方法的组合不是原子的

如：
在这里插入图片描述
不可变类线程安全性

  • String、Integer 等都是不可变类，因为其内部的状态不可以改变，因此它们的方法都是线程安全的

7、Monitor概念

Monitor，在操作系统领域一般翻译为“管程”，在Java邻域就是“对象锁”。

Java对象头，以32位虚拟机为例

在这里插入图片描述
其中Klass word指定该对象的类型，即指向一个class对象。

Mark Word的不同状态对应不同的结构，如下：
在这里插入图片描述

其中Normal表示该对象是正常状态，hashcode表示每个对象不同的哈希码，age表示分代的年龄，垃圾回收算法可以根据此将其放入老年区。

每个Java对象都可以关联一个Monitor对象，如果使用synchronized给对象加锁，对应上图的Heavyweight Locked，该对象头的Mark Word中的ptr_to_heavyweight_monitor就会指向Monitor。

以一段代码为例：

synchronized(obj){
//临界资源
}
  • 当线程Thread2执行synchronized(obj)，就会将MarkWord中的指针指向Monitor
  • 刚开始，Monitor中的Owner为null，Thread会将Monitor的所有者Owner设置为Thread2，Owner只能指向一个线程
  • 当别的线程Thread1执行synchronized(obj)，会检查obj有没有关联Monitor，然后检查关联的Monitor有没有主人，即Owner
  • 此时，Thread1就会进入EntryList，可以理解成堵塞队列，然后线程Thread1变成BLOCKED状态
    在这里插入图片描述
  • 当Thread2执行完毕，就会让出Owner的位置。然后从Monitor的EntryList中唤醒一个线程，成为该Monitor的下一个主人。

注意：

  • synchronized 必须是进入同一个对象的 monitor 才有上述的效果
  • 不加 synchronized 的对象不会关联 monitor ，不遵从以上规则

8、synchronized原理进阶

轻量级锁

使用场景：
如果一个对象虽然有多线程要加锁，但加锁的时间是错开的（也就是没有竞争），那么可以使用轻量级锁来优化。

轻量级锁对使用者是透明的，即语法仍然是synchronized

举例子：

static final Object obj = new Object();
public static void method1() {synchronized( obj ) {// 同步块 Amethod2();}
}
public static void method2() {synchronized( obj ) {// 同步块 B}
}

  • 当method1执行到synchronized，会创建锁记录(Lock Record)对象，每个栈帧都会包含一个锁记录的结构：
    在这里插入图片描述

    • Object reference指向锁对象，并尝试用cas替换 Object 的 Mark Word，将 Mark Word 的值存入锁记录
      在这里插入图片描述

  • 如果cas替换成果，对象头中的Mark Word存储了锁记录地址和状态00，表示该线程给对象加锁。此时图示如下：
    在这里插入图片描述

  • cas失败的两种情况：

    • 如果是其它线程已经持有了该 Object 的轻量级锁，这时表明有竞争，进入锁膨胀过程
    • 如果是自己执行了 synchronized 锁重入，那么再添加一条 Lock Record 作为重入的计数。(如代码执行到上述method2的synchronized部分)
      在这里插入图片描述
      即要进行cas交换时，发现Mark Word中的状态是00，且锁记录指向的是本线程。此时会添加一条锁记录，且将锁记录中存储Mark Word的部分设置为null

  • 当退出synchronized如果有取值为null的锁记录，表示有重入。此时，将重置锁记录，表示重入计数减一
    在这里插入图片描述

  • 当退出synchronized代码块（解锁时）锁记录的值不为null，这时使用cas将Mark Word的值恢复给对象头

    • 成功，则解锁成功
    • 失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程

锁膨胀

如果在尝试加轻量级锁的过程中，CAS 操作无法成功，这时一种情况就是有其它线程为此对象加上了轻量级锁（有竞争），这时需要进行锁膨胀，将轻量级锁变为重量级锁。

  • 当Thread1进行轻量级加锁，Thread0已经加了轻量级锁
    在这里插入图片描述

  • 此时，Thread1加锁失败，进入锁膨胀流程

    • 为Object对象申请Monitor锁，让Object指向重量级锁地址
    • 然后将自己加入到Monitor的EntryList，进入BLOCKED状态
      在这里插入图片描述

  • 当Thread0退出同步代码块解锁时，使用cas将Mark Word的值恢复给对象头，失败(因为此时存储的是Monitor的地址)。然后进入重量级解锁流程，按照Monitor地址找到Monitor对象，设置Owner为null，唤醒EntryList中的BLOCKED线程

自旋优化

重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即这时候持锁线程已经退出了同步块，释放了锁），这时当前线程就可以避免阻塞(阻塞会造成上下文切换)。

偏向锁

轻量级锁在没有竞争时，每次重入任需要执行CAS判断。

因此引入偏向锁做进一步优化：

  • 只有第一次使用CAS将线程ID设置到对象的Mark Word头，之后发现这个线程ID就是自己就表示没有竞争，不用重新CAS。
  • 以后只要不发生竞争，这个对象就归该线程所有

回忆对象头格式：
在这里插入图片描述
一个对象创建时：

  • 如果开启了偏向锁（默认开启），那么对象创建后，markword 值为 0x05 即最后 3 位为 101，这时它的thread、epoch、age 都为 0
  • 偏向锁是默认是延迟的，不会在程序启动时立即生效，如果想避免延迟，可以加 VM 参数 -XX:BiasedLockingStartupDelay=0 来禁用延迟
  • 如果没有开启偏向锁，那么对象创建后，markword 值为 0x01 即最后 3 位为 001，这时它的 hashcode、age 都为 0，第一次用到 hashcode 时才会赋值

注意

  • 处于偏向锁的对象解锁后，线程 id 仍存储于对象头中

撤销偏向锁：

  • 调用锁对象的hashCode：
    偏向锁的对象 MarkWord 中存储的是线程 id，如果调用 hashCode 会导致偏向锁被撤销(因为没有位置存储hashCode了)
    • 轻量级锁会在锁记录中记录 hashCode
    • 重量级锁会在 Monitor 中记录 hashCode
  • 其它线程使用对象：
    当有其它线程使用偏向锁对象时，会将偏向锁升级为轻量级锁

批量重偏向

若对象被多个线程访问，但没有竞争，这时偏向了现场T1的对象仍有机会重新偏向T2，重偏向会重置对象的Thread ID

例子：

输出
private static void test3() throws InterruptedException {Vector<Dog> list = new Vector<>();Thread t1 = new Thread(() -> {for (int i = 0; i < 30; i++) {Dog d = new Dog();list.add(d);synchronized (d) {log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));}}synchronized (list) {list.notify();} }, "t1");t1.start();Thread t2 = new Thread(() -> {synchronized (list) {try {list.wait();} catch (InterruptedException e) {e.printStackTrace();}}log.debug("===============> ");for (int i = 0; i < 30; i++) {Dog d = list.get(i);log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));synchronized (d) {log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));}log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));}}, "t2");t2.start();
}
  • 第一次cas会启用偏向锁，偏向t1
  • 因为没有竞争，因此不会发生撤销偏向锁
  • 当进入t2时，标识为撤销锁偏向001，再次申请锁会将偏向锁升级为轻量级锁
  • 在后面几次循环中会保持轻量级锁的申请模式
  • 当撤销锁偏向达到某个阈值，会将轻量级锁转变成偏向锁偏向t2进程

批量撤销

当撤销偏向锁阈值超过 40 次后，jvm 会这样觉得，自己确实偏向错了，根本就不该偏向。于是整个类的所有对象都会变为不可偏向的，新建的对象也是不可偏向的

9、wait、notify

  • obj.wait() 让进入 object 监视器的线程到 waitSet 等待

    • wait() 方法会释放对象的锁，进入 WaitSet 等待区，从而让其他线程就机会获取对象的锁。无限制等待，直到notify 为止
    • wait(long n) 有时限的等待, 到 n 毫秒后结束等待继续执行后续代码，或是被 notify

  • obj.notify() 在 object 上正在 waitSet 等待的线程中随机挑一个唤醒

  • obj.notifyAll() 让 object 上正在 waitSet 等待的线程全部唤醒

wait和sleep的区别

  • sleep是Thread类的方法，wait是Object的方法
  • sleep 不需要强制和 synchronized 配合使用，但 wait 需要和 synchronized 一起用，在获取对象锁之后，才能使用wait
  • sleep 在睡眠的同时，不会释放对象锁的，但 wait 在等待的时候会释放对象锁
  • 它们状态都是TIMED_WAITING

wait、notify的使用格式

synchronized(lock) {while(条件不成立) {lock.wait();}// 干活
}//另一个线程
synchronized(lock) {lock.notifyAll();
}

wait、notify原理

在这里插入图片描述

  • Owner线程发现条件不满足，调用wait方法，即可进入WaitSet变为WAITING状态
  • BLOCKED和WAITING的线程都处于阻塞状态，不占用CPU时间片
  • BLOCKED线程会在Owner线程释放锁时唤醒
  • WAITING线程会在Owner线程调用notify或notifyAll时唤醒，但唤醒后并不意味立即获得锁，仍需进入EntryList重新竞争

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

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

相关文章

MSP430M03507最小系统板的keil环境搭配，用keil编辑ti单片机

MSP430M03507最小系统板的keil环境搭配，用keil编辑ti单片机

转载自嘉立创MSP430M03507开发手册 这篇文章只是因为我的keil版本与嘉立创的不一样&#xff0c;所以添加了我自己遇到的问题解析 先说说为什么要用keil编辑&#xff0c;因为ti单片机自己的ccs编译环境需要对应仿真器&#xff0c;那个加芯片都240了&#xff0c;哪有那么多钱买…
阅读更多...
FastDFS分布式存储

FastDFS分布式存储

一&#xff1a;FastDFS原理 FastDFS是一个开源的轻量级分布式文件系统&#xff0c;功能包括&#xff1a;文件存储&#xff0c;文件同步&#xff0c;文件访问&#xff08;文件上传、文件下载&#xff09;等&#xff0c;解决了大容量存储和负载均衡的问题。 1&#xff1a;FastD…
阅读更多...
56 网络层

56 网络层

本节重点 理解网络层的作用&#xff0c;深入理解IP协议的基本原理 对整个TCP/IP协议有系统的理解 对TCP/IP协议体系下的其他重要协议和技术有一定的了解 目录 前置认识ip协议基本概念协议头格式网段划分特殊的ip地址ip地址的数量限制私有ip和公有ip路由路由表生成算法 在复杂…
阅读更多...
Wi-SUN无线通信技术 — 大规模分散式物联网应用首选

Wi-SUN无线通信技术 — 大规模分散式物联网应用首选

引言 在数字化浪潮的推动下&#xff0c;物联网&#xff08;IoT&#xff09;正逐渐渗透到我们生活的方方面面。Wi-SUN技术以其卓越的性能和广泛的应用前景&#xff0c;成为了大规模分散式物联网应用的首选。本文将深入探讨Wi-SUN技术的市场现状、核心优势、实际应用中的案例以及…
阅读更多...
一些和颜色相关网站

一些和颜色相关网站

1.中国传统色 2.网页颜色选择器 3.渐变色网站 4.多风格色卡生成 5.波浪生成 6.半透明磨砂框
阅读更多...
第123天：内网安全-域防火墙入站出站规则不出网隧道上线组策略对象同步

第123天：内网安全-域防火墙入站出站规则不出网隧道上线组策略对象同步

目录 案例一&#xff1a; 单机-防火墙-限制端口\协议出入站 案例二&#xff1a;不出网的解决思路 入站连接 隧道技术 案例三&#xff1a;域控-防火墙-组策略对象同步 案例四&#xff1a;域控-防火墙-组策略不出网上线 msf cs 案例一&#xff1a; 单机-防火墙-限制端口\…
阅读更多...
RabbitMQ的学习和模拟实现｜sqlite轻量级数据库的介绍和简单使用

RabbitMQ的学习和模拟实现｜sqlite轻量级数据库的介绍和简单使用

SQLite3 项目仓库&#xff1a;https://github.com/ffengc/HareMQ SQLite3 什么是SQLite为什么需要用SQLite官方文档封装Helper进行一些实验 什么是SQLite SQLite是一个进程内的轻量级数据库&#xff0c;它实现了自给自足的、无服务器的、零配置的、事务性的 SQL数据库引擎…
阅读更多...
CTFSHOW game-gyctf web2

CTFSHOW game-gyctf web2

【2020年新春战“疫”】game-gyctf web2 参考https://www.cnblogs.com/aninock/p/15408090.html 说明&#xff1a;看见网上好像没多少人写&#xff0c;刚好玩到这道题了&#xff0c;就写一下吧。 一、利用入口 常规套路发现www.zip然后进行代码审计 index可以包含update&…
阅读更多...
汽车技术智能化程度不断提升，线束可靠性如何设计？

汽车技术智能化程度不断提升，线束可靠性如何设计？

随着汽车技术的高速发展&#xff0c;汽车自动化、智能化程度的逐步提高&#xff0c;人们对汽车的安全性、舒适性、娱乐性等要求也不断提高&#xff0c;加上汽车节能减排法规的不断严峻&#xff0c;整车电气设备不断增加&#xff0c;作为连接汽车各种电器设备“神经网络”的整车…
阅读更多...
谷粒商城实战笔记-跨域问题

谷粒商城实战笔记-跨域问题

一&#xff0c;When allowCredentials is true, allowedOrigins cannot contain the special value “*” since that cannot be set on the “Access-Control-Allow-Origin” response header. To allow credentials to a set of origins, list them explicitly or consider u…
阅读更多...
数据清洗系统设计

数据清洗系统设计

设计一个高效的数据清洗系统旨在确保数据的质量&#xff0c;以便后续分析和决策过程可以基于准确、一致和完整的信息。以下是设计实时数据清洗系统时需要考虑的关键要素&#xff0c;结合之前提到的设计目标和原则&#xff1a; 1. 高效的数据处理 技术选型&#xff1a;采用并行…
阅读更多...
Linux基于CentOS7【yum】【vim】的基础学习,【普通用户提权】

Linux基于CentOS7【yum】【vim】的基础学习,【普通用户提权】

目录 yum生态 什么是yum yum是如何得知目标服务器的地址和下载链接 vim vim模式 命名模式 光标移动 插入模式 i键插 a键插 o键插 底行模式 批量化注释 批量化去注释 创建vim配置文件 例子 高亮功能&#xff1a; 缩进功能&#xff1a; 符号位自动补齐功能…
阅读更多...
win10安装ElasticSearch7.x和分词插件

win10安装ElasticSearch7.x和分词插件

说明&#xff1a; 以下内容整理自网络&#xff0c;格式调整优化&#xff0c;更易阅读&#xff0c;希望能对需要的人有所帮助。 一 安装 Java环境 ElasticSearch使用Java开发的&#xff0c;依赖Java环境&#xff0c;安装 ElasticSearch 7.x 之前&#xff0c;需要先安装jdk-8。…
阅读更多...
梅卡曼德高精度 DLP 结构光焊接专用 3D 相机

梅卡曼德高精度 DLP 结构光焊接专用 3D 相机

精度高&#xff0c;抗环境光、抗反光&#xff0c;成像效果好 自研蓝光 DLP 投影技术及双目结构光 3D 成像算法&#xff0c;相 机精度高&#xff0c;抗环境光、抗反光性能优异。在实际场景中&#xff0c; 可对各类复杂焊接件、焊缝高质量成像。 超小体积&#xff0c;超强适…
阅读更多...
UFO：革新Windows操作系统交互的UI聚焦代理

UFO：革新Windows操作系统交互的UI聚焦代理

人工智能咨询培训老师叶梓 转载标明出处 人机交互的便捷性和效率直接影响着我们的工作和生活质量。尽管现代操作系统如Windows提供了丰富的图形用户界面&#xff08;GUI&#xff09;&#xff0c;使得用户能够通过视觉和简单的点击操作来控制计算机&#xff0c;但随着应用程序功…
阅读更多...
分享一个最近在进行前后端联调时改了2天的bug...

分享一个最近在进行前后端联调时改了2天的bug...

场景再现 我们这边前端端口是8080 后端端口是8121 我们在前端里在首页面写了一个任务 当进入网页三秒后 发起一个叫getLoginUser的请求 我们的getLoginUser是调用的这里 一个异步请求 这边我们前端调用后端的接口也已经写好 我们先把后端跑起来 访问前端页面 接收到了这个…
阅读更多...
数学建模学习（112）：FAHP模糊层次分析法

数学建模学习（112）：FAHP模糊层次分析法

文章目录 一、FAHP方法由来二、模糊层次分析法原理2.1 AHP缺陷2.2 模糊集理论2.3 模糊层次分析法（FAHP）三、模糊层次分析法步骤3.1 问题定义与层次结构建立3.2 构造模糊判断矩阵3.2.1 计算模糊判断矩阵的列和向量3.2.2 计算模糊综合向量3.2.3 计算模糊权重向量3.3 解模糊数3.…
阅读更多...
Ubuntu 22.04.4 LTS (linux) Tomcat 9 内存和线程优化

Ubuntu 22.04.4 LTS (linux) Tomcat 9 内存和线程优化

1 Apache Tomcat 9.0.91 线程 #在70行左右&#xff0c;增加如下 sudo vim /data/tomcat/conf/server.xmlmaxThreads"800" #客户请求最大线程数minSpareThreads"200" #最小线程数maxSpareThreads"500" #最大线程数acceptCount"800"…
阅读更多...
监控易V7.6.6.15全新升级14：设置功能全面优化

监控易V7.6.6.15全新升级14：设置功能全面优化

随着企业IT架构的不断发展&#xff0c;对运维管理的需求也日益增加。为了满足广大用户对运维管理的更高需求&#xff0c;监控易系统近期完成了一次重要版本升级。本次升级在原有功能的基础上&#xff0c;对设置功能进行了全面优化和新增&#xff0c;旨在为用户提供更加灵活、高…
阅读更多...
数据结构【没头单链表】

数据结构【没头单链表】

目录 ​ 概念与结构 结点 链表的性质 链表的打印分析 实现单链表&#xff1a; 创建单链表数据 申请空间 尾插数据 打印 头插数据 尾删 头删 查询数据 指定位置前插入数据 指定位置后插入数据 删除pos节点 删除pos后面的节点 销毁 链表的分类 链表说明&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023