JUC并发编程--------基础篇

一、多线程的相关知识

栈与栈帧

我们都知道 JVM 中由堆、栈、方法区所组成，其中栈内存是给谁用的呢？其实就是线程，每个线程启动后，虚拟 机就会为其分配一块栈内存。 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

线程上下文切换

上下文切换可以更详细地描述为内核(即操作系统的核心)对CPU上的进程(包括线程)执行以下活动:

1. 暂停一个进程的处理，并将该进程的CPU状态(即上下文)存储在内存中的某个地方

2. 从内存中获取下一个进程的上下文，并在CPU的寄存器中恢复它

3. 返回到程序计数器指示的位置(即返回到进程被中断的代码行)以恢复进程。

从数据来说，以程序员的角度来看， 是方法调用过程中的各种局部的变量与资源； 以线程的角度来看， 是方法的调用栈中存储的各类信息。

引发上下文切换的原因一般包括：线程、进程切换、系统调用等等。上下文切换通常是计算密集型的，因为涉及一系列数据在各种寄存器、 缓存中的来回拷贝。就CPU时间而言，一次上下文切换大概需要5000~20000个时钟周期，相对一个简单指令几个乃至十几个左右的执行时钟周期，可以看出这个成本的巨大。

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

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

当 Context Switch（上下文切换） 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念 就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的 状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等 Context Switch 频繁发生会影响性能

并行于并发

  • 并行Parallel：在同一时刻，有多个指令在多个CPU上同时执行。
  • 并发Concurrent：在一段时间内，有多个指令在单个CPU上交替执行。

进程和线程的区别

  • 进程：是正在运行的程序
  1. 独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位
  2. 动态性：进程的实质程序的一次执行过程，进程是动态产生，动态消亡的
  3. 并发性：任何进程都可以同其他进程一起并发执行
  • 线程：是进程中的单个顺序控制流，是一条执行路径
  1. 单线程：一个进程如果只有一条执行路径，则称为单线程程序
  2. 多线程：一个进程如果有多条执行路径，则称为多线程程序

线程状态介绍

  •  当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。那么Java中的线程存在哪几种状态呢？Java中的线程状态被定义在了java.lang.Thread.State枚举类中

State枚举类的源码如下：

public class Thread {
    
    public enum State {
    
        /* 新建 */
        NEW , 
​
        /* 可运行状态 */
        RUNNABLE , 
​
        /* 阻塞状态 */
        BLOCKED , 
​
        /* 无限等待状态 */
        WAITING , 
​
        /* 计时等待 */
        TIMED_WAITING , 
​
        /* 终止 */
        TERMINATED;
    
    }
    
    // 获取当前线程的状态
    public State getState() {
        return jdk.internal.misc.VM.toThreadState(threadStatus);
    }
    
}

通过源码我们可以看到Java中的线程存在6种状态，每种线程状态的含义如下

线程状态具体含义
NEW一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程象，没有线程特征。
RUNNABLE当我们调用线程对象的start方法，那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程，线程一经启动并不是立即得到执行，线程的运行与否要听令与CPU的调度，那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格，但是并没有真正的执行起来而是在等待CPU的度。
BLOCKED当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
WAITING一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种，分别是调用Object.wait()、join()方法。处于等待状态的线程，正在等待其他线程去执行一个特定的操作。例如：因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll()；一个因为join()而等待的线程正在等待另一个线程结束。
TIMED_WAITING一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种，分别是：Thread.sleep(long)，Object.wait(long)、join(long)。
TERMINATED一个完全运行完成的线程的状态。也称之为终止状态、结束状态

各个状态的转换，如下图所示：

情况 1 NEW --> RUNNABLE

当调用 t.start() 方法时，由 NEW --> RUNNABLE

情况 2 RUNNABLE <--> WAITING

t 线程用 synchronized(obj) 获取了对象锁后 调用 obj.wait() 方法时，t 线程从 RUNNABLE --> WAITING ，调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时 竞争锁成功，t 线程从WAITING -->RUNNABLE ，竞争锁失败，t 线程从WAITING --> BLOCKED

情况 3 RUNNABLE <--> WAITING

