【多线程】面试高频考点!JUC常见类的详细总结,建议收藏!

💐个人主页:初晴~

📚相关专栏:多线程 / javaEE初阶


        JUC是“Java Util Concurrency”的缩写,指的是Java并发工具包,它位于java.util.concurrent包及其子包中。JUC包提供了大量用于构建并发应用程序的工具和类,这些工具和类使得开发者能够更容易地编写多线程和并发程序。接下来就让我们深入研究一下JUC的一些常用类吧

目录

一、Callable接口

二、ReentrantLock

三、同步器

1、信号量 Semaphore

2、CountDownLatch

四、并发集合

1、CopyOnWrite 集合类

2、ConcurrentHashMap

总结


一、Callable接口

我们还记得Runnable接口是用来描述一个任务的,Callable接口也是类似的,不同的是,Callable允许任务在执行结束后返回一个结果,并且可以抛出异常。相当于把线程封装了一个返回值,通过这种方式,可以灵活地处理异步任务,并获得它们的执行结果。

Callable<V>接口是一个泛型接口,其中V代表任务执行后返回的结果类型。Callable接口只有一个抽象方法call(),这个方法返回一个V类型的值,并且可以抛出异常。

public interface Callable<V> {V call() throws Exception;
}

Callable接口与Runnable接口的区别

  • 有返回值Callable接口的任务可以返回一个结果,而Runnable接口的任务没有返回值。
  • 可以抛出异常Callable接口的call()方法可以声明抛出异常,而Runnable接口的run()方法不可以抛出检查异常。
  • FutureTaskCallable任务通常会被包装成FutureTask对象,以便于获取任务的执行结果。Runnable任务则不需要这样的包装,可以直接提交给Executor执行。

为了方便理解,让我们看一下下面这个情景:

创建一个线程,让这个线程计算1+2+3+...+1000

如果是采用之前Runnable的方式的话,为了得到执行结果,我们需要定义一个成员变量,来负责存储数据:

public class Main {private static int result;public static void main(String[] args) throws InterruptedException {Thread t=new Thread(()->{for (int i = 0; i < 1000; i++) {result+=i;}});t.start();t.join();System.out.println(result);}
}

这样程序就会引入了新的依赖,主线程和 t 线程与成员变量之间的耦合度就会比较高,不利于后期代码维护。这时使用Callable就能很好地解决这一问题:

public class Main {public static void main(String[] args) throws ExecutionException, InterruptedException {Callable<Integer> callable=new Callable<Integer>() {@Overridepublic Integer call() throws Exception {int result=0;for (int i = 0; i < 1000; i++) {result+=i;}return result;}};FutureTask<Integer> futureTask=new FutureTask<>(callable);Thread t=new Thread(futureTask);t.start();System.out.println(futureTask.get());}
}

在上述代码中,我们使用FutureTask来包装一个Callable任务,并在线程 t 中执行它。通过调用get()方法,我们可以在主线程中等待任务完成并获取其结果。

注意:

futureTask 的 get() 方法具有阻塞功能,当 t 线程未执行完时,会进入阻塞等待,直到 t 线程执行完毕后才会返回结果。可以这么理解,get() 就相当于 “带有返回结果” 的 join()

Callable接口的任务也可以直接通过ExecutorService提交执行,并通过Future对象获取结果:

public class CallableExample {public static void main(String[] args) {// 创建一个Callable接口的实现类Callable<Integer> callableTask = () -> {int result = 0;for (int i = 0; i < 1000; i++) {result += i;}System.out.println("计算结束");return result;};// 创建一个ExecutorServiceExecutorService executor = Executors.newSingleThreadExecutor();// 提交Callable任务并获取Future对象Future<Integer> future = executor.submit(callableTask);// 获取任务的结果try {Integer result = future.get(); // get()方法会阻塞,直到任务完成System.out.println("计算结果: " + result);} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}// 关闭ExecutorServiceexecutor.shutdown();}
}

二、ReentrantLock

可重⼊互斥锁. 和 synchronized 定位类似, 都是⽤来实现互斥效果, 保证线程安全。

特点:

