您当前的位置:首页 > 电脑百科 > 程序开发 > 容器

这些Java并发容器,你都了解吗?

时间:2023-12-07 14:32:54  来源:微信公众号  作者:架构殿堂

前言

在多线程环境下,数据的并发访问和修改是无法避免的问题。

为了解决这个问题,JAVA 提供了一系列并发容器,这些容器在内部已经处理了并发问题,使得我们可以在多线程环境下安全地访问和修改数据。

 


 

并发容器

 

1.ConcurrentHashMap 并发版 HashMap

最常见的并发容器之一,可以用作并发场景下的缓存。底层依然是哈希表,但在 JAVA 8 中有了不小的改变,而 JAVA 7 和 JAVA 8 都是用的比较多的版本,因此经常会将这两个版本的实现方式做一些比较(比如面试中)。

一个比较大的差异就是,JAVA 7 中采用分段锁来减少锁的竞争,JAVA 8 中放弃了分段锁,采用 CAS(一种乐观锁),同时为了防止哈希冲突严重时退化成链表(冲突时会在该位置生成一个链表,哈希值相同的对象就链在一起),会在链表长度达到阈值(8)后转换成红黑树(比起链表,树的查询效率更稳定)。

 

示例
import java.util.concurrent.*;

public class ConcurrentHashMapExample {
  public static void mAIn(String[] args) {
      // Creating a ConcurrentHashMap
      ConcurrentHashMap<String, String> map = new ConcurrentHashMap<String, String>();

      // Adding elements to the ConcurrentHashMap
      map.put("Key1", "Value1");
      map.put("Key2", "Value2");
      map.put("Key3", "Value3");

      // Printing the ConcurrentHashMap
      System.out.println("ConcurrentHashMap: " + map);
  }
}

 

2.CopyOnWriteArrayList 并发版 ArrayList

并发版 ArrayList,底层结构也是数组,和 ArrayList 不同之处在于:当新增和删除元素时会创建一个新的数组,在新的数组中增加或者排除指定对象,最后用新增数组替换原来的数组。

CopyOnWriteArrayList 的主要特性是,每当列表修改时,例如添加或删除元素,它都会创建列表的一个新副本。原始列表和新副本都可以进行并发读取,这样就可以在不锁定整个列表的情况下进行并发读取。这种方法在读取操作远多于写入操作的场景中非常有用。

适用场景:由于读操作不加锁,写(增、删、改)操作加锁,因此适用于读多写少的场景。

局限:由于读的时候不会加锁(读的效率高,就和普通 ArrayList 一样),读取的当前副本,因此可能读取到脏数据。如果介意,建议不用。

看看源码感受下:

这些Java并发容器,你都了解吗?

 

示例
import java.util.concurrent.*;

public class CopyOnWriteArrayListExample {
  public static void main(String[] args) {
      // 创建一个 CopyOnWriteArrayList
      CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();

      // 向 CopyOnWriteArrayList 添加元素
      list.add("Element1");
      list.add("Element2");
      list.add("Element3");

      // 打印 CopyOnWriteArrayList
      System.out.println("CopyOnWriteArrayList: " + list);
  }
}

 

3.CopyOnWriteArraySet 并发 Set

基于 CopyOnWriteArrayList 实现(内含一个 CopyOnWriteArrayList 成员变量),也就是说底层是一个数组,意味着每次 add 都要遍历整个集合才能知道是否存在,不存在时需要插入(加锁)。

CopyOnWriteArraySet 的工作原理与 CopyOnWriteArrayList 类似。每当发生修改操作(如添加或删除元素)时,它都会创建集合的一个新副本。原始集合和新副本都可以进行并发读取,这样就可以在不锁定整个集合的情况下进行并发读取。这种方法在读取操作远多于写入操作的场景中非常有用。

适用场景:在 CopyOnWriteArrayList 适用场景下加一个,集合别太大(全部遍历伤不起)。

 

示例
import java.util.concurrent.*;

