程序员经验分享-hwhale

多线程顺序打印的5种解法

2023-10-27

多线程同步的方式有许多，有传统的synchronized锁，还可以使用lock锁，下面列举多线程顺序打印的5种解法，算作对线程同步的一个总结。

经典面试题

下面是多线程顺序打印的经典面试题

1.三个线程分别打印 A，B，C，要求这三个线程一起运行，打印 n 次，输出形如“ABCABCABC…”的字符串

2.两个线程交替打印 0~100 的奇偶数

3.通过 N 个线程顺序循环打印从 0 至 100

4.多线程按顺序调用，A->B->C，AA 打印 5 次，BB 打印10 次，CC 打印 15 次，重复 10 次

5.用两个线程，一个输出字母，一个输出数字，交替输出 1A2B3C4D…26Z

多种解法

使用 Lock

我们以第一题为例：三个线程分别打印 A，B，C，要求这三个线程一起运行，打印 n 次，输出形如“ABCABCABC…”的字符串。

思路：使用一个取模的判断逻辑 C%M ==N，题为 3 个线程，所以可以按取模结果编号：0、1、2，他们与 3 取模结果仍为本身，则执行打印逻辑。

package cn.wideth.util.thread;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class PrintABCUsingLock {

    private int times; // 控制打印次数
    private int state;   // 当前状态值：保证三个线程之间交替打印
    private Lock lock = new ReentrantLock();

    public PrintABCUsingLock(int times) {
        this.times = times;
    }

    private void printLetter(String name, int targetNum) {

        for (int i = 0; i  < times;){
             lock.lock();
             if (state % 3 == targetNum) {
                 state++;
                 i++;
                 System.out.print(name);
            }
            lock.unlock();
        }
}

    public static void main(String[] args) {

        //顺序打印10次
        PrintABCUsingLock loopThread = new PrintABCUsingLock(10);

        new Thread(() -> {
            loopThread.printLetter("A", 0);
        }, "A").start();

        new Thread(() -> {
            loopThread.printLetter("B", 1);
        }, "B").start();
        
        new Thread(() -> {
            loopThread.printLetter("C", 2);
        }, "C").start();
    }

}

运行结果

在这里插入图片描述
程序分析

main 方法启动后，3 个线程会抢锁，但是 state 的初始值为 0，所以第一次执行 if 语句的内容只能是 线程 A，然后还在 for 循环之内，此时 state = 1，只有 线程 B 才满足 1% 3 == 1，所以第二个执行的是 B，同理只有 线程 C 才满足 2% 3 == 2，所以第三个执行的是 C，执行完 ABC 之后，才去执行第二次 for 循环，所以要把 i++ 写在 for 循环里边，不能写成 for (int i = 0; i < times;i++) 这样。

使用 wait/notify

其实遇到这类型题目，好多同学可能会先想到的就是 join()，或者 wati/notify 这样的思路。算是比较传统且万能的解决方案。也有些面试官会要求不能使用这种方式。

思路：还是以第一题为例，我们用对象监视器来实现，通过 wait 和 notify() 方法来实现等待、通知的逻辑，A 执行后，唤醒 B，B 执行后唤醒 C，C 执行后再唤醒 A，这样循环的等待、唤醒来达到目的。

package cn.wideth.util.thread;

public class PrintABCUsingWaitNotify {

    private int state;
    private int times;
    private static final Object LOCK = new Object();

    public PrintABCUsingWaitNotify(int times) {
        this.times = times;
    }