当前线程调用 t.join() 方法时，当前线程从 RUNNABLE --> WAITING ，注意是当前线程在t 线程对象的监视器上等待 t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从 WAITING --> RUNNABLE

情况 4 RUNNABLE <--> WAITING

当前线程调用 LockSupport.park() 方法会让当前线程从 RUNNABLE --> WAITING 调用 LockSupport.unpark(目标线程) 或调用了线程 的 interrupt() ，会让目标线程从 WAITING -->

RUNNABLE

情况 5 RUNNABLE <--> TIMED_WAITING

t 线程用 synchronized(obj) 获取了对象锁后 调用 obj.wait(long n) 方法时，t 线程从 RUNNABLE --> TIMED_WAITING ，t 线程等待时间超过了 n 毫秒，或调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时 ，竞争锁成功，t 线程从TIMED_WAITING --> RUNNABLE ，竞争锁失败，t 线程从

TIMED_WAITING --> BLOCKED

情况 6 RUNNABLE <--> TIMED_WAITING

当前线程调用 t.join(long n) 方法时，当前线程从 RUNNABLE --> TIMED_WAITING

注意是当前线程在t 线程对象的监视器上等待 ，当前线程等待时间超过了 n 毫秒，或t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从 TIMED_WAITING --> RUNNABLE

情况 7 RUNNABLE <--> TIMED_WAITING

当前线程调用 Thread.sleep(long n) ，当前线程从 RUNNABLE --> TIMED_WAITING

当前线程等待时间超过了 n 毫秒，当前线程从 TIMED_WAITING --> RUNNABLE

情况 8 RUNNABLE <--> TIMED_WAITING

当前线程调用 LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long millis) 时，当前线 程从 RUNNABLE --> TIMED_WAITING ，调用 LockSupport.unpark(目标线程) 或调用了线程 的 interrupt() ，或是等待超时，会让目标线程从 TIMED_WAITING--> RUNNABLE

情况 9 RUNNABLE <--> BLOCKED

t 线程用 synchronized(obj) 获取了对象锁时如果竞争失败，从RUNNABLE --> BLOCKED

持 obj 锁线程的同步代码块执行完毕，会唤醒该对象上所有 BLOCKED的线程重新竞争，如果其中 t 线程竞争 成功，从 BLOCKED --> RUNNABLE ，其它失败的线程仍然 BLOCKED

情况 10 RUNNABLE <--> TERMINATED

当前线程所有代码运行完毕，进入 TERMINATED

二、创建线程的几种方式

继承Thread类

方法介绍：

实现步骤：

  1. 定义一个类（MyThread），继承Thread类
  2. 在MyThread类中实现run()重写
  3. 创建MyThread类对象
  4. 启动线程，调用start()放法

代码实现：

public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
​
        my1.start();
        my2.start();
    }
}

实现Runnable接口

实现步骤：

  1. 定义一个类（MyRunnable），实现Runnable接口
  2. 在MyRunnable类中重写run()方法
  3. 创建MyRunnable类对象
  4. 创建Thread对象，将创建的MyRunnable类作为Thread对象构造方法的参数传入
  5. 调用Thread对象的start()方法

代码实现：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class MyRunnableDemo {
    public static void main(String[] args) {
        //创建MyRunnable类的对象
        MyRunnable my = new MyRunnable();
​
        //创建Thread类的对象，把MyRunnable对象作为构造方法的参数
        //Thread(Runnable target)
//        Thread t1 = new Thread(my);
//        Thread t2 = new Thread(my);
        //Thread(Runnable target, String name)
        Thread t1 = new Thread(my,"坦克");
        Thread t2 = new Thread(my,"飞机");
​
        //启动线程
        t1.start();
        t2.start();
    }
}

实现callable接口

方法介绍：

实现步骤：

  1. 创建一个类(MyCallable)实现Callable接口
  2. 重写Callable中的call()方法
  3. 创建MyCallable对象
  4. 创建Future实现类FutureTask对象，把Mycallable作为构造方法的参数
  5. 创建Thread对象，把FutureTask作为构造方法的参数
  6. 启动Thread线程，调用start()方法
  7. 调用FutureTask的get()方法，获取Mycallable的返回值，get方法会一直等待线程执行完获取结果，必须要放在start后面，否则会一直等待

