1、描述

下游可用的服务器目前有5个（node），设计一个方法，方法没有任何参数，采用轮询的方式返回其中一个node；

2、使用环形链表

每次取下一个node即可。注意：需要保证线程安全！

// 节点定义 @Data class Node {      Node next;      String name;      String ip;  }

// 环形状node集合 class LoadBalanceCycle {      private Node head;      private Node nextNode;      /**      * 添加节点      */     public synchronized void addNode(String name, String ip) {         Node newNode = new Node();         newNode.name = name;         newNode.ip = ip;          if (head == null) {             head = newNode;             head.next = head;         } else {             Node temp = head;             while (temp.next != head) {                 temp = temp.next;             }             temp.next = newNode;             newNode.next = head;         }     }      /**      * 获取下一个节点      */     public synchronized Node getNextNode() {         if (nextNode == null) {             nextNode = head;         } else {             nextNode = nextNode.next;         }         return nextNode;     }  }

// 测试验证 public static void main(String[] args) {          LoadBalanceCycle loadBalanceCycle = new LoadBalanceCycle();          // 初始化三个节点的         loadBalanceCycle.addNode("node1", "192.168.0.1");         loadBalanceCycle.addNode("node2", "192.168.0.2");         loadBalanceCycle.addNode("node3", "192.168.0.3");          AtomicInteger n1Count = new AtomicInteger();         AtomicInteger n2Count = new AtomicInteger();         AtomicInteger n3Count = new AtomicInteger();          CountDownLatch latch = new CountDownLatch(30);          // 多线程，返回负载均衡中的节点         for (int i = 0; i < 3; i++) {             new Thread(() -> {                 int j = 10;                 while (j > 0) {                     try {                         String name = loadBalanceCycle.getNextNode().getName();                         System.out.println(Thread.currentThread().getName() + " " + name);                         if ("node1".equals(name)) {                             n1Count.incrementAndGet();                         }                         if ("node2".equals(name)) {                             n2Count.incrementAndGet();                         }                         if ("node3".equals(name)) {                             n3Count.incrementAndGet();                         }                         j--;                     } finally {                         latch.countDown();                     }                 }              }).start();          }          try {             latch.await();         } catch (InterruptedException e) {             throw new RuntimeException(e);         }          System.out.println("==============================负载均衡调用结果===================================");          System.out.println("node1 被调用的次数: " + n1Count.get());         System.out.println("node2 被调用的次数: " + n2Count.get());         System.out.println("node3 被调用的次数: " + n3Count.get());      }  }

3、使用AtomicLong

long 类型的最大值？

这个值是 2^63 - 1，即 9223372036854775807，是 long 类型能表示的最大正数值。

是多少亿？

Long.MAX_VALUE 大约是 92233.72 亿。（如果你的请求次数即【负载均衡调用次数】会超过这个值，那么或许下面的例子会存在问题）

@Data class Node2 {      String name;      String ip;      public Node2(String node1, String s) {         this.name = node1;         this.ip = s;     } }

 /**  * 基于AtomicLong实现的一个结构  */ class LoadBalanceByAtomic {      final List nodeList = new ArrayList<>();      AtomicLong mark = new AtomicLong(0);      public void add(Node2 node) {         synchronized (nodeList) {             nodeList.add(node);         }     }      public Node2 getNext() {         long andIncrement = mark.getAndIncrement();         return nodeList.get((int) (andIncrement % nodeList.size()));     }  }

测试代码

public static void main(String[] args) {          LoadBalanceByAtomic loadBalanceByAtomic = new LoadBalanceByAtomic();          // 初始化三个节点的         loadBalanceByAtomic.add(new Node2("node1", "192.168.0.1"));         loadBalanceByAtomic.add(new Node2("node2", "192.168.0.2"));         loadBalanceByAtomic.add(new Node2("node3", "192.168.0.3"));          AtomicInteger n1Count = new AtomicInteger();         AtomicInteger n2Count = new AtomicInteger();         AtomicInteger n3Count = new AtomicInteger();          CountDownLatch latch = new CountDownLatch(30);          // 多线程，返回负载均衡中的节点         for (int i = 0; i < 3; i++) {             new Thread(() -> {                 int j = 10;                 while (j > 0) {                     try {                         String name = loadBalanceByAtomic.getNext().getName();                         System.out.println(Thread.currentThread().getName() + " " + name);                         if ("node1".equals(name)) {                             n1Count.incrementAndGet();                         }                         if ("node2".equals(name)) {                             n2Count.incrementAndGet();                         }                         if ("node3".equals(name)) {                             n3Count.incrementAndGet();                         }                         j--;                     } finally {                         latch.countDown();                     }                 }              }).start();          }          try {             latch.await();         } catch (InterruptedException e) {             throw new RuntimeException(e);         }          System.out.println("==============================负载均衡调用结果===================================");          System.out.println("node1 被调用的次数: " + n1Count.get());         System.out.println("node2 被调用的次数: " + n2Count.get());         System.out.println("node3 被调用的次数: " + n3Count.get());      }

结果：

问题

在大并发下使用 AtomicInteger ，相比于使用锁，Atomic会不断自旋重试，在线程比较多的场景下会造成cpu资源消耗高么？

在大并发场景下，使用 AtomicInteger 相比使用显式的锁（如 synchronized）确实有一些区别和考虑因素。

1. 自旋和CPU消耗：

   • AtomicInteger 使用了一些技术（如 CAS，即比较并交换），它会尝试更新值直到成功。如果更新失败，它会自旋（重试）。在低并发情况下，自旋几乎没有额外开销，因为更新通常很快成功。
   • 在高并发情况下，自旋可能会导致一定的CPU资源消耗。如果有大量线程竞争同一个 AtomicInteger，并且更新操作不断失败，导致频繁自旋，会增加CPU负载。

2. 性能比较：

   • AtomicInteger 在低到中等并发情况下通常比显式锁（如 synchronized）效率更高，因为它利用了硬件级别的原子操作，避免了线程阻塞和切换的开销。
   • 在非常高的并发情况下，性能可能会受到影响，因为自旋操作可能会消耗大量CPU资源，而且不能保证性能和可扩展性的优势。

3. 选择合适的工具：

   • 在选择 AtomicInteger 还是显式锁时，需要考虑具体的应用场景和并发需求。通常情况下，AtomicInteger 更适合用于简单的计数或者状态标记等，而显式锁更适合于需要复杂的条件同步和数据操作的场景。

综上所述，虽然 AtomicInteger 在大多数情况下性能优于显式锁，但在极端高并发情况下，它可能会因为自旋而增加CPU消耗。因此，在高并发场景下，需要进行性能测试和基准测试，以便选择最适合的并发控制方法。

二者比较

锁跟Atomic-CAS在大并发场景下的效率比较-CSDN博客