    private void printLetter(String name, int targetState) {
        for (int i = 0; i < times; i++)
            synchronized (LOCK) {
                while (state % 3 != targetState) {
                try {
                    LOCK.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            state++;
            System.out.print(name);
            LOCK.notifyAll();
        }
    }

    public static void main(String[] args) {

        PrintABCUsingWaitNotify printABC = new PrintABCUsingWaitNotify(10);
        new Thread(() -> {
            printABC.printLetter("A", 0);
        }, "A").start();
        new Thread(() -> {
            printABC.printLetter("B", 1);
        }, "B").start();
        new Thread(() -> {
            printABC.printLetter("C", 2);
        }, "C").start();
    }

}

在这里插入图片描述
同样的思路，来解决下第 2 题：两个线程交替打印奇数和偶数

使用对象监视器实现，两个线程 A、B 竞争同一把锁，只要其中一个线程获取锁成功，就打印 ++i，并通知另一线程从等待集合中释放，然后自身线程加入等待集合并释放锁即可。

package cn.wideth.util.thread;

public class OddEvenPrinter {

    private Object monitor = new Object();
    private final int limit;
    private volatile int count;

    OddEvenPrinter(int initCount, int times) {
        this.count = initCount;
        this.limit = times;
    }

    private void print() {

        synchronized (monitor) {
            while (count < limit){
            try {
                System.out.println(String.format("线程[%s]打印数字:%d", Thread.currentThread().getName(), ++count));
                monitor.notifyAll();
                monitor.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //防止有子线程被阻塞未被唤醒，导致主线程不退出
        monitor.notifyAll();
      }
   }

    public static void main(String[] args) {

        OddEvenPrinter printer = new OddEvenPrinter(0, 10);
        new Thread(printer::print, "odd").start();
        new Thread(printer::print, "even").start();
    }

}

运行结果

在这里插入图片描述
同样的思路，来解决下第 5 题：用两个线程，一个输出字母，一个输出数字，交替输出 1A2B3C4D…26Z。

package cn.wideth.util.thread;

public class NumAndLetterPrinter {

    private static char c = 'A';
    private static int i = 0;
    static final Object lock = new Object();

    public static void main(String[] args) {
        new Thread(() -> printer(), "numThread").start();
        new Thread(() -> printer(), "letterThread").start();
    }

    private static void printer() {
        synchronized (lock) {
            for (int i = 0; i < 26; i++) {
                if (Thread.currentThread().getName() == "numThread") {
                    //打印数字1-26
                    System.out.print((i + 1));
                    // 唤醒其他在等待的线程
                    lock.notifyAll();
                    try {
                        // 让当前线程释放锁资源，进入wait状态
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else if (Thread.currentThread().getName() == "letterThread") {
                    // 打印字母A-Z
                    System.out.print((char) ('A' + i));
                    // 唤醒其他在等待的线程
                    lock.notifyAll();
                    try {
                        // 让当前线程释放锁资源，进入wait状态
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            lock.notifyAll();
        }
    }
}

运行结果

在这里插入图片描述

使用 Lock/Condition

Condition 中的 await() 方法相当于 Object 的 wait() 方法，Condition 中的 signal() 方法相当于Object 的 notify() 方法，Condition 中的 signalAll() 相当于 Object 的 notifyAll() 方法。
 
不同的是，Object 中的 wait(),notify(),notifyAll()方法是和"同步锁"(synchronized关键字)捆绑使用的；而 Condition 是需要与"互斥锁"/"共享锁"捆绑使用的。

还是以第一题为例，使用 Condition 来实现，其实和 wait/notify 的思路一样。

package cn.wideth.util.thread;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class PrintABCUsingLockCondition {

    private int times;
    private int state;
    private static Lock lock = new ReentrantLock();
    private static Condition c1 = lock.newCondition();
    private static Condition c2 = lock.newCondition();
    private static Condition c3 = lock.newCondition();

    public PrintABCUsingLockCondition(int times) {
        this.times = times;
    }

    public static void main(String[] args) {
        PrintABCUsingLockCondition print = new PrintABCUsingLockCondition(10);
        new Thread(() -> {
            print.printLetter("A", 0, c1, c2);
        }, "A").start();
        new Thread(() -> {
            print.printLetter("B", 1, c2, c3);
        }, "B").start();
        new Thread(() -> {
            print.printLetter("C", 2, c3, c1);
        }, "C").start();
    }

    private void printLetter(String name, int targetState, Condition current, Condition next) {
        for (int i = 0; i < times;){
            lock.lock();
            try {
               while (state % 3 != targetState) {
                  current.await();
               }
            state++;
            i++;
            System.out.print(name);
            next.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
      }
   }
}

运行结果

在这里插入图片描述
使用 Lock 锁的多个 Condition 可以实现精准唤醒，所以碰到那种多个线程交替打印不同次数的题就比较容易想到，比如解决第四题：多线程按顺序调用，A->B->C，AA 打印 5 次，BB 打印10 次，CC 打印 15 次，重复 10 次。

代码就不贴了，思路相同。

以上几种方式，其实都会存在一个锁的抢夺过程，如果抢锁的的线程数量足够大，就会出现很多线程抢到了锁但不该自己执行，然后就又解锁或 wait() 这种操作，这样其实是有些浪费资源的。

使用Semaphore

在信号量上我们定义两种操作：信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。
 

  1. acquire(获取) 当一个线程调用 acquire 操作时，它要么通过成功获取信号量(信号量减1)，要么一直等下去，直到有线程释放信号量，或超时。
  2. release(释放)实际上会将信号量的值加1，然后唤醒等待的线程。

先看下如何解决第一题：三个线程循环打印 A，B，C

package cn.wideth.util.thread;

import java.util.concurrent.Semaphore;

public class PrintABCUsingSemaphore {

    public static void main(String[] args) {
        // 初始化许可数为1，A线程可以先执行
        Semaphore semaphoreA = new Semaphore(1);
        // 初始化许可数为0，B线程阻塞
        Semaphore semaphoreB = new Semaphore(0);
        // 初始化许可数为0，C线程阻塞
        Semaphore semaphoreC = new Semaphore(0);

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    // A线程获得许可，同时semaphoreA的许可数减为0,进入下一次循环时
                    // A线程会阻塞，知道其他线程执行semaphoreA.release();
                    semaphoreA.acquire();
                    // 打印当前线程名称
                    System.out.print(Thread.currentThread().getName());
                    // semaphoreB许可数加1
                    semaphoreB.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    semaphoreB.acquire();
                    System.out.print(Thread.currentThread().getName());
                    semaphoreC.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    semaphoreC.acquire();
                    System.out.print(Thread.currentThread().getName());
                    semaphoreA.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();
    }

}

运行结果

在这里插入图片描述
如果题目中是多个线程循环打印的话，一般使用信号量解决是效率较高的方案，上一个线程持有下一个线程的信号量，通过一个信号量数组将全部关联起来，这种方式不会存在浪费资源的情况。

接着用信号量的方式解决下第三题：通过 N 个线程顺序循环打印从 0 至 100

import java.util.concurrent.Semaphore;

public class LoopPrinter {

    //线程个数
    private final static int THREAD_COUNT = 3;
    private static int result = 0;
    //最大数字
    private static int maxNum = 10;

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

        final Semaphore[] semaphores = new Semaphore[THREAD_COUNT];
        for (int i = 0; i  < THREAD_COUNT; i++){           //非公平信号量，每个信号量初始计数都为1
            semaphores[i] = new Semaphore(1);
            if (i != THREAD_COUNT - 1) {
               //  System.out.println(i+"==="+semaphores[i].getQueueLength());
               //获取一个许可前线程将一直阻塞, for 循环之后只有 syncObjects[2] 没有被阻塞
                 semaphores[i].acquire();
            }
        }

        for (int i = 0; i  < THREAD_COUNT; i++){          // 初次执行，上一个信号量是 syncObjects[2]
            final Semaphore lastSemphore = i == 0 ? semaphores[THREAD_COUNT - 1] : semaphores[i - 1];
            final Semaphore currentSemphore = semaphores[i];
            final int index = i;
            new Thread(() -> {
            try {
             while (true) {
                // 初次执行，让第一个 for 循环没有阻塞的 syncObjects[2] 先获得令牌阻塞了
                lastSemphore.acquire();
                System.out.println("thread" + index + ": " + result++);
                if (result > maxNum) {
                    System.exit(0);
                }
                // 释放当前的信号量，syncObjects[0] 信号量此时为 1，下次 for 循环中上一个信号量即为syncObjects[0]
                currentSemphore.release();
             }
         } catch (Exception e) {
            e.printStackTrace();
        }
        }).start();
       }
    }
}

运行结果

在这里插入图片描述

使用LockSupport

LockSupport 是 JDK 底层的基于 sun.misc.Unsafe 来实现的类，用来创建锁和其他同步工具类的基本线程阻塞原语。它的静态方法unpark()和park()可以分别实现阻塞当前线程和唤醒指定线程的效果，所以用它解决这样的问题会更容易一些。(在 AQS 中，就是通过调用 LockSupport.park( )和 LockSupport.unpark() 来实现线程的阻塞和唤醒的。)

package cn.wideth.util.thread;

import java.util.concurrent.locks.LockSupport;

public class PrintABCUsingLockSupport {

    private static Thread threadA, threadB, threadC;

    public static void main(String[] args) {
        threadA = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                // 打印当前线程名称
                System.out.print(Thread.currentThread().getName());
                // 唤醒下一个线程
                LockSupport.unpark(threadB);
                // 当前线程阻塞
                LockSupport.park();
            }
        }, "A");
        threadB = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                // 先阻塞等待被唤醒
                LockSupport.park();
                System.out.print(Thread.currentThread().getName());
                // 唤醒下一个线程
                LockSupport.unpark(threadC);
            }
        }, "B");
        threadC = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                // 先阻塞等待被唤醒
                LockSupport.park();
                System.out.print(Thread.currentThread().getName());
                // 唤醒下一个线程
                LockSupport.unpark(threadA);
            }
        }, "C");
        threadA.start();
        threadB.start();
        threadC.start();
    }
}

