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

news2025/1/10 10:40:50

一、多线程的相关知识

栈与栈帧

我们都知道 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.coloradmin.cn/o/945947.html

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

相关文章

Linux 常用命令 2

Linux 常用命令 2

Linux 常用命令 2 1、组和权限管理1.1、ls 指令1.2、chown 指令1.3、chgrp 指令1.4、chmod 指令1.5、chown 指令1.6、chgrp 指令 2、crond 任务调度2.1、crontab2.2、时间格式2.3、脚本无法执行问题2.4、案例 3、进程管理3.1、ps 指令3.2、kill 和 killall 指令3.3、pstree 指令…
阅读更多...
《开发实战》12 | 异常处理：别让自己在出问题的时候变为瞎子

《开发实战》12 | 异常处理：别让自己在出问题的时候变为瞎子

12 | 异常处理&#xff1a;别让自己在出问题的时候变为瞎子 捕获和处理异常容易犯的错 “统一异常处理”方式正是我要说的第一个错&#xff1a;不在业务代码层面考虑异常处理&#xff0c;仅在框架层面粗犷捕获和处理异常。为了理解错在何处&#xff0c;先看看大多数业务应用都…
阅读更多...
python学习2之sublime text编辑器安装配置使用

python学习2之sublime text编辑器安装配置使用

1、在windows系统中使用sublime text 下载地址 https://www.sublimetext.com/3 2、在sublime text中运行python程序 代码运行可选择菜单Tools->Build或者按CtrlB 3、定制sublime text的设置 3.1将制表符转换为空格 选择菜单view->indentation,核实选择了复选框indent u…
阅读更多...
【1++的数据结构】之AVL树

【1++的数据结构】之AVL树

&#x1f44d;作者主页&#xff1a;进击的1 &#x1f929; 专栏链接&#xff1a;【1的数据结构】 文章目录 一&#xff0c;什么是AVL树二&#xff0c;AVL树的插入三&#xff0c;AVL树的旋转3.1 向左旋转3.2 向右旋转3.3 左右双旋3.4 右左双旋 四&#xff0c;验证AVL树是否平衡 …
阅读更多...
前端学习之轮播图

前端学习之轮播图

前端学习之轮播图 该案例涉及到定时器的使用&#xff0c;元素的活获取&#xff0c;函数的调用等知识的运用 显示图如下&#xff1a;可以点击图标跳转图片&#xff0c;也可以自动轮播 源码如下 <!DOCTYPE html> <html><head><meta charset"UTF-8&q…
阅读更多...
监控抽烟检测识别算法

监控抽烟检测识别算法

监控抽烟检测识别算法采用yolov7系列网络模型深度学习图像识别技术&#xff0c;监控抽烟检测识别算法能够准确识别人员抽烟的动作和烟雾&#xff0c;监控抽烟检测识别算法一旦发现有人员在禁烟区域内抽烟&#xff0c;将立即触发预警。YOLO的结构非常简单&#xff0c;就是单纯的…
阅读更多...
正中优配：“核污染防治”炒作按下暂停键， 中电环保、建龙微纳大跌

正中优配：“核污染防治”炒作按下暂停键， 中电环保、建龙微纳大跌

连日大涨的核污染防治炒作“步伐”放缓。 8月29日上午&#xff0c;核污染防治概念股多数低开&#xff0c;截止到午间休市&#xff0c;此前4个交易日累计涨超80%的中电环保&#xff08;300172.SZ&#xff09;大跌6.76%。 8月28日晚间&#xff0c;中电环保发布异动公告&#xff…
阅读更多...
遗传算法决策变量降维的matlab实现

遗传算法决策变量降维的matlab实现

1.案例背景 1.1遗传算法概述 遗传算法是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型,是一种通过模拟自然进化过程搜索最优解的方法。它最初由美国Michigan大学的J. Holland教授提出,1967年, Holland 教授的学生 Bagley在其博士论文中首次提出了“遗传…
阅读更多...
三电平离网逆变器接不平衡负载仿真

三电平离网逆变器接不平衡负载仿真

文章目录 **0、系统框图****1、纯阻性负载R****2、纯感性负载L****3、纯容性负载C****4、 RL负载****5、RC负载****6、CL负载****7、RLC负载** 0、系统框图 闭环控制 PWM调制 逆变桥 LCL滤波电路 负载&#xff08;可配置&#xff09; 坐标变换&#xff08;采样得到&#xff09;…
阅读更多...
SAP_ABAP_FUNCTION_ALV案例

SAP_ABAP_FUNCTION_ALV案例

SAP ABAP顾问能力模型梳理_企业数字化建设者的博客-CSDN博客SAP Abap顾问能力模型https://blog.csdn.net/java_zhong1990/article/details/132469977 一、Function ALV 1.1 基于退货采购订单创建&#xff0c;解释 FUNCTION_ALV开发的程序结构与代码模板参考 1.2 程序结构 to…
阅读更多...
ORA-00604 ORA-00069报错