public class CopyOnWriteArraySetExample {
  public static void main(String[] args) {
      // 创建一个 CopyOnWriteArraySet
      CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet<String>();

      // 向 CopyOnWriteArraySet 添加元素
      set.add("Element1");
      set.add("Element2");
      set.add("Element3");

      // 打印 CopyOnWriteArraySet
      System.out.println("CopyOnWriteArraySet: " + set);
  }
}

 

4.ConcurrentLinkedQueue 并发队列 (基于链表)

基于链表实现的并发队列,使用乐观锁 (CAS) 保证线程安全。因为数据结构是链表,所以理论上是没有队列大小限制的,也就是说添加数据一定能成功。

ConcurrentLinkedQueue 是 Java 并发包的一部分,它是基于链接节点的无界线程安全队列。它按照 FIFO(先进先出)的原则对元素进行排序。

ConcurrentLinkedQueue 的主要优点是它允许完全并发的插入,并且使用了一种高效的“wait-free”算法。

 

示例
import java.util.concurrent.*;

public class ConcurrentLinkedQueueExample {
  public static void main(String[] args) {
      // 创建一个 ConcurrentLinkedQueue
      ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<String>();

      // 向 ConcurrentLinkedQueue 添加元素
      queue.add("Element1");
      queue.add("Element2");
      queue.add("Element3");

      // 打印 ConcurrentLinkedQueue
      System.out.println("ConcurrentLinkedQueue: " + queue);
  }
}

 

5.ConcurrentLinkedDeque 并发队列 (基于双向链表)

基于双向链表实现的并发队列,可以分别对头尾进行操作,因此除了先进先出 (FIFO),也可以先进后出(FILO),当然先进后出的话应该叫它栈了。

ConcurrentLinkedDeque 是 Java 并发包的一部分,它是一个基于链接节点的无界并发双端队列。在 ConcurrentLinkedDeque 中,添加、删除等操作可以在队列的两端进行,使其具有更高的并发性。

 

示例
import java.util.concurrent.*;

public class ConcurrentLinkedDequeExample {
  public static void main(String[] args) {
      // 创建一个 ConcurrentLinkedDeque
      ConcurrentLinkedDeque<String> deque = new ConcurrentLinkedDeque<String>();

      // 向 ConcurrentLinkedDeque 添加元素
      deque.add("Element1");
      deque.addFirst("Element2");
      deque.addLast("Element3");

      // 打印 ConcurrentLinkedDeque
      System.out.println("ConcurrentLinkedDeque: " + deque);
  }
}

 

6.ConcurrentSkipListMap 基于跳表的并发 Map

ConcurrentSkipListMap 是 Java 并发包的一部分,它是一个线程安全的排序映射表。它使用跳表的数据结构来保证元素的有序性和并发性。

跳表是一种可以进行二分查找的有序链表。ConcurrentSkipListMap 提供了预期的平均 log(n) 时间成本来执行 containsKeygetputremove 操作,并且它的并发性通常优于基于树的算法。

SkipList 即跳表,跳表是一种空间换时间的数据结构,通过冗余数据,将链表一层一层索引,达到类似二分查找的效果

这些Java并发容器,你都了解吗?

 

示例
import java.util.concurrent.*;

public class ConcurrentSkipListMapExample {
  public static void main(String[] args) {
      // 创建一个 ConcurrentSkipListMap
      ConcurrentSkipListMap<String, String> map = new ConcurrentSkipListMap<String, String>();

      // 向 ConcurrentSkipListMap 添加元素
      map.put("Key1", "Value1");
      map.put("Key2", "Value2");
      map.put("Key3", "Value3");

      // 打印 ConcurrentSkipListMap
      System.out.println("ConcurrentSkipListMap: " + map);
  }
}

 

7.ConcurrentSkipListSet 基于跳表的并发 Set

类似 HashSet 和 HashMap 的关系,ConcurrentSkipListSet 里面就是一个 ConcurrentSkipListMap,

ConcurrentSkipListSet 是 Java 并发包的一部分,它是一个线程安全的排序集合。它使用跳表的数据结构来保证元素的有序性和并发性。