在这里插入图片描述
理解了思路，解决其他问题就容易太多了。

比如，我们再解决下第五题：用两个线程，一个输出字母，一个输出数字，交替输出 1A2B3C4D…26Z。

package cn.wideth.util.thread;

import java.util.concurrent.locks.LockSupport;

public class NumAndLetterPrinterByLockSupport {

    private static Thread numThread, letterThread;

    public static void main(String[] args) {

        letterThread = new Thread(() -> {
            for (int i = 0; i < 26; i++) {
                System.out.print((char) ('A' + i));
                LockSupport.unpark(numThread);
                LockSupport.park();
            }
        }, "letterThread");

        numThread = new Thread(() -> {
            for (int i = 1; i <= 26; i++) {
                System.out.print(i);
                LockSupport.park();
                LockSupport.unpark(letterThread);
            }
        }, "numThread");
        numThread.start();
        letterThread.start();
    }
}

运行结果

在这里插入图片描述

本文小结

以上就是常用的五种实现方案，多练习几次，需要深刻理解thread和juc相关的知识。当然，这类问题，解决方式不止是我列出的这些，还会有 join、CountDownLatch、也有放在队列里解决的，思路有很多，面试官想考察的其实只是对多线程的编程功底，其实自己练习的时候，是个很好的巩固理解 JUC 的过程。

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