代码实现：

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("跟女孩表白" + i);
        }
        //返回值就表示线程运行完毕之后的结果
        return "答应";
    }
}
public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程开启之后需要执行里面的call方法
        MyCallable mc = new MyCallable();
​
        //Thread t1 = new Thread(mc);
​
        //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
        FutureTask<String> ft = new FutureTask<>(mc);
​
        //创建线程对象
        Thread t1 = new Thread(ft);
        //开启线程
        t1.start();
​
        String s = ft.get();//该方法会一直等到线程执行完获取返回值，否则会一直等待，所以要放在start方法后面
        System.out.println(s);
    }
}

三种创建方式的区别

实现Runnable、Callable接口的的优点：

  • 好处：扩展性强，实现该接口的同时，还可以继承其他类
  • 缺点：编程相对复杂，不能直接调用Thread类方法

继承Thread类：

  • 好处：编程相对简单，可以直接调用Thread类方法
  • 缺点：可以拓展性较差，不能再继承其他类

Runnable和Callable的区别：

  • Runnable规定的方法是run(),Callable规定的方法
  • Runnable的run()方法不能抛出异常，而Callable的call()方法可以抛出异常
  • Runnable执行完毕后没有返回值，而Callable执行完毕后有返回值
  • Callable可与通过Future的实现类FutureTask的get()方法计算返回值

Thread和Runnable的区别：

Thread才是Java里对线程的唯一抽象，Runnable只是对任务（业务逻辑）的抽象。Thread可以接受任意一个Runnable的实例并执行。

因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了FutureTask。FutureTask类实现了RunnableFuture接口，RunnableFuture继承了Runnable接口和Future接口，而FutureTask实现了RunnableFuture接口。所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。因此我们通过一个线程运行Callable，但是Thread不支持构造方法中传递Callable的实例，所以我们需要通过FutureTask把一个Callable包装成Runnable，然后再通过这个FutureTask拿到Callable运行后的返回值。

新启线程有几种方式？

这个问题的答案其实众说纷纭，有2种，3种，4种等等答案，建议比较好的回答是：

按照Java源码中Thread上的注释：

官方说法是在Java中有两种方式创建一个线程用以执行，一种是派生自Thread类，另一种是实现Runnable接口。

当然本质上Java中实现线程只有一种方式，都是通过new Thread()创建线程对象，调用Thread#start启动线程。

至于基于callable接口的方式，因为最终是要把实现了callable接口的对象通过FutureTask包装成Runnable，再交给Thread去执行，所以这个其实可以和实现Runnable接口看成同一类。

而线程池的方式，本质上是池化技术，是资源的复用，和新启线程没什么关系。

所以，比较赞同官方的说法，有两种方式创建一个线程用以执行。

三、多线程的常见方法

start和run

  • run：是多线程的方法体，调用多线程时执行的代码块，如果直接调用run那么就像直接调用方法一样，不会启动多线程（正确方法时通过调用start方法启动多线程执行run方法）
  • start：使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码，底层会调用native方法，通过操作系统进行操作

Thread类是Java里对线程概念的抽象，可以这样理解：我们通过new Thread()其实只是new出一个Thread的实例，还没有操作系统中真正的线程挂起钩来。只有执行了start()方法后，才实现了真正意义上的启动线程。

从Thread的源码可以看到，Thread的start方法中调用了start0()方法，而start0()是个native方法，这就说明Thread#start一定和操作系统是密切相关的。

start()方法让一个线程进入就绪队列等待分配cpu，分到cpu后才调用实现的run()方法，start()方法不能重复调用，如果重复调用会抛出异常（注意，此处可能有面试题：多次调用一个线程的start方法会怎么样？）。

而run方法是业务逻辑实现的地方，本质上和任意一个类的任意一个成员方法并没有任何区别，可以重复执行，也可以被单独调用。

优先级Priority

线程调度两种调度方式：

  • 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
  • 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些

Java使用的是抢占式调度模型

  • 随机性：假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

优先级相关方法