ORA-00604 ORA-00069报错

在测试环境上删除用户&#xff0c;报错如下 rop user "USR_EOS" cascade; * ERROR at line 1: ORA-00604: error occurred at recursive SQL level 1 ORA-00069: cannot acquire lock -- table locks disabled for T_EMPLOYEE 解决方法 alter table USR_EOS.T_EMPL…
阅读更多...
运维架构师：驱动企业运维向高效发展“

运维架构师：驱动企业运维向高效发展“

运维架构师是高级运维工程师的角色&#xff0c;主要负责运维工作的策划和执行。他们需要熟练掌握开源工具&#xff0c;但更重要的是运用思维来进行运维工作&#xff0c;实现DevOps理念和解决各种企业运营中的挑战。他们的职责包括设计各种运维解决方案&#xff0c;例如自动化代…
阅读更多...
Python框架【模板继承、继承模板实战、装饰器、蓝图（介绍、单文件、目录结构、模版文件、静态文件 url_for函数子域名实现）】(五)

Python框架【模板继承、继承模板实战、装饰器、蓝图（介绍、单文件、目录结构、模版文件、静态文件 url_for函数子域名实现）】(五)

&#x1f44f;作者简介&#xff1a;大家好&#xff0c;我是爱敲代码的小王&#xff0c;CSDN博客博主,Python小白 &#x1f4d5;系列专栏&#xff1a;python入门到实战、Python爬虫开发、Python办公自动化、Python数据分析、Python前后端开发 &#x1f4e7;如果文章知识点有错误…
阅读更多...
深入解析SNMP协议及其在网络设备管理中的应用

深入解析SNMP协议及其在网络设备管理中的应用

SNMP&#xff08;Simple Network Management Protocol&#xff0c;简单网络管理协议&#xff09;作为一种用于网络设备管理的协议&#xff0c;在实现网络设备的监控、配置和故障排除方面发挥着重要的作用。本文将深入解析SNMP协议的工作原理、重要概念和功能&#xff0c;并探讨…
阅读更多...
回首一路坎坷，献给刚入测试的你

回首一路坎坷，献给刚入测试的你

恍惚间&#xff0c;已经进入测试岗位四年多的时间了&#xff0c;回顾过往&#xff0c;思绪良多&#xff0c;一路走来&#xff0c;或多或少的经历了一些坎坷&#xff0c;也遇到了不少的困难&#xff0c;也曾四顾迷茫&#xff0c;在此&#xff0c;我结合了自己的一些心得&#xf…
阅读更多...
【实训项目】精点考研

【实训项目】精点考研

1.设计摘要 如果说高考是一次能够改变命运的考试&#xff0c;那么考研应该是另外一次。为什么那么多人都要考研呢&#xff1f;从中国教育在线官方公布是考研动机调查来看&#xff0c;大家扎堆考研的原因大概集中在这6个方面&#xff1a;本科就业压力大&#xff0c;提升竞争力、…
阅读更多...
C++ 面试题（一）--C++基础，面向对象，内存管理

C++ 面试题（一）--C++基础，面向对象，内存管理

目录 1.part1 C基础 1 C特点 2 说说C语言和C的区别 3 说说 C中 struct 和 class 的区别 4 include头文件的顺序以及双引号""和尖括号<>的区别 5 说说C结构体和C结构体的区别 6 导入C函数的关键字是什么&#xff0c;C编译时和C有什么不同&#xff1f; 7…
阅读更多...
Tomcat安装及基本使用

Tomcat安装及基本使用

1. 什么是Web服务器 Web服务器是一种应用程序&#xff08;软件&#xff09;&#xff0c;它封装了对HTTP协议的操作&#xff0c;使得开发人员无需直接操作协议&#xff0c;从而简化了Web开发。其主要功能是提供网上信息浏览服务。 Web服务器安装在服务器端&#xff0c;我们可以…
阅读更多...
JavaWeb 速通JSON

JavaWeb 速通JSON

目录 一、JSON快速入门 1.基本介绍 : 2.定义格式 : 3.入门案例 : 二、JSON对象和字符串的相互转换 1.常用方法 : 2.应用实例 : 3.使用细节 : 三、JSON在Java中的使用 1.基本说明 : 2.应用场景 : 2.1 JSON <---> JavaBean 2.2 JSON <---> List 2.3 JSON …
阅读更多...
java对时间序列根据阈值进行连续性分片

java对时间序列根据阈值进行连续性分片

问题描述&#xff1a;我需要对一个连续的时间戳list进行分片&#xff0c;分片规则是下一个数据比当前数据要大于某一个阈值则进行分片&#xff1b; 解决方式&#xff1a; 1、输入的有顺序的list &#xff0c;和需要进行分片的阈值 2、调用方法&#xff0c;填入该排序的list和阈…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023