并发编程

核心知识点

多线程

多线程顺序打印的5种解法 的相关文章

  • 集合在多线程下 不安全的代码案例，以及解决方法

    package thread import java util import java util concurrent ConcurrentHashMap import java util concurrent CopyOnWriteArr

  • Cpp关键字破解（三）【volatile】篇

    关键字总结 volatile 文章目录 关键字总结 volatile 0 前言 1 概念 2 作用 3 使用场景 4 volatile成员函数 5 代码体验 0 前言 参考几位前辈博客 汇总整理了一下 C 中volatile关键字的使用详解

  • 锁介绍名词解释&&Lock && synchronized

    各种锁名词解释及应用 一 名词解释 1 乐观锁 VS 悲观锁 2 自旋锁 VS 适应性自旋锁 3 无锁 VS 偏向锁 VS 轻量级锁 VS 重量级锁 4 公平锁 VS 非公平锁 5 可重入锁 VS 非可重入锁 6 独享锁 VS 共享锁 二

  • 对聊天室的优化&常用参数配置

    优化处1 编码和解码 编码解码用的是JDK 对象与数组的转换 这种虽然简单 但是效率不高 现在需要支持更多的序列化算法 就需要改进 抽取一个接口 Serializer 用以支持 序列化和 反序列化 package com zhao prot

  • fcgi程序两种编写风格

    fcgi进程可以写成单线程的 也可以写成多线程的 单线程就是main函数中有一个死循环 一直等待接受请求 有请求过来时 就处理请求 并返回结果 没有并发性 多线程也分两种模式 一种是main函数起多个线程 每个线程都独立接受请求 另一种是m

  • brpc源码解析（十七）—— bthread上的类futex同步组件butex详解

    文章目录 一 futex简介 二 butex源码解析 2 1 butex相关数据结构 2 2 butex主要机制 2 2 1 butex wait 2 2 2 butex wake 我们知道在linux 下 锁和其他一些同步机制都会用到fu

  • Java多线程并行处理任务的实现

    Java多线程并行处理任务的实现 在实际项目开发的过程中 遇到过需要处理一个由多个子任务组成的任务的问题 顺序处理起来会造成响应时间超长 用户体验不好的问题 我想到一个解决方案 即使用多线程并行处理子任务 思路就是使用ThreadPoolE

  • 条件变量(condition variable)详解

    原理 假设我们需要解决这样一个问题 一个列表记录需要处理的任务 一个线程往此列表添加任务 一个线程processTask处理此列表中的任务 这个问题的一个关键点在于processTask怎么判断任务列表不为空 一般有两种方法 一 proce

  • 并发编程4 - 线程状态、死锁及ReentrantLock

    文章目录 一 再述线程状态转换 二 多把锁与线程活跃性问题 1 多把锁 2 活跃性 三 ReEntrantLock 1 基本用法 2 可重入 3 可打断 4 锁超时 5 公平锁 6 条件变量 一 再述线程状态转换 情况1 New RUNNA

  • Java 多线程模式 —— Guarded Suspension 模式

    Part1Guarded Suspension 模式的介绍 我们只从字面上看 Guarded Suspension 是受保护暂停的意思 1Guarded Suspension 模式 在实际的并发编程中 Guarded Suspension

  • MFC多线程编程之一——问题提出

    原文地址 http www vckbase com document viewdoc id 1704 一 问题的提出 编写一个耗时的单线程程序 新建一个基于对话框的应用程序SingleThread 在主对话框IDD SINGLETHREAD

  • [QT编程系列-25]：多线程机制 - QThread和MoveToThread简介

    目录 第1章 简介 1 1 多线程的目的 1 2 QThread多线程使用方法 1 3 QT支持多线的步骤 第2章 QThread 2 1 概述 2 2 moveToThread 第1章 简介 1 1 多线程的目的 QThread类提供了一

  • JAVA使用线程池查询大批量数据

    前言 在开发过程中可能会碰到某些独特的业务 比如查询全部表数据 数据量过多会导致查询变得十分缓慢 虽然在大多数情况下并不需要查询所有的数据 而是通过分页或缓存的形式去减少或者避免这个问题 但是仍然存在需要这样的场景 比如需要导出所有的数据到

  • 多线程系列之——事件内核对象

    所有内核对象里面事件内核对象是最简单的一个 它包括一个使用计数 还有两个布尔值 一个布尔值用来表示事件是手动重置事件还是自动重置事件 另一个布尔值表示当前是否处于触发状态 当一个手动重置事件被触发的时候 所有等待该事件的线程都能变成调度状态

  • Jmeter动态吞吐量实现

    在容量测试时 控量 是非常重要的 JMeter 是根据线程数大小来控制压力强弱的 但我们制定的压测目标中的指标往往是吞吐量 QPS TPS 这就给测试人员带来了不便之处 必须一边调整线程数 一边观察 QPS TPS 达到什么量级了 为了解决

  • JAVA实现简易HTTP服务器

    说实话 之前完全没有想过 我还能写出服务器 感觉服务器这么高端的东西 能会用就不错了 还能写 不吐槽了 开始了 这次的作业是搭建一个服务器 要能接收请求 并给浏览器返回正确响应 项目的下载地址 项目目标 实现一个简易的多线程服务器 可以处理

  • JAVA并发：线程安全与Synchorinzed

    1 什么是线程安全问题 线程的合理使用能够提升程序的处理性能 主要有两个方面 第一个是能够利用多核 cpu 以及超线程技术来实现线程的并行执行 第二个是线程的异步化执行相比于同步执行来说 异步执行能够很好的优化程序的处理性能提升并发吞吐量

  • 由一个多线程共享Integer类变量问题引起的。。。

    假设并发环境下 业务代码中存在一些统计操作 为了保证线程安全 开发人员往往会对计数值进行加锁 synchronized 值得注意的是 直接对Integer类型进行加锁 似乎并不会达到预期效果 比如下面这段代码 Integer num new

  • VS2008编译的程序在某些机器上运行提示“由于应用程序配置不正确，应用程序未能启动”的问题...

    VC9编译的程序在没有装过VC9 确切的说是 Net Framework3 5 的机器上运行时 如果提示 由于应用程序配置不正确 应用程序未能启动 重新安装应用程序可能会纠正这个问题 这个错误 那么就说明该程序动态链接了VC9的运行时库 如

  • 线程安全的集合类

    Java中提供了许多集合类 其中有的是线程安全的 有的是线程不安全的 线程安全的集合类有 1 Vector Vector类实现了一个 动态数组 与ArrayList相似 但Vector是同步访问的 2 Stack Stack是Vector的