跳表是一种可以进行二分查找的有序链表。ConcurrentSkipListSet 提供了预期的平均 log(n) 时间成本来执行 containsaddremove 操作,并且它的并发性通常优于基于树的算法。

 

示例
import java.util.concurrent.*;

public class ConcurrentSkipListSetExample {
  public static void main(String[] args) {
      // 创建一个 ConcurrentSkipListSet
      ConcurrentSkipListSet<String> set = new ConcurrentSkipListSet<String>();

      // 向 ConcurrentSkipListSet 添加元素
      set.add("Element1");
      set.add("Element2");
      set.add("Element3");

      // 打印 ConcurrentSkipListSet
      System.out.println("ConcurrentSkipListSet: " + set);
  }
}

 

8.ArrayBlockingQueue 阻塞队列 (基于数组)

ArrayBlockingQueue 是 Java 并发包的一部分,它是一个基于数组的有界阻塞队列。此队列按 FIFO(先进先出)原则对元素进行排序。

ArrayBlockingQueue 在尝试插入元素到已满队列或从空队列中移除元素时,会导致线程阻塞,直到有空间或元素可用。

基于数组实现的可阻塞队列,构造时必须制定数组大小,往里面放东西时如果数组满了便会阻塞直到有位置(也支持直接返回和超时等待),通过一个锁 ReentrantLock 保证线程安全。

这些Java并发容器,你都了解吗?

乍一看会有点疑惑,读和写都是同一个锁,那要是空的时候正好一个读线程来了不会一直阻塞吗?

答案就在 notEmpty、notFull 里,这两个出自 lock 的小东西让锁有了类似 synchronized + wait + notify 的功能。传送门 → 终于搞懂了 sleep/wait/notify/notifyAll

 

示例
import java.util.concurrent.*;

public class ArrayBlockingQueueExample {
  public static void main(String[] args) {
      // 创建一个 ArrayBlockingQueue
      ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<String>(3);

      // 向 ArrayBlockingQueue 添加元素
      try {
          queue.put("Element1");
          queue.put("Element2");
          queue.put("Element3");
      } catch (InterruptedException e) {
          e.printStackTrace();
      }

      // 打印 ArrayBlockingQueue
      System.out.println("ArrayBlockingQueue: " + queue);
  }
}

 

9.LinkedBlockingQueue 阻塞队列 (基于链表)

LinkedBlockingQueue 是 Java 并发包的一部分,它是一个基于链表的可选有界阻塞队列。此队列按照 FIFO(先进先出)的原则对元素进行排序。

LinkedBlockingQueue 在尝试插入元素到已满队列或从空队列中移除元素时,会导致线程阻塞,直到有空间或元素可用。

基于链表实现的阻塞队列,想比与不阻塞的 ConcurrentLinkedQueue,它多了一个容量限制,如果不设置默认为 int 最大值。

 

示例
import java.util.concurrent.*;

public class LinkedBlockingQueueExample {
  public static void main(String[] args) {
      // 创建一个 LinkedBlockingQueue
      LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<String>(3);

      // 向 LinkedBlockingQueue 添加元素
      try {
          queue.put("Element1");
          queue.put("Element2");
          queue.put("Element3");
      } catch (InterruptedException e) {
          e.printStackTrace();
      }

      // 打印 LinkedBlockingQueue
      System.out.println("LinkedBlockingQueue: " + queue);
  }
}

 

10.LinkedBlockingDeque 阻塞队列 (基于双向链表)

LinkedBlockingDeque 是 Java 并发包的一部分,它是一个基于链表的可选有界阻塞双端队列。此队列按照 FIFO(先进先出)的原则对元素进行排序。

LinkedBlockingDeque 在尝试插入元素到已满队列或从空队列中移除元素时,会导致线程阻塞,直到有空间或元素可用。双端队列的优势在于可以从两端插入或移除元素。

类似 LinkedBlockingQueue,但提供了双向链表特有的操作。

 