代码演示：

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
        return "线程执行完毕了";
    }
}
public class Demo {
    public static void main(String[] args) {
        //优先级: 1 - 10 默认值:5
        MyCallable mc = new MyCallable();
​
        FutureTask<String> ft = new FutureTask<>(mc);
​
        Thread t1 = new Thread(ft);
        t1.setName("飞机");
        t1.setPriority(10);
        //System.out.println(t1.getPriority());//5
        t1.start();
​
        MyCallable mc2 = new MyCallable();
​
        FutureTask<String> ft2 = new FutureTask<>(mc2);
​
        Thread t2 = new Thread(ft2);
        t2.setName("坦克");
        t2.setPriority(1);
        //System.out.println(t2.getPriority());//5
        t2.start();
    }
}

守护线程Daemon

相关方法：

代码演示：

public class MyThread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + "---" + i);
        }
    }
}
public class MyThread2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "---" + i);
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();
​
        t1.setName("女神");
        t2.setName("备胎");
​
        //把第二个线程设置为守护线程
        //当普通线程执行完之后,那么守护线程也没有继续运行下去的必要了.
        t2.setDaemon(true);
​
        t1.start();
        t2.start();
    }
}

sleep

特点：

  • 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
  •  其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
  • 睡眠结束后的线程未必会立刻得到执行
  • 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

