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 {@Overridepublic 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 {@Overridepublic 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> {@Overridepublic 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> {@Overridepublic 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 默认值:5MyCallable mc = new MyCallable();
​FutureTask<String> ft = new FutureTask<>(mc);
​Thread t1 = new Thread(ft);t1.setName("飞机");t1.setPriority(10);//System.out.println(t1.getPriority());//5t1.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());//5t2.start();}
}

守护线程Daemon

相关方法：

代码演示：

public class MyThread1 extends Thread {@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(getName() + "---" + i);}}
}
public class MyThread2 extends Thread {@Overridepublic 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.mzph.cn/news/58514.shtml

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

相关文章

算法通过村第四关-栈白银笔记|括号问题

算法通过村第四关-栈白银笔记|括号问题

文章目录 前言1. 括号匹配问题2. 最小栈问题3. 最大栈 总结 前言 提示&#xff1a;如果让我送给年轻人四个字&#xff0c;就是&#xff1a;量力而行。 量力而行不会失眠&#xff0c;不会啃老&#xff0c;不会为各种考试焦虑。顺其自然活得轻松。其实&#xff0c;量力而行最易大…
阅读更多...
小米面试题——不用加减乘除计算两数之和

小米面试题——不用加减乘除计算两数之和

前言 &#xff08;1&#xff09;刷B站看到一个面试题&#xff0c;不用加减乘除计算两数之和。 &#xff08;2&#xff09;当时我看到这个题目&#xff0c;第一反应就是感觉这是一个数电题目。不过需要采用C语言的方式编写出来。 &#xff08;3&#xff09;不过看到大佬的代码之…
阅读更多...
算法与数据结构（九）--并查集

算法与数据结构（九）--并查集

并查集是一种树型的数据结构&#xff0c;并查集可以高校地进行如下操作&#xff1a; *查询元素p和元素q是否在同一组 *合并元素p和元素q所在的组 一.并查集结构 并查集也是一种树型结构&#xff0c;这种树的要求比较简单&#xff1a;1.每个元素都唯一的对应一个结点&#xff…
阅读更多...
优美而高效：解决服务器通信问题

优美而高效：解决服务器通信问题

题目背景 在这个问题中&#xff0c;我们面临着一幅服务器分布图。图中的每个单元格可能有服务器&#xff08;标记为1&#xff09;或者没有&#xff08;标记为0&#xff09;。我们的任务是找出能够与至少一台其他服务器进行通信的服务器数量。 算法思路 为了解决这个问题&…
阅读更多...
无涯教程-Python机器学习 - Stochastic Gradient Boosting函数

无涯教程-Python机器学习 - Stochastic Gradient Boosting函数

它也称为梯度提升机。在下面的Python食谱中,我们将通过使用pima Indians糖尿病数据集上的 sklearn 的 GradientBoostingClassifier 类来创建随机梯度Boostingensemble模型进行分类。 首先,导入所需的软件包,如下所示: from pandas import read_csv from sklearn.model_select…
阅读更多...
国民八路参考文献：［８］许少辉．乡村振兴战略下传统村落文化旅游设计［Ｍ］北京：中国建筑工业出版社，２０２２．

国民八路参考文献：［８］许少辉．乡村振兴战略下传统村落文化旅游设计［Ｍ］北京：中国建筑工业出版社，２０２２．

国民八路参考文献&#xff1a;&#xff3b;&#xff18;&#xff3d;许少辉&#xff0e;乡村振兴战略下传统村落文化旅游设计&#xff3b;&#xff2d;&#xff3d;北京&#xff1a;中国建筑工业出版社&#xff0c;&#xff12;&#xff10;&#xff12;&#xff12;&#xff0…
阅读更多...
SpringCloud教程 | 第二篇: 服务消费者（rest+ribbon）

SpringCloud教程 | 第二篇: 服务消费者（rest+ribbon）

在上一篇文章&#xff0c;讲了服务的注册和发现。在微服务架构中&#xff0c;业务都会被拆分成一个独立的服务&#xff0c;服务与服务的通讯是基于http restful的。Spring cloud有两种服务调用方式&#xff0c;一种是ribbonrestTemplate&#xff0c;另一种是feign。在这一篇文章…
阅读更多...
Python requests实现图片上传接口自动化测试

Python requests实现图片上传接口自动化测试

最近帮别人写个小需求&#xff0c;需要本地自动化截图&#xff0c;然后图片自动化上传到又拍云&#xff0c;实现自动截图非常简单&#xff0c;在这里就不详细介绍了&#xff0c;主要和大家写下&#xff0c;如何通过Pythonrequests实现上传本地图片到又拍云服务器。 话不多说&a…
阅读更多...
Kali 软件管理

Kali 软件管理

kali 更新 1. 查看发行版本 ┌──(root㉿kali)-[~] └─# lsb_release -a No LSB modules are available. Distributor ID: Kali Description: Kali GNU/Linux Rolling Release: 2023.2 Codename: kali-rolling2. 查看内核版本 ┌──(root㉿kali)-[~] └─…
阅读更多...
正则常见问题及解决方案

正则常见问题及解决方案

使用正则处理问题的基本思路。有一些方法比较固定&#xff0c;比如将问题分解成多个小问题&#xff0c;每个小问题见招拆招&#xff1a;某个位置上可能有多个字符的话&#xff0c;就⽤字符组。某个位置上有多个字符串的话&#xff0c;就⽤多选结构。出现的次数不确定的话&#…
阅读更多...
突破连接壁垒，火山引擎边缘云网络的先行之路

突破连接壁垒，火山引擎边缘云网络的先行之路

在万物互联时代&#xff0c;信息不局限于人与人之间的交流&#xff0c;大量的机器设备也需要进行信息交流。就在去年&#xff0c;我国率先迎来了“物超人”的历史性时刻&#xff0c;即物联网连接数超越了人联网连接数。边缘云的发展进入到“黄金十年”。 “要致富&#xff0c;…
阅读更多...
JavaFX 加载 fxml 文件

JavaFX 加载 fxml 文件

JavaFX 加载 fxml 文件主要有两种方式&#xff0c;第一种方式通过 FXMLLoader 类直接加载 fxml 文件&#xff0c;简单直接&#xff0c;但是有些控件目前还不知道该如何获取&#xff0c;所以只能显示&#xff0c;目前无法处理。第二种方式较为复杂&#xff0c;但是可以使用与 fx…
阅读更多...
Docker容器与虚拟化技术：Docker compose部署LNMP

Docker容器与虚拟化技术：Docker compose部署LNMP

目录 一、理论 1.LNMP架构 2.背景 3.Dockerfile部署LNMP 3.准备Nginx镜像 4.准备MySQL容器 5.准备PHP镜像 6.上传wordpress软件包 7.编写docker-compose.yml 8.构建与运行docker-compose 9.启动 wordpress 服务 10.浏览器访问 11.将运行中的 docker容器保存为 doc…
阅读更多...
智能设计师的崛起：探寻智元兔AI设计师的神奇之旅

智能设计师的崛起：探寻智元兔AI设计师的神奇之旅

AI绘图是指利用人工智能技术来生成或改善绘图作品的方法和工具。通过使用深度学习和生成对抗网络等算法&#xff0c;人工智能可以学习和模仿艺术家的创作风格&#xff0c;生成逼真的艺术作品。 智元兔-AI设计师是一款基于人工智能设计工具&#xff0c;利用机器学习和深度学习技…
阅读更多...
什么是ChatGPT水印，ChatGPT生成的内容如何不被检测出来，原理什么？

什么是ChatGPT水印，ChatGPT生成的内容如何不被检测出来，原理什么？

太长不看版 1. 什么是ChatGPT水印&#xff1f; ChatGPT水印是AI以伪随机方式生成的独特tokens序列。该序列用来作为水印&#xff0c;以区分AI生成内容和人类原创内容。 2. 如何规避ChatGPT水印&#xff1f; 一种规避方法是使用其他AI模型改写ChatGPT生成的文本。这会破坏水…
阅读更多...
大数据（二）大数据行业相关统计数据

大数据（二）大数据行业相关统计数据

大数据&#xff08;二&#xff09;大数据行业相关统计数据 目录 一、大数据相关的各种资讯 二、转载自网络的大数据统计数据 2.1、国家大数据政策 2.2、产业结构分析 2.3、应用结构分析 2.4、数据中心 2.5、云计算 一、大数据相关的各种资讯 1. 据IDC预测&#xff0…
阅读更多...
JOJO的奇妙冒险

JOJO的奇妙冒险

JOJO,我不想再做人了。 推荐一部动漫 JOJO的奇妙冒险 荒木飞吕彦创作的漫画 《JOJO的奇妙冒险》是由日本漫画家荒木飞吕彦所著漫画。漫画于1987年至2004年在集英社的少年漫画杂志少年JUMP上连载&#xff08;1987年12号刊-2004年47号刊&#xff09;&#xff0c;2005年后在集英…
阅读更多...
全国首台！浙江机器人产业集团发布垂起固定翼无人机-机器人自动换电机巢

全国首台！浙江机器人产业集团发布垂起固定翼无人机-机器人自动换电机巢

展示突破性创新技术&#xff0c;共话行业发展趋势。8月25日&#xff0c;全国首台垂起固定翼无人机-机器人自动换电机巢新品发布会暨“科创中国宁波”无人机产业趋势分享会在余姚市机器人小镇成功举行。 本次活动在宁波市科学技术协会、余姚市科学技术协会指导下&#xff0c;由浙…
阅读更多...
DBO优化SVM的电力负荷预测，附MATLAB代码

DBO优化SVM的电力负荷预测，附MATLAB代码

今天为大家带来一期基于DBO-SVM的电力负荷预测。 原理详解 文章对支持向量机(SVM)的两个参数进行优化&#xff0c;分别是&#xff1a;惩罚系数c和 gamma。 其中&#xff0c;惩罚系数c表示对误差的宽容度。c越高&#xff0c;说明越不能容忍出现误差,容易过拟合。c越小&#xff0…
阅读更多...
Pytorch-以数字识别更好地入门深度学习

Pytorch-以数字识别更好地入门深度学习

目录 一、数据介绍 二、下载数据 三、可视化数据 四、模型构建 五、模型训练 六、模型预测 一、数据介绍 MNIST数据集是深度学习入门的经典案例&#xff0c;因为它具有以下优点&#xff1a; 1. 数据量小&#xff0c;计算速度快。MNIST数据集包含60000个训练样本和1000…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023

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