  1. 可中断的等待:当线程等待锁时,可以响应中断请求。
  2. 公平与非公平锁:公平锁按照请求锁的顺序来获取锁,而非公平锁可能会让后来的请求抢占先前请求的锁。
  3. 条件变量ReentrantLock提供了Condition对象作为条件变量,用于更精细的线程间同步。
  4. 可重入性:线程可以多次获取同一个锁而不会造成死锁。
  5. 显式的锁释放:必须显式地调用unlock()方法来释放锁,否则可能会导致资源泄露。

基本使用:

1、创建实例

public class LockExample {private final ReentrantLock lock = new ReentrantLock();
}

这里创建了一个默认的非公平锁。如果你想创建一个公平锁,可以传递一个参数给构造函数:

private final ReentrantLock lock = new ReentrantLock(true); // 公平锁

2、锁的获取与释放

lock.lock(); // 获取锁
try {// 执行临界区代码
} finally {lock.unlock(); // 释放锁
}

注意:

finally块中释放锁是非常重要的,这样可以确保即使在发生异常的情况下锁也能被正确释放。

3、tryLock机制

ReentrantLock提供了一个tryLock方法,它试图获取锁而不阻塞。如果锁可用,则立即获取锁并返回true;如果锁不可用,则不获取锁并返回false,通过返回值来反馈加锁是否成功,可以由程序员自行决定后续操作,而不是一味地“死等”,提供了更高的可操作空间。

if (lock.tryLock()) {try {// 执行临界区代码} finally {lock.unlock();}
} else {// 锁不可用时的操作
}

4、唤醒机制

ReentrantLock通过newCondition()方法创建Condition对象,用于实现更复杂的同步控制。Condition 对象提供了比 Object 类的 wait()notify() 方法更高级的线程同步功能,包括更精确的线程唤醒控制和多个等待集的支持。

基本方法

  1. await():使当前线程进入等待状态,并释放锁。当其他线程调用相应的 signal() 或 signalAll() 方法唤醒该线程时,它会重新竞争获取锁并继续执行。
  2. signal():唤醒在当前条件队列上等待的一个线程。被唤醒的线程会重新竞争获取锁,并继续执行。
  3. signalAll():唤醒在当前条件队列上等待的所有线程。被唤醒的线程会重新竞争获取锁,并继续执行。
private final Condition condition = lock.newCondition();// 通知其他等待线程
lock.lock();
try {condition.signal();
} finally {lock.unlock();
}// 等待通知
lock.lock();
try {condition.await();
} catch (InterruptedException e) {Thread.currentThread().interrupt();
} finally {lock.unlock();
}

ReentrantLocksynchronized的区别:

  1. 使用方式:

    • synchronized 是 Java 语言的关键字,是 JVM 内部实现的(⼤概率是基于 C++ 实现),它直接集成在 Java 语言的语法结构中,可以用作修饰符来声明方法或代码块。
    • ReentrantLock 是 java.util.concurrent.locks 包中的一个类,在 JVM 外实现的(基于 Java 实现),它需要显式地创建实例,并调用 lock() 和 unlock() 方法来获取和释放锁。
  2. 显式/隐式锁释放

    • synchronized 会在线程退出作用域时自动释放锁,无需显式地调用 unlock() 方法。
    • ReentrantLock 必须显式地调用 unlock() 方法来释放锁,如果没有释放锁就会导致资源泄露。
  3. 可中断等待

    • synchronized 不支持中断等待,如果一个线程因为等待锁而被阻塞,则无法响应中断请求。
    • ReentrantLock 支持中断等待,可以通过 tryLock 方法尝试获取锁,如果锁不可用则可以选择性地返回,也可以通过 lockInterruptibly() 方法等待锁,此时可以响应中断请求。
  4. 公平锁/非公平锁

    • synchronized 只能是非公平锁。
    • ReentrantLock 支持选择公平锁或非公平锁,可以通过构造⽅法传⼊⼀个 true 开启公平锁模式。公平锁保证了按照请求锁的顺序来获取锁,而非公平锁可能会让后来的请求抢占先前请求的锁。
  5. 唤醒机制

    • synchronized 是通过 Object 类的 wait() 和 notify() 方法来实现等待-唤醒的功能,但每次只能随机唤醒一个等待的线程。
    • ReentrantLock 通过 Condition 类实现等待-唤醒,可以更精确控制唤醒某个指定
      的线程
  6. 可重入性

    • synchronized 和 ReentrantLock 都支持可重入性,即同一线程可以多次获取同一个锁而不会造成死锁。
  7. 锁的粒度控制

    • synchronized 锁定的是整个方法或代码块,没有提供更细粒度的锁定控制。
    • ReentrantLock 可以通过不同的锁对象来实现更细粒度的控制。
  8. 性能考虑

    • 在某些情况下,synchronized 可能由于 JVM 的优化而比 ReentrantLock 更快。
    • ReentrantLock 因为其灵活性和高级特性,在复杂情况下可能比 synchronized 更适合。
如何选择使⽤哪个锁?
  • 锁竞争不激烈的时候, 使⽤ synchronized, 效率更⾼, ⾃动释放更⽅便.
  • 锁竞争激烈的时候, 使⽤ ReentrantLock, 搭配 trylock 更灵活控制加锁的⾏为, ⽽不是死等.
  • 如果需要使⽤公平锁, 使⽤ ReentrantLock

基于 ReentrantLock 实现生产者消费者模式

public class ProducerConsumerExample {private LinkedList<Integer> queue = new LinkedList<>();private int capacity = 10;private final ReentrantLock lock = new ReentrantLock();private final Condition notFull = lock.newCondition();private final Condition notEmpty = lock.newCondition();public void put(int value) throws InterruptedException {lock.lock();try {// 如果队列已满,则等待while (queue.size() == capacity) {notFull.await();}// 生产数据queue.addLast(value);System.out.println("Produced: " + value);// 唤醒消费者notEmpty.signal();} finally {lock.unlock();}}public int take() throws InterruptedException {lock.lock();try {// 如果队列为空,则等待while (queue.isEmpty()) {notEmpty.await();}// 消费数据int value = queue.removeFirst();System.out.println("Consumed: " + value);// 唤醒生产者notFull.signal();return value;} finally {lock.unlock();}}
}

在上述代码中,我们使用 ReentrantLock 来保护对队列的访问,并使用两个 Condition 对象 notFullnotEmpty 来分别控制队列满和队列空的情况。生产者在队列满时等待,消费者在队列空时等待,只有当条件满足时才会唤醒相应的线程继续执行


三、同步器

1、信号量 Semaphore

信号量通常用于控制对共享资源的访问次数或者限制系统中的某个操作可以同时进行的最大次数,用来表示“可用资源的个数”,本质上就是一个计数器。Semaphore 提供了许可(permit)的概念,允许一定数量的线程获取许可,超过这个数量的线程将被阻塞,直到有许可被释放。

Semaphore的主要方法:

  • acquire():获取一个许可。如果没有可用的许可,则当前线程会被阻塞,直到有许可可用。
  • release():释放一个许可,将其返回给信号量。
  • availablePermits():返回当前可用的许可数量。
  • drainPermits():从信号量中获取所有可用的许可,并将它们释放回信号量。
  • reducePermits(int reduction):减少信号量的许可数量。
  • tryAcquire():尝试获取一个许可。如果没有可用的许可,则立即返回 false
  • tryAcquire(long timeout, TimeUnit unit):尝试获取一个许可,但只等待指定的时间。如果在等待时间内没有可用的许可,则立即返回 false

其中获取资源被称之为 P 操作,会让·“计数器”-1;释放资源则被称之为 V 操作,会让“计数器”+1

创建实例:

public class SemaphoreExample {public static void main(String[] args) {Semaphore semaphore = new Semaphore(5); // 初始许可数量为5}
}

当许可数量为1时,甚至可以用它来实现 “锁” 的功能,因为此时当线程 t1 获取当资源时,此时剩余资源就会为零,当其它线程申请资源时就会进入阻塞等待,等到 t1 执行完毕释放资源时,其它资源才有机会竞争获取资源,从而达到了类似于加锁的操作:

public class Main {private static int count=0;public static void main(String[] args) throws InterruptedException {//创建 Semaphore 实例Semaphore semaphore=new Semaphore(1);Thread t1=new Thread(()->{for(int i=0;i<5000;i++){try {//申请资源semaphore.acquire();count++;//释放资源semaphore.release();} catch (InterruptedException e) {throw new RuntimeException(e);}}});Thread t2=new Thread(()->{for(int i=0;i<5000;i++){try {//申请资源semaphore.acquire();count++;//释放资源semaphore.release();} catch (InterruptedException e) {throw new RuntimeException(e);}}});t1.start();t2.start();t1.join();t2.join();System.out.println(count);}
}

相比于传统的互斥锁,Semaphore 可以自由地设定资源数量,更加具有灵活性,可以很容易地应用于多种并发场景中,还是十分有用的。

2、CountDownLatch

实际开发中,很多时候需要把一个大任务,拆分成多个小任务,一般会采用多线程/线程池来执行,但在多个线程的并发执行下,该如何判断总任务是否完成了呢?这时候就需要用到 CountDownLatch 了。

就好比跑步比赛时,需要每位选手都就位后,发令枪才会响起,所有选手都通过终点,才能公布成绩。CountDownLatch 提供了一个用于协调多个线程的计数器,通常用于等待一组操作完成之后再继续执行其他操作。它的主要用途是在一个或多个线程完成一系列初始化工作之前,阻止其他线程的进展。

主要方法:

  • await():阻塞当前线程,直到计数器的值变为零或线程被中断。
  • await(long timeout, TimeUnit unit):阻塞当前线程,直到计数器的值变为零、线程被中断或等待时间到达指定的超时时间。
  • countDown():递减计数器的值。
  • getCount():返回当前的计数器值。

实例创建:

public class CountDownLatchExample {public static void main(String[] args) {CountDownLatch latch = new CountDownLatch(3); // 初始计数值为3}
}

使用原理:
CountDownLatch 维护了一个内部计数器,当计数器减为时,在 await() 方法上等待的线程将被释放。计数器的值由创建 CountDownLatch 实例时提供的构造函数参数确定。线程可以通过调用 countDown() 方法来递减计数器的值。

简单应用:

public class Main {public static void main(String[] args) throws InterruptedException {ExecutorService executorService= Executors.newFixedThreadPool(4);//构造方法里的数字,就是拆分出来任务的个数CountDownLatch countDownLatch=new CountDownLatch(20);for(int i=1;i<=20;i++){int id=i;executorService.submit(()->{System.out.println("第"+id+"个任务开始执行");try {Thread.sleep(3000);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("第"+id+"个任务执行完毕");//代表一个任务执行完成countDownLatch.countDown();});}//当 CountDownLatch 收到 20 个完成时,就代表所有任务都完成了//await -> all waitcountDownLatch.await();System.out.println("所以任务执行完毕!");}
}

应用场景:

  1. 等待一组操作完成:当一个线程需要等待一组操作全部完成之后再继续执行时,可以使用 CountDownLatch
  2. 多线程初始化:在多线程环境中,如果有多个线程负责初始化不同的部分,主初始化线程可以使用 CountDownLatch 来等待所有初始化线程完成它们的工作。
  3. 定时任务:如果需要等待一段时间后执行某个任务,可以使用带有超时时间的 await 方法。

注意:

  • CountDownLatch 的计数器是不可重置的,一旦计数器归零就不能再增加。如果你需要重复使用类似的功能,可以考虑使用 CyclicBarrier
  • 当使用 await 方法时,如果当前线程被中断,将会抛出 InterruptedException 并且中断状态会被设置。

四、并发集合

像我们之前介绍的一些集合类,比如ArrayList、Queue、HashMap等,⼤部分都不是线程安全的。
像Vector, Stack, HashTable, 是线程安全的,但并不建议直接去使用,因为加锁是需要一定的开销的,盲目加锁反而会影响程序效率。
那么该如何在多线程环境下安全地使用集合类呢?我们接着往下看:

1、CopyOnWrite 集合类

这个集合类并没有加锁,而是通过  “写实拷贝” 来实现线程安全,即在写入数据时复制一份当前的数据副本,然后在副本上进行修改,最后用新的副本替换旧的数据。这种方法可以避免在读取数据的同时进行写入操作时出现的数据不一致问题。

 此时别的线程执行读操作,仍然可以读取旧版本的内容,而写操作都是在新版本的内容上修改,避免了之前会读到修改了一半的数据的情况发生,也就避免了线程安全问题的产生。

基本使用:

public class CopyOnWriteArraySetExample {public static void main(String[] args) {CopyOnWriteArraySet<Integer> set = new CopyOnWriteArraySet<>();// 添加元素set.add(1);set.add(2);set.add(2); // 重复元素不会被添加// 输出元素for (Integer number : set) {System.out.println(number);}// 删除元素set.remove(2);// 检查是否包含某个元素boolean containsOne = set.contains(1);System.out.println("Contains One: " + containsOne);}
}
优点:
  1. 线程安全:所有的写入操作都是通过复制整个数组来实现的。
  2. 读取性能:读取操作不需要加锁,性能较好。

缺点:

  1. 内存消耗:每次写入操作都需要复制整个数组,这会导致额外的内存消耗。
  2. 写入性能:写入操作的性能较低,特别是在集合较大时,复制整个数组的成本较高。
  3. 不支持并发修改:虽然 CopyOnWrite 集合类支持在迭代过程中修改集合,但不能支持真正的并发修改,因为写入操作会阻塞读取操作。
适用场景:
  1. 读多写少:如果应用程序主要是读操作,偶尔有一些写操作,那么 CopyOnWrite 集合类非常适合,因为读操作不需要加锁。
  2. 集合大小较小:如果集合的大小不是特别大,那么 CopyOnWrite 集合类的性能影响是可以接受的。

2、ConcurrentHashMap

虽然有线程安全的Hashtable或Collections.synchronizedMap(),但它们加锁的方式比较“粗暴”,运行效率往往不高。JUC中就提供了一个 ConcurrentHashMap 类,它在多线程环境下就有更高的性能,因为它采用了分段锁(segmentation)技术,而不是在整个映射上加锁。这意味着多个线程可以同时进行读取操作,甚至在某些条件下可以同时进行写入操作。

基本使用:

创建一个 ConcurrentHashMap 实例非常简单,可以直接使用默认构造器或者提供初始容量和负载因子。

public class ConcurrentHashMapExample {public static void main(String[] args) {// 创建一个默认容量和负载因子的ConcurrentHashMapConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();// 添加键值对map.put("one", 1);map.put("two", 2);// 获取值Integer value = map.get("one");System.out.println("Value of 'one': " + value);// 删除键值对map.remove("two");}
}

优势

(1)优化了锁的粒度

像Hashtable 的加锁,就是直接在 put、get 等方法上套上 synchronized,不管当前操作是否会引起线程安全问题都会一味加锁,任何一个针对这个哈希表的操作都会引起锁竞争,效率就比较低下了。

而ConcurrentHashMap则是给每个Hash表中的“链表”都进行加锁,形成一个“锁桶”,这样只有在同时发生两次 “哈希冲突” ,且冲突的是同一个链表上的元素时才会加锁,而我们知道,一个正常的哈希表发生 “哈希冲突” 的概率是非常低的,因此会触发上述锁竞争的概率是非常非常低的,并且一个“链表”加锁之后,也完全不会影响对其它“链表”结点的操作,就可以大幅减少加锁次数,提高效率。

(2)引入了CAS原子操作

 ConcurrentHashMap提供了大量原子操作方法,如 computeIfAbsentcomputeIfPresentmerge 等,这些方法可以在并发环境下安全地执行计算并更新值。

// 使用computeIfAbsent方法,如果不存在键对应的值,则计算并放入
Integer newValue = map.computeIfAbsent("three", key -> 3);
System.out.println("Value of 'three': " + newValue);

这样对于一些可能会引发线程安全问题的修改操作直接借助CAS完成,并不需要加锁,这使得只有在一些需要全局同步的操作中,例如扩容和转换链表为红黑树,才需要使用 synchronized 加锁,也就进一步减少了加锁的操作。关于CAS操作的详细叙述,可以看看博主的 CAS的原理及应用 一文。

(3)volatile 字段

为了确保线程间的可见性, ConcurrentHashMap 使用了 volatile 字段来修饰关键的共享变量。volatile 变量的值会被强制立即写入主内存,当线程读取 volatile 变量时,总是能读取到最新的值。

(4)优化了哈希的扩容机制

传统的 Hash表扩容,需要创建一个新的 Hash表,将原来表中所有元素搬运过去,这些操作很可能会在一次put中就完成了,就会导致这次的 put 操作开销非常大,在用户的视角下就会出现“卡”了一下的感觉,体验是非常不好的。

ConcurrentHashMap则实现了“化整为零”,不会在一次操作中进行所有数据的搬运,而是一次只搬一部分,之后每次操作都会触发一部分 key 的搬运,最终吧所有的key都搬运完

当新旧表同时存在时:

  • 插入操作,就会直接插入到新的空间中
  • 查询/修改/删除,会同时访问新的空间与旧的空间

至于线程池、原子类等JUC常见类在博主之前的文章 CAS的原理及应用、深入剖析线程池的应用中有过详细的研究,这里就不做赘述了。

总结

通过使用java.util.concurrent包中的工具,我们可以灵活地处理异步任务,并获得它们的执行结果。无论是使用ExecutorService来管理线程池中的任务,还是使用FutureTask来包装Callable任务,抑或是使用ReentrantLock来在锁竞争激烈时灵活控制加锁操作等,这些工具都极大地简化了并发编程的工作量,并提高了程序在多线程环境下的性能和可靠性。


那么本篇文章就到此为止了,如果觉得这篇文章对你有帮助的话,可以点一下关注和点赞来支持作者哦。作者还是一个萌新,如果有什么讲的不对的地方欢迎在评论区指出,希望能够和你们一起进步✊

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

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

相关文章

深入解析Python 中的 sortedcontainers 库:高效的排序数据结构

在日常的 Python 编程中&#xff0c;列表&#xff08;list&#xff09;、集合&#xff08;set&#xff09;和字典&#xff08;dict&#xff09;是常用的数据结构。然而&#xff0c;在某些特定的场景下&#xff0c;我们需要对数据进行排序&#xff0c;并且希望在插入、删除或访问…

计算机网络32——Linux-文件io-2文件系统

1、阻塞和非阻塞 想要将文件以非阻塞方式打开&#xff0c;有两种方式 &#xff08;1&#xff09;需要将文件关闭&#xff0c;再用非阻塞方式打开 &#xff08;2&#xff09;fctnl函数&#xff0c;先获取旧属性&#xff0c;再添加一个新属性 阻塞函数 阻塞函数一直在等待输入…

从更底层的角度理解网站的访问过程

文章目录 1.示例&#xff0c;访问www.baidu.com是如何返回数据的1.输入www.baidu.com回车2.检查本机的C:\Windows\System32\drivers\etc\hosts配置文件夹下有没有这个域名对应的映射&#xff1a; 1.示例&#xff0c;访问www.baidu.com是如何返回数据的 1.输入www.baidu.com回车…

开源数据集网站合集

一.Google数据集 链接&#xff1a;https://datasetsearch.research.google.com/ 二.Huggingface数据集 链接1&#xff1a;GitHub - huggingface/datasets: &#x1f917; The largest hub of ready-to-use datasets for ML models with fast, easy-to-use and efficient dat…

深入解析:HTTP 和 HTTPS 的区别

网络安全问题正变得日益重要&#xff0c;而 HTTP 与 HTTPS 对用户数据的保护十分关键。本文将深入探讨这两种协议的特点、工作原理&#xff0c;以及保证数据安全的 HTTPS 为何变得至关重要。 认识 HTTP 与 HTTPS HTTP 的工作原理 HTTP&#xff0c;全称超文本传输协议&#xf…

2-103 基于matlab的光电信号下血氧饱和度计算

基于matlab的光电信号下血氧饱和度计算&#xff0c;光转换成电信号时&#xff0c;由于动脉对光的吸收有变化而其他组织对光的吸收基本不变&#xff0c;得到的信号就可以分为直流DC信号和交流AC信号。提取AC信号&#xff0c;就能反应出血液流动的特点。这种技术叫做光电容积脉搏…

如何查看线程

1、首先找到我们的电脑安装jdk的位置&#xff0c;这里给大家展示一下博主本人的电脑jdk路径下的jconsole位置。 2、 ok&#xff0c;那么找到这个jconsole程序我们直接双击打开就可以查看我们电脑的本地进程&#xff1a; jconsole 这里能够罗列出你系统上的 java 进程&#xff0…

[Linux] Linux操作系统 进程的状态

标题&#xff1a;[Linux] Linux操作系统 进程的状态 个人主页&#xff1a;水墨不写bug &#xff08;图片来源于网络&#xff09; 目录 一、前置概念的理解 1.并行和并发 2.时间片 3.进程间具有独立性 4.等待的本质 正文开始&#xff1a; 在校的时候&#xff0c;你一定学过《…

java 框架组件

Java 框架是一系列预先编写好的、可复用的软件组件&#xff0c;它们旨在帮助开发者快速构建高质量的应用程序。Java 社区拥有众多优秀的框架&#xff0c;涵盖了从 Web 开发到大数据处理的各个领域。下面是一些流行的 Java 框架及其主要用途&#xff1a; Spring框架&#xff1a;…

新手教学系列——非正常关机导致MySQL权限表(db)损坏及修复详解

在使用MySQL的过程中,我们常常会遇到一些问题,尤其是当服务器或主机非正常关机或重启时,MySQL的某些表,特别是权限表(如 mysql.db 表),可能会损坏,导致数据库无法启动或访问。这种情况对生产环境的数据库系统来说是相当严重的,因此掌握修复方法非常重要。 本篇文章将…

【STM32系统】基于STM32设计的DAC输出电压与ADC检测电压系统(简易万用表,检测电压电流)——文末工程资料下载

基于STM32设计的DAC输出电压与ADC检测电压系统(简易万用表,检测电压电流) 演示视频: 基于STM32设计的DAC输出电压与ADC检测电压系统(简易万用表,检测电压电流) 前言:本项目实现对STM32的DAC和ADC的程序设计与硬件电路连接实现STM32内部DAC输出电压,并且ADC可以采集电压…

下载2001年版英特尔开发手册与使用网易有道词典

本专栏的任务&#xff0c;是翻译2001年版英特尔开发手册的第3卷。上一节&#xff0c;我写了开篇语。本节&#xff0c;我是打算将这个版本的英特尔开发手册的下载方式公布出来。使得大家可以将其下载回去。如果你看的块的话&#xff0c;你可以自行翻译与学习。 一. 下载英特…

macOS设置 Redis自启动

macOS自定义开机启动程序 1、打开 自动操作app里面的应用程序 过程资料 1、https://juejin.cn/post/7123098435254747149 2、https://blog.twofei.com/889/ 2、编写脚本&#xff0c;可以点击右上角运行测试&#xff0c;保存为 app https://juejin.cn/post/7123098435254747149…

招联金融2025校招内推喇

【投递方式】 直接扫下方二维码&#xff0c;或点击内推官网https://wecruit.hotjob.cn/SU61025e262f9d247b98e0a2c2/mc/position/campus&#xff0c;使用内推码 igcefb 投递&#xff09; 【招聘岗位】 深圳&#xff0c;武汉&#xff1a; 后台开发 前端开发 数据开发 数据运营…

在MySQL中,要查询所有用户及其权限,您可以使用以下命令:

文章目录 1、查询所有用户1.1、登录数据库1.2、select user,host from mysql.user; 2、查看用户的权限 1、查询所有用户 1.1、登录数据库 [rootlocalhost ~]# docker exec -it spzx-mysql /bin/bash rootab66508d9441:/# mysql -uroot -p123456 mysql: [Warning] Using a pas…

什么是电商云手机?可以用来干什么?

随着电商行业的迅速发展&#xff0c;云手机作为一种创新工具正逐渐进入出海电商领域。专为外贸市场量身定制的出海电商云手机&#xff0c;已经成为许多外贸企业和出海电商卖家的必备。本文将详细介绍电商云手机是什么以及可以用来做什么。 与国内云手机偏向于游戏场景不同&…

Elasticsearch导出导入数据

1.概念回顾 2.基础操作 展示详细信息 GET&#xff1a;http://127.0.0.1:9200/_cat/indices?v Java代码将文件导入到ES package com.Graph.medicalgraph;import org.apache.http.HttpHost; import org.elasticsearch.action.bulk.BulkRequest; import org.elasticsearch.act…

Linux 下安装mysql

1.检查之前是否安装过mysql rpm -qa | grep mysql 如果之前安装过&#xff0c;删除之前的安装包 rpm -e 安装包 如果没有&#xff0c;进行后续安装 2. 下载 MySQL :: Download MySQL Community Server (Archived Versions)https://downloads.mysql.com/archives/community/ 3…

FPGA IP 和 开源 HDL 一般去哪找?

在FPGA开发的世界中&#xff0c;IP核和HDL模块是构建复杂数字系统的基石。它们如同乐高积木&#xff0c;让开发者能够快速搭建和重用经过验证的电路功能。但你是否曾感到迷茫&#xff0c;不知道从哪里寻找这些宝贵的资源&#xff1f;本文将为你揭开寻找FPGA IP核和HDL模块资源的…

Kafka 下载安装及使用总结

1. 下载安装 官网下载地址&#xff1a;Apache Kafka 下载对应的文件 上传到服务器上&#xff0c;解压 tar -xzf kafka_2.13-3.7.0.tgz目录结果如下 ├── bin │ └── windows ├── config │ └── kraft ├── libs ├── licenses └── site-docs官方文档…