示例
import java.util.concurrent.*;

public class LinkedBlockingDequeExample {
  public static void main(String[] args) {
      // 创建一个 LinkedBlockingDeque
      LinkedBlockingDeque<String> deque = new LinkedBlockingDeque<String>(3);

      // 向 LinkedBlockingDeque 添加元素
      try {
          deque.putFirst("Element1");
          deque.putLast("Element2");
          deque.putFirst("Element3");
      } catch (InterruptedException e) {
          e.printStackTrace();
      }

      // 打印 LinkedBlockingDeque
      System.out.println("LinkedBlockingDeque: " + deque);
  }
}

 

11.PriorityBlockingQueue 线程安全的优先队列

PriorityBlockingQueue 是 Java 并发包的一部分,它是一个无界的并发队列。它使用了和类 java.util.PriorityQueue 一样的排序规则,并且能够确保在并发环境下的线程安全。

PriorityBlockingQueue 中的元素按照自然顺序或者由比较器提供的顺序进行排序。队列不允许使用 null 元素。

构造时可以传入一个比较器,可以看做放进去的元素会被排序,然后读取的时候按顺序消费。某些低优先级的元素可能长期无法被消费,因为不断有更高优先级的元素进来。

 

示例
import java.util.concurrent.*;

public class PriorityBlockingQueueExample {
  public static void main(String[] args) {
      // 创建一个 PriorityBlockingQueue
      PriorityBlockingQueue<String> queue = new PriorityBlockingQueue<String>();

      // 向 PriorityBlockingQueue 添加元素
      queue.add("Element1");
      queue.add("Element2");
      queue.add("Element3");

      // 打印 PriorityBlockingQueue
      System.out.println("PriorityBlockingQueue: " + queue);
  }
}

 

12.SynchronousQueue 数据同步交换的队列

 

SynchronousQueue 是 Java 并发包的一部分,它是一个不存储元素的阻塞队列。每一个 put 操作必须等待一个 take 操作,否则不能继续添加元素,反之亦然。

这种特性使 SynchronousQueue 成为线程之间传递数据的好工具。它可以看作是一个传球手,负责把生产者线程处理的数据直接传递给消费者线程。

一个虚假的队列,因为它实际上没有真正用于存储元素的空间,每个插入操作都必须有对应的取出操作,没取出时无法继续放入。

 

示例
import java.util.concurrent.SynchronousQueue;

public class Main {
   
  public static void main(String[] args) {
      SynchronousQueue<Integer> queue = new SynchronousQueue<>();
      new Thread(()->{
          try{
              for(int i=0;;i++){
                  System.out.println("放入:" + i);
                  queue.put(i);
              }
          }catch (InterruptedException e){
              e.printStackTrace();
          }
      }).start();

      new Thread(()->{
          try{
              while(true){
                  System.out.println("取出:" + queue.take());
                  Thread.sleep((long)(Math.random()*2000));
              }
          }catch (InterruptedException e){
              e.printStackTrace();
          }
      }).start();
  }
}

运行结果:

取出:0
放入:0
取出:1
放入:1
放入:2
取出:2
取出:3
放入:3
取出:4
放入:4
...
...

可以看到,写入的线程没有任何 sleep,可以说是全力往队列放东西,而读取的线程又很不积极,读一个又 sleep 一会。输出的结果却是读写操作成对出现。

JAVA 中一个使用场景就是 Executors.newCachedThreadPool(),创建一个缓存线程池。

这些Java并发容器,你都了解吗?

13.LinkedTransferQueue 基于链表的数据交换队列

LinkedTransferQueue 是 Java 并发包的一部分,它是一个由链表结构组成的无界转移阻塞队列。队列按照 FIFO(先进先出)的原则对元素进行排序。

LinkedTransferQueue 的一个特性是,它可以尝试将元素直接转移给消费者,如果没有等待的消费者,元素就会被添加到队列的尾部,等待消费者来获取。