随机推荐

  • 傅里叶分析之掐死教程

    作者 韩昊 知乎 Heinrich 微博 花生油工人 知乎专栏 与时间无关的故事 谨以此文献给大连海事大学的吴楠老师 柳晓鸣老师 王新年老师以及张晶泊老师 转载的同学请保留上面这句话 谢谢 如果还能保留文章来源就更感激不尽了 更新于 201

  • python创建虚拟环境报错_centos8使用python3自带的venv创建虚拟环境报错问题

    一 背景 damon localhost python3 m venv pdf env Error Command home damon pdf env bin python3 Im ensurepip upgrade default pi

  • IPsec协议过程

    版权声明 如有需要 可供转载 但请注明出处 https blog csdn net City of skey article details 86618784 目录 1 ipsec协议简介 2 IPSec工作模式 2 1 传输模式 2 2

  • 三星S5P6818之UBOOT网络配置

    三星S5P6818之UBOOT网络配置 使用友善提供的固件烧写到SD卡发现UBOOT并不能联网 于是研究了UBOOT源码 并调通了网络 以下步骤亲测可用 前言 这个适合友善nanopi3系列的开发板 M3 Fire3 T3等 或者其他使用

  • Python不平衡数据处理库imblearn安装和使用

    一般直接pip安装即可 安装不成功可能是因为 没有安装imblearn需要的Python模块 对应安装即可 pip install U imbalanced learn imblearn中的过采样方法 Over sampling metho

  • VMware 安装、移除Ubuntu系统

    目录 前言 安装虚拟机 1 新建虚拟机 2 进入向导 3 选择系统镜像 4 添加系统设置 用户名主机名密码 lt 实际没啥用 在系统安装过程中才设置的 gt 5 设置虚拟机名称 存放位置 6 磁盘容量 7 设置虚拟机硬件配置 8 自定义硬件

  • vue框架

    一 vue是什么 官方解释 vue是一套用于构建用户界面的渐进式框架 vue是一个js框架 提供了一套开发规则 按照这个开发规则可提高开发效率 补充 渐进式意思是 vue js本身功能局限 一旦配合其他的工具可以增强其能力 vue rout

  • Linux离线安装NTP服务，无外网环境下配置本地时间同步

    1 常用命令 rpm qa grep ntp 查询已安装的ntp版本信息等 rpm e nodeps ntp 4 2 6p5 29 el7 centos 2 x86 64 卸载 systemctl status ntpd 查询ntp服务状态

  • es打分机制

    基于Lucene的倒排索引算法

  • 【python数据挖掘课程】二十.KNN最近邻分类算法分析详解及平衡秤TXT数据集读取

    这是 Python数据挖掘课程 系列文章 也是我这学期上课的部分内容及书籍的一个案例 本文主要讲述KNN最近邻分类算法 简单实现分析平衡秤数据集 希望这篇文章对大家有所帮助 同时提供些思路 内容包括 1 KNN算法基础原理知识 2 最近邻分

  • 如何手动运行一个容器【一】

    作者 行云创新 周朋 每个刚涉足容器的人都会对容器的实现有所困惑 容器是如何实现的 是如何复用宿主机的资源 并且实现资源隔离的 下面会用shell创建一个容器 为大家展示一个容器的创建过程 1 创建镜像 我们一般用 docker pull

  • 宏定义的#和##

    宏定义中一个 表示右侧的符号转化为字符串 比如 define STR x x QString s STR 3 编译ok s值为 3 之前在看QT源码时 发现了下面的宏定义 define QLOCATION 0 FILE QT STRINGI

  • Typora + Gitee 配置图床_图片自动上传教程

    一 创建 Gitee 仓库 进入 Gitee 官网 注册一个属于自己的账号 点击创建仓库并且设置为开源 一定要是开源的public 只有这样你的图片才能被别人访问到 二 设置私人令牌 进入个人设置 gt 选择私人令牌进行创建 gt 设置自己

  • 华为od机考真题-HJ6-质数因子（简单）

    while 1 try num int input c 2 while c lt num 0 5 if num c 0 print c end

  • C++ Primer 学习笔记十五 —— 面向对象编程

    记录笔记原则 1 用简单易懂的语言叙述自己的理解 避免照搬原文 2 用实例说明 避免空洞 3 多做总结和横向对比 避免片面 面向对象三个基本概念 抽象 继承 动态绑定 继承使我们简化了类的定义 动态绑定使我们简化了接口的实现 使得所有继承层

  • 探究java IO之AutoCloseable,Closeable和Flushable接口

    http blog csdn net caiwenfeng for 23 article details 41862225 有3个接口对于流类相当重要 其中两个接口是Closeable和Flushable 它们是在java io包中定义的

  • BQ40Z50/BQ4050/BQ40Z80 等 BQ40xxx 系列电量计外围电路设计指导

    TI 电量计在消费和工业市场电池产品广泛应用 本文围绕电量计的功能逐一介绍电量计供电和 采样 对外交互 电池保护 电池均衡等外围电路设计 以帮助大家优化电量计电路设计 提高 开发效率 FAE 壹伍柒 陆陆贰陆 柒捌贰伍 1 电量计外围电路框

  • GPIO 8种工作模式

    GPIO 是什么 GPIO全称General Purpose Input Output 即通用输入 输出 其实GPIO的本质就是芯片的一个引脚 通常在ARM中所有的I O都是通用的 不过由于每个开发板上都会设计不同的外围电路 这就造成GPI

  • QT——操作数据库03

    目录标题 一 安装数据库 二 连接数据库 一 在项目的pro文件中增加一行代码 二 连接sqlite 三 封装连接数据库操作 三 增删查改例子 一 安装数据库 一般使用mysql或者sqlite mysql安装教程 sqlite安装教程 1

  • 多线程顺序打印的5种解法

    多线程同步的方式有许多 有传统的synchronized锁 还可以使用lock锁 下面列举多线程顺序打印的5种解法 算作对线程同步的一个总结 文章目录 经典面试题 多种解法 使用 Lock 使用 wait notify 使用 Lock Co

热门标签