代码演示：

  public static void main(String[] args) {
        
        
        new Thread(()->{
            try {
                //方式一
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
          
            try {
                //方式二
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

yield

特点：

  • 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程
  • 具体的实现依赖于操作系统的任务调度器
  • 有可能会出现让出时间片不成功的现象，因为当让出时间片后就进入就绪状态，很可能会重新再次获得时间片

代码演示：

 public static void main(String[] args) {


       Thread thread = new Thread();
       thread.yield();//进入就绪状态，让出时间片

    }

join

特点：

  • 当线程调用join方法之后，就会让主线程进入阻塞状态，直到所有被标记为join方法的线程执行完成后才能开始执行主线程

join的两种调用方式：

  • join（）   ：不添加时间参数，即等待线程完成后主线程才开始运行
  • join（i）   ：添加时间参数，主线程最多等待i毫秒，超过i毫秒后如果还没完成，主线程也开始执行，如果参数是0，就无限等待，相当于无参调用

代码演示：

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


        MyThread myThread1 = new MyThread("线程一");

        myThread1.start();

        myThread1.join();
        
        System.out.println("我主线程先完成了");

    }

park，unpark

  • 通过LockSupport.park可以暂停某个线程。通过LockSupport.unpark可以恢复某个线程运行
  • 与 Object 的 wait & notify 相比 wait，notify 和 notifyAll 必须配合 Object Monitor 一起使用，而 park，unpark 不必
  • LockSupport.unpark(t1);park & unpark 是以线程为单位来【阻塞】和【唤醒】线程，而 notify 只能随机唤醒一个等待线程，notifyAll 是唤醒所有等待线程，就不那么【精确】
  • park & unpark 可以先 unpark，而 wait & notify 不能先 notify

原理：

每个线程都有自己的一个 Parker 对象，由三部分组成 _counter ， _cond 和 _mutex 打个比喻

线程就像一个旅人，Parker 就像他随身携带的背包，条件变量就好比背包中的帐篷。_counter 就好比背包中的备用干粮（0 为耗尽，1 为充足） 调用 park 就是要看需不需要停下来歇息 ，如果备用干粮耗尽，那么钻进帐篷歇息 ，如果备用干粮充足，那么不需停留，继续前进 ，调用 unpark，就好比令干粮充足 ，如果这时线程还在帐篷，就唤醒让他继续前进，如果这时线程还在运行，那么下次他调用 park 时，仅是消耗掉备用干粮，不需停留继续前进，因为背包空间有限，多次调用 unpark 仅会补充一份备用干粮

1. 当前线程调用 Unsafe.park() 方法

2. 检查 _counter ，本情况为 0，这时，获得 _mutex 互斥锁

3. 线程进入 _cond 条件变量阻塞

4. 设置 _counter = 0

1. 调用 Unsafe.unpark(Thread_0) 方法，设置 _counter 为 1

2. 唤醒 _cond 条件变量中的 Thread_0

3. Thread_0 恢复运行

4. 设置 _counter 为 0

 

1. 调用 Unsafe.unpark(Thread_0) 方法，设置 _counter 为 1

2. 当前线程调用 Unsafe.park() 方法

3. 检查 _counter ，本情况为 1，这时线程无需阻塞，继续运行

4. 设置 _counter 为 0

interrupt

方法介绍：

interrupt中断sleep，wait，join的线程：

会打断当前的等待状态，如果需要锁的则会等待获取锁，如果不需要所得会进入就绪状态，等待获取时间片

interrupt的作用：是中断线程，如果线程不是处于wait、timewait、block状态的话，实际上并不会直接中断线程，而是给线程一个打断状态，我们需要在代码中判断打断状态是否为true（默认值为false），如果为true表示按照逻辑是希望线程终止的，这时候我们可以写一些善后代码，体面终止线程

如果线程是处于wait、timewait、block状态，使线程开始运行，并且会清空打断状态，打断状态还是fasle

  •  
    方法说明
    interrupt()打断线程
    isinterrupted()判断是否被打断，不会清空打断标记
    interrupted()判断是否被打断，会清空打断标记

interrupt打断正常运行的线程：

  • 表面上并不会出现任何情况，但是会将打断状态设置成true，用户可以根据实际情况进行处理

interrupt打断park线程：

代码演示：

private static void test4() {
 Thread t1 = new Thread(() -> {
 for (int i = 0; i < 5; i++) {
 log.debug("park...");
 LockSupport.park();
 log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
 }
 });
 t1.start();
 sleep(1);
 t1.interrupt();
}

  • park线程只会使打断状态为false的线程进入阻塞，第一次park能够成功，但是当通过interrupt打断了之后，再次park就会失效，除非将打断状态设置成false

对于线程的中断，除了interrupt还有其他两种方式，但是都不推荐使用：

暂停、恢复和停止操作对应在线程Thread的API就是suspend()、resume()和stop()。但是这些API是过期的，也就是不建议使用的。不建议使用的原因主要有：以suspend()方法为例，在调用后，线程不会释放已经占有的资源（比如锁），而是占有着资源进入睡眠状态，这样容易引发死锁问题。同样，stop()方法在终结一个线程时不会保证线程的资源正常释放，通常是没有给予线程完成资源释放工作的机会，因此会导致程序可能工作在不确定状态下。正因为suspend()、resume()和stop()方法带来的副作用，这些方法才被标注为不建议使用的过期方法。

wait、notify

原理：

  • Owner 线程发现条件不满足，调用 wait 方法，即可进入 WaitSet 变为 WAITING 状态
  • BLOCKED 和 WAITING 的线程都处于阻塞状态，不占用 CPU 时间片
  • BLOCKED 线程会在 Owner 线程释放锁时唤醒
  • WAITING 线程会在 Owner 线程调用 notify 或 notifyAll 时唤醒，但唤醒后并不意味者立刻获得锁，仍需进入 EntryList 重新竞争
  • wait和notify都是object的方法，必须要获取对象的锁之后才能使用wait和notify进行等待和唤醒

 方法介绍

方法介绍
wait（）无限期等待，直到被唤醒
wait（long i）等待i毫秒，如果没被唤醒则停止等待
notify（）随机唤醒一个
notifyAll（）唤醒所有wait线程

wait和sleep的区别

sleep是thread方法，而wait是object方法

sleep不需要强制和synchronized配合使用，wait需要和synchronized配合使用

sleep在睡眠的同时不会释放锁，wait在睡眠的时候会释放锁

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

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

相关文章

Databend 开源周报第 108 期

Databend 开源周报第 108 期

Databend 是一款现代云数仓。专为弹性和高效设计&#xff0c;为您的大规模分析需求保驾护航。自由且开源。即刻体验云服务&#xff1a;https://app.databend.cn 。 Whats On In Databend 探索 Databend 本周新进展&#xff0c;遇到更贴近你心意的 Databend 。 多源数据目录 …
阅读更多...
前端工程化

前端工程化

前后端混合开发 前后端分离开发 接口文档&#xff1a;一个业务功能就是一个接口 开发某个功能的流程&#xff1a; 需求分析&#xff0c;接口定义&#xff08;API接口文档&#xff09;&#xff0c;前后端并行开发&#xff08;遵守规范&#xff09;&#xff0c;测试&#xff…
阅读更多...
SpringWeb(SpringMVC)

SpringWeb(SpringMVC)

目录 SpringWeb介绍 搭建 SpringWeb SpringWeb介绍 Spring Web是一个基于 Servlet API 构建的原始 web 框架&#xff0c;用于构建基于MVC模式的Web应用程序。在 web 层框架历经 Strust1&#xff0c;WebWork&#xff0c;Strust2 等诸多产品的历代更选 之后&#xff0c;目前业界普…
阅读更多...
比较器的工作原理及性能指标介绍

比较器的工作原理及性能指标介绍

一、什么是比较器 比较器的功能是比较两个或更多数据项&#xff0c;以确定它们是否相等&#xff0c;或者确定它们之间的大小关系和排列顺序&#xff0c;这称为比较。可以实现此比较功能的电路或设备称为比较器。比较器是将模拟电压信号与参考电压进行比较的电路。比较器的两个…
阅读更多...
深度学习论文: Segment Any Anomaly without Training via Hybrid Prompt Regularization

深度学习论文: Segment Any Anomaly without Training via Hybrid Prompt Regularization

深度学习论文: Segment Any Anomaly without Training via Hybrid Prompt Regularization Segment Any Anomaly without Training via Hybrid Prompt Regularization PDF: https://arxiv.org/pdf/2305.10724.pdf PyTorch代码: https://github.com/shanglianlm0525/CvPytorch Py…
阅读更多...
前端：横向滚动条，拖动进行左右滚动（含隐藏滚动条）

前端：横向滚动条，拖动进行左右滚动（含隐藏滚动条）

效果 代码 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><meta http-equiv"X-UA-Compatible" content"IEedge"><meta name"viewport" content"widthdevice-width, i…
阅读更多...
gdb基本使用快捷键

gdb基本使用快捷键

gdb 1. gdb简介2.基本命令2.1 进入/退出2.2 基本使用2.3 执行语句2.4 查看变量2.5 禁用/启用断点 1. gdb简介 gdb是Linux下的代码调试工具。 程序的发布有debug模式和release模式&#xff0c;Linux的gcc/g模式&#xff0c;默认是release模式。若想在Linux下调试&#xff0c;程…
阅读更多...
NewStarCTF 2022 web方向题解 wp

NewStarCTF 2022 web方向题解 wp

----------WEEK1---------- BUU NewStarCTF 公开赛赛道 WEEK1 [NotPHP] 先看题目&#xff0c;要传参加绕过。 分析一下代码&#xff1a;首先get一个datadata://test/plain,Wel…。然后key1和2用数组可以绕过。num2077a可以绕过弱类型。eval()中的php语句被#注释了&#xff0c…
阅读更多...
美创科技一体化智能化公共数据平台数据安全建设实践

美创科技一体化智能化公共数据平台数据安全建设实践

公共数据是当今政府数字化转型的关键要素和未来价值释放的核心锚点&#xff0c;也是“网络强国”、“数字中国”的战略性资源。 作为数字化改革先行省份&#xff0c;近年来&#xff0c;浙江省以一体化智能化公共数据平台作为数字化改革的支撑总平台&#xff0c;实现了全省公共数…
阅读更多...
基于OpenCV+LPR模型端对端智能车牌识别——深度学习和目标检测算法应用(含Python+Andriod全部工程源码)+CCPD数据集

基于OpenCV+LPR模型端对端智能车牌识别——深度学习和目标检测算法应用(含Python+Andriod全部工程源码)+CCPD数据集

目录 前言总体设计系统整体结构图系统流程图 运行环境Python 环境OpenCV环境Android环境1. 开发软件和开发包2. JDK设置3. NDK设置 模块实现1. 数据预处理2. 模型训练1&#xff09;训练级联分类器2&#xff09;训练无分割车牌字符识别模型 3. APP构建1&#xff09;导入OpenCV库…
阅读更多...
零基础如何使用IDEA启动前后端分离中的前端项目（Vue）？

零基础如何使用IDEA启动前后端分离中的前端项目（Vue）？

一、在IDEA中配置vue插件 点击File-->Settings-->Plugins-->搜索vue.js插件进行安装&#xff0c;下面的图中我已经安装好了 二、搭建node.js环境 安装node.js 可以去官网下载&#xff1a;安装过程就很简单&#xff0c;直接下一步就行 测试是否安装成功&#xff1a;要…
阅读更多...
input时间表单默认样式修改（input[type=“date“]）

input时间表单默认样式修改（input[type=“date“]）

一、时间选择的种类: HTML代码&#xff1a; <input type"date" value"2018-11-15" />选择日期&#xff1a; 选择时间&#xff1a; <input type"time" value"22:52" />在这里插入图片描述 选择星期&#xff1a; <…
阅读更多...
Leetcode:【448. 找到所有数组中消失的数字】题解

Leetcode:【448. 找到所有数组中消失的数字】题解

题目 给你一个含 n 个整数的数组 nums &#xff0c;其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字&#xff0c;并以数组的形式返回结果。 难度&#xff1a;简单 题目链接&#xff1a;448. 找到所有数组中消失的数字 示例1 输入&…
阅读更多...
服务器数据恢复-重组RAID导致RAID6数据丢失的数据恢复案例

服务器数据恢复-重组RAID导致RAID6数据丢失的数据恢复案例

服务器数据恢复环境&#xff1a; 一台存储设备中有一组由12块硬盘组建的RAID6磁盘阵列&#xff0c;上层采用EXT3文件系统&#xff0c;共划分3个LUN。 服务器故障&分析&#xff1a; 存储设备在运行过程中RAID6阵列突然不可用&#xff0c;管理员对故障存储进行了重新分配RAI…
阅读更多...
从C过渡到C ++的3个理由

从C过渡到C ++的3个理由

几十年来&#xff0c;嵌入式软件工程师之间一直在争论他们应该使用C还是C 。根据2020年嵌入式市场调查&#xff0c;在大多数情况下&#xff0c;微控制器制造商提供的软件都以C语言提供&#xff0c;实际上&#xff0c;有56&#xff05;的嵌入式软件是用C语言编写的。但是&#x…
阅读更多...
PHP自己的框架PDO数据表前缀、alias、model、table、join方法实现（完善篇九--结束）

PHP自己的框架PDO数据表前缀、alias、model、table、join方法实现（完善篇九--结束）

一、实现功能&#xff0c;数据表前缀、alias、model、table、join方法实现 二、表前缀实现 1、config.php增加表前缀 DB_PEX>fa_,//数据库前缀 2、增加表前缀方法function.php function model($table){$modelnew ModelBase($table,config("DB_PEX"));return $m…
阅读更多...
查看edge浏览器插件的安装位置

查看edge浏览器插件的安装位置

C:\Users\zhang\AppData\Local\Microsoft\Edge\User Data\Default\Extensions 这是我的目录&#xff0c;把中间的的替换成你的电脑用户名就可以了 你也可以先输入目录的部分名称&#xff0c;下拉找对应的目录
阅读更多...
【juc】读写锁ReentrantReadWriteLock

【juc】读写锁ReentrantReadWriteLock

目录 一、说明二、读读不互斥2.1 代码示例2.2 截图示例 三、读写互斥3.1 代码示例3.2 截图示例 四、写写互斥4.1 代码示例4.2 截图示例 五、注意事项5.2.1 代码示例5.2.2 截图示例 一、说明 1.当读操作远远高于写操作时&#xff0c;使用读写锁让读读可以并发&#xff0c;来提高…
阅读更多...
python matlab 画柱状图

python matlab 画柱状图

函数&#xff1a; bar(x, height, width0.8, bottomNone, *, aligncenter,dataNone, **kwargs) 设置坐标的刻度(ticks)&#xff0c;轴的标签和标题 在数据分析的很多时候&#xff0c;我们各个柱下面通常不是x刻度值&#xff0c;而是有实际意义的字符串&#xff0c;那么这个时…
阅读更多...
ceph对象三元素data、xattr、omap

ceph对象三元素data、xattr、omap

这里有一个ceph的原则&#xff0c;就是所有存储的不管是块设备、对象存储、文件存储最后都转化成了底层的对象object&#xff0c;这个object包含3个元素data&#xff0c;xattr&#xff0c;omap。data是保存对象的数据&#xff0c;xattr是保存对象的扩展属性&#xff0c;每个对象…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站