实现了接口 TransferQueue,通过 transfer 方法放入元素时,如果发现有线程在阻塞在取元素,会直接把这个元素给等待线程。如果没有人等着消费,那么会把这个元素放到队列尾部,并且此方法阻塞直到有人读取这个元素。和 SynchronousQueue 有点像,但比它更强大。

 

示例
import java.util.concurrent.*;

public class LinkedTransferQueueExample {
  public static void main(String[] args) {
      // 创建一个 LinkedTransferQueue
      LinkedTransferQueue<String> queue = new LinkedTransferQueue<String>();

      // 启动一个新线程来从 LinkedTransferQueue 取出元素
      new Thread(() -> {
          try {
              System.out.println("Taken: " + queue.take());
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }).start();

      // 向 LinkedTransferQueue 添加一个元素
      try {
          queue.transfer("Element");
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
  }
}

 

14.DelayQueue 延时队列

DelayQueue 是 Java 并发包的一部分,它是一个无界阻塞队列,只有在延迟期满时才能从中提取元素。此队列的头部是延迟期满后保存时间最长的元素。如果延迟都还没有期满,则队列没有头部,并且 poll 将返回 null

元素在 DelayQueue 中的顺序是按照其到期时间的先后顺序进行排序的,越早到期的元素越排在队列前面。延迟队列常用于实现定时任务功能。

可以使放入队列的元素在指定的延时后才被消费者取出,元素需要实现 Delayed 接口。

 

示例
import java.util.concurrent.*;

public class DelayQueueExample {
  public static void main(String[] args) {
      // 创建一个 DelayQueue
      DelayQueue<DelayedElement> queue = new DelayQueue<DelayedElement>();

      // 向 DelayQueue 添加一个元素,延迟 3 秒
      queue.put(new DelayedElement(3000, "Element"));

      // 从 DelayQueue 获取元素
      try {
          DelayedElement element = queue.take();
          System.out.println("Taken: " + element);
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
  }
}

class DelayedElement implements Delayed {
  private long delayTime; // 延迟时间
  private long expire; // 到期时间
  private String element; // 元素数据

  public DelayedElement(long delay, String element) {
      this.delayTime = delay;
      this.element = element;
      this.expire = System.currentTimeMillis() + delay;
  }

  @Override
  public long getDelay(TimeUnit unit) {
      return unit.convert(expire - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
  }

  @Override
  public int compareTo(Delayed o) {
      return (int) (this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS));
  }

  @Override
  public String toString() {
      return element;
  }
}

 


 

总结

 

从上面的介绍总总结有以下几种容器类

  1. ConcurrentHashMap:并发版 HashMap

  2. CopyOnWriteArrayList:并发版 ArrayList

  3. CopyOnWriteArraySet:并发 Set

  4. ConcurrentLinkedQueue:并发队列 (基于链表)

  5. ConcurrentLinkedDeque:并发队列 (基于双向链表)

  6. ConcurrentSkipListMap:基于跳表的并发 Map

  7. ConcurrentSkipListSet:基于跳表的并发 Set

  8. ArrayBlockingQueue:阻塞队列 (基于数组)

  9. LinkedBlockingQueue:阻塞队列 (基于链表)

  10. LinkedBlockingDeque:阻塞队列 (基于双向链表)

  11. PriorityBlockingQueue:线程安全的优先队列

  12. SynchronousQueue:读写成对的队列

  13. LinkedTransferQueue:基于链表的数据交换队列

  14. DelayQueue:延时队列

     

Java 并发容器为处理多线程环境下的数据访问和修改提供了强大的工具。

通过了解和学习这些并发容器,我们可以更好地理解并发编程,更有效地处理并发问题。

无论你是正在学习 Java,还是已经在使用 Java 进行开发,我都强烈建议你深入了解这些并发容器,它们将在你的并发编程之路上起到重要的作用。



Tags:容器   点击:()  评论:()
声明:本站部分内容及图片来自互联网,转载是出于传递更多信息之目的,内容观点仅代表作者本人,不构成投资建议。投资者据此操作,风险自担。如有任何标注错误或版权侵犯请与我们联系,我们将及时更正、删除。
▌相关推荐
掌握Docker网络驱动程序:优化容器通信
Docker为在容器内包装、交付和运行应用程序提供了一个强大的平台,从而彻底改变了容器化。网络是容器化的重要组成部分,Docker提供了各种网络驱动程序来支持容器之间的通信以...【详细内容】
2024-03-22  Search: 容器  点击:(10)  评论:(0)  加入收藏
Containerd容器管理
Nginx 指定容器名称 使用 ctr container create 命令创建容器后,容器并没有处于运行状态,其只是一个静态的容器。容器基本操作容器基本操作主要是 ctr image 命令,查看命令帮...【详细内容】
2024-03-20  Search: 容器  点击:(13)  评论:(0)  加入收藏
我们一起聊聊容器资源自愈
在企业实际在使用容器这类资源的时候,除了技术本身,要考虑的其他问题也会很多。企业管理的容器有千千万万,出于效率考虑,对于有特殊需求的容器如何进行批量创建和管理呢,这就需要...【详细内容】
2024-01-30  Search: 容器  点击:(47)  评论:(0)  加入收藏
Docker镜像与容器的交互及在容器内部执行代码的原理与实践
Docker作为一种流行的容器技术,已经成为现代应用程序开发和部署的重要工具。在Docker中,镜像是构建和运行容器的基础,而容器则是基于镜像创建的可执行实例。Docker镜像与容器的...【详细内容】
2024-01-10  Search: 容器  点击:(75)  评论:(0)  加入收藏
Go微服务入门到容器化实践
Go微服务入门到容器化实践Go 是一门高效、现代化、快速增长的编程语言,非常适合构建 Web 应用程序。而 Docker 是一种轻量级的容器化技术,能够使得您的应用程序在任何地方运行...【详细内容】
2024-01-01  Search: 容器  点击:(61)  评论:(0)  加入收藏
容器的“边缘”
译者 | 布加迪审校 | 重楼近年来边缘计算和容器越来越受欢迎,为我们日常生活中与数据处理相关的各种挑战提供了创新的解决方案。这些技术现在已经渗入到各种设备中,包括我们的...【详细内容】
2023-12-25  Search: 容器  点击:(161)  评论:(0)  加入收藏
Docker容器如何打包应用程序的代码和依赖项?
Docker容器通过将应用程序的代码和所有依赖项打包到一个独立的软件包中,实现了应用程序的快速部署和移植。下面是Docker容器实现这一目标的步骤:打包应用程序:使用Docker工具将...【详细内容】
2023-12-20  Search: 容器  点击:(130)  评论:(0)  加入收藏
理解Go、容器以及Linux调度器
Go开发的应用程序通常部署在容器中。在容器中运行时,重要的一点是要设置CPU限制以确保容器不会耗光主机上的所有CPU。但Go运行时不知道容器上设置的CPU限制,因此有可能会把所...【详细内容】
2023-12-18  Search: 容器  点击:(120)  评论:(0)  加入收藏
Docker容器编排技术解析
一、容器编排介绍容器编排是现代云原生应用管理的核心,它涉及在大规模的环境中自动化部署、管理、扩展和网络配置容器。随着微服务架构的兴起和应用的复杂性增加,容器编排成为...【详细内容】
2023-12-15  Search: 容器  点击:(244)  评论:(0)  加入收藏
在Linux系统中实现容器化的大规模数据分析平台:Hadoop和Spark
在Linux系统中实现容器化的大规模数据分析平台,我们可以利用Hadoop和Spark这两个强大的开源工具。Hadoop是一个分布式计算框架,适用于处理大规模数据集。它提供了分布式文件系...【详细内容】
2023-12-15  Search: 容器  点击:(154)  评论:(0)  加入收藏
▌简易百科推荐
Docker 和传统虚拟机有什么区别?
我有一个程序员朋友,他每年情人节都要送女朋友一台服务器。他说:“谁不想在过节当天收到一台 4核8g 的服务器呢?”“万一对方不要,我还能留着自己用。” 给他一次过节的机会,他能...【详细内容】
2024-03-26  小白debug  微信公众号  Tags:Docker   点击:(11)  评论:(0)  加入收藏
掌握Docker网络驱动程序:优化容器通信
Docker为在容器内包装、交付和运行应用程序提供了一个强大的平台,从而彻底改变了容器化。网络是容器化的重要组成部分,Docker提供了各种网络驱动程序来支持容器之间的通信以...【详细内容】
2024-03-22    51CTO  Tags:Docker   点击:(10)  评论:(0)  加入收藏
Containerd容器管理
Nginx 指定容器名称 使用 ctr container create 命令创建容器后,容器并没有处于运行状态,其只是一个静态的容器。容器基本操作容器基本操作主要是 ctr image 命令,查看命令帮...【详细内容】
2024-03-20  云原生运维圈  微信公众号  Tags:容器   点击:(13)  评论:(0)  加入收藏
如何基于Docker镜像逆向生成Dockerfile
引言你是否曾经遇到过一个想要使用的 Docker 镜像,但却无法修改以适应你的特定需求?或者你可能发现了一个喜欢的 Docker 镜像,但想要了解它是如何构建的?在这两种情况下,将 Docke...【详细内容】
2024-03-07  云原生运维圈  微信公众号  Tags:Docker   点击:(22)  评论:(0)  加入收藏
Kubernetes是什么?主要特点是什么?
Kubernetes是什么?Kubernetes,也称为K8s,是一个开源的容器编排系统,由Google首次开发和维护。它允许容器化的应用程序在集群中自动部署、扩展和管理。Kubernetes提供了一种容器...【详细内容】
2024-02-01    简易百科  Tags:Kubernetes   点击:(153)  评论:(0)  加入收藏
我们一起聊聊容器资源自愈
在企业实际在使用容器这类资源的时候,除了技术本身,要考虑的其他问题也会很多。企业管理的容器有千千万万,出于效率考虑,对于有特殊需求的容器如何进行批量创建和管理呢,这就需要...【详细内容】
2024-01-30  匠心独运维妙维效  微信公众号  Tags:容器   点击:(47)  评论:(0)  加入收藏
Docker与Docker Compose入门:释放你应用部署的威力
今天给大家介绍一项强大而有趣的技能,那就是使用 Docker 和 Docker Compose 来释放你的应用部署的威力!无论你是一名开发人员还是系统管理员,掌握这个技能都将为你的工作带来巨...【详细内容】
2024-01-17  waynblog  微信公众号  Tags:Docker   点击:(65)  评论:(0)  加入收藏
Docker镜像与容器的交互及在容器内部执行代码的原理与实践
Docker作为一种流行的容器技术,已经成为现代应用程序开发和部署的重要工具。在Docker中,镜像是构建和运行容器的基础,而容器则是基于镜像创建的可执行实例。Docker镜像与容器的...【详细内容】
2024-01-10  编程技术汇  今日头条  Tags:Docker   点击:(75)  评论:(0)  加入收藏
如何在 Ubuntu 上安装 Docker
使用 Docker 意味着开启一个新的计算领域,但如果你刚刚开始使用 Docker,安装可能看起来是一项艰巨的任务。在 Ubuntu 上安装 Docker 有两种推荐的方法: 从 Ubuntu 的仓库安装 D...【详细内容】
2024-01-04    Linux中国  Tags:Docker   点击:(124)  评论:(0)  加入收藏
从Kubernetes的探针到DevOps
今天在群里又看有人问如何设置 Kubernetes 的探针,感觉要补充的话太多了,结合我们在一些 DevOps 项目中痛苦的体验,今天一劳永逸的全部说完,此外,也为大家展现一下为什么 DevOps...【详细内容】
2023-12-27  云云众生s  微信公众号  Tags:Kubernetes   点击:(113)  评论:(0)  加入收藏
站内最新
站内热门
站内头条