更新

Author: hanyanbing123

JavaConcurrent/.idea/compiler.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_6">
+  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_8">
     <output url="file://$MODULE_DIR$/target/classes" />
     <output-test url="file://$MODULE_DIR$/target/test-classes" />
     <content url="file://$MODULE_DIR$">

JavaConcurrent/.idea/encodings.xml

@@ -0,0 +1,56 @@
+package com.FlammulinaBlog.Java.Concurrent.CAS;
+
+import java.util.List;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class AtomicCounter {
+
+    private AtomicInteger value = new AtomicInteger(0);
+
+    public int getValue() {
+        return value.get();
+    }
+
+    public void increment() {
+        int current;
+        int next;
+        do {
+            // 读取当前值
+            current = value.get();
+            // 计算下一个值
+            next = current + 1;
+            // CAS操作尝试更新值
+            System.out.println(Thread.currentThread().getName() + ": CAS operation  current: " + current + " next:" + next + (current == next ? "succeeded" : "failed"));
+        } while (!value.compareAndSet(current, next)); // 如果当前值已经被其他线程修改，则重试
+        // 打印CAS操作结果
+    }
+
+    public static void main(String[] args) {
+        AtomicCounter counter = new AtomicCounter();
+        // 启动多个线程并发执行递增操作
+        for (int i = 0; i < 100; i++) {
+            new Thread(() -> {
+                for (int j = 0; j < 1000; j++) {
+                    counter.increment();
+                }
+            }).start();
+        }
+
+        ArrayBlockingQueue sss =  new ArrayBlockingQueue<>(1);
+
+        CountDownLatch countDownLatch = new CountDownLatch(2);
+
+        // 等待所有线程执行完毕
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        // 输出最终计数值
+        System.out.println("Final count: " + counter.getValue());
+    }
+
+}

JavaConcurrent/.idea/jarRepositories.xml

@@ -0,0 +1,35 @@
+package com.FlammulinaBlog.Java.Concurrent;
+
+import java.util.concurrent.CountDownLatch;
+
+public class CountDownLatchExample {
+    private static final int THREAD_COUNT = 64;
+
+    public static void main(String[] args) throws InterruptedException {
+        CountDownLatch startSignal = new CountDownLatch(1);
+        CountDownLatch doneSignal = new CountDownLatch(THREAD_COUNT);
+
+        for (int i = 0; i < THREAD_COUNT; i++) {
+            new Thread(() -> {
+                try {
+                    startSignal.await(); // 等待startSignal为0
+                    // 模拟任务执行
+                    System.out.println("Thread " + Thread.currentThread().getName() + " is executing task...");
+                    Thread.sleep(1000); // 模拟任务耗时
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                } finally {
+                    doneSignal.countDown(); // 任务执行完毕，计数器减1
+                }
+            }).start();
+        }
+
+        System.out.println("Start all threads...");
+
+        Thread.sleep(1000L);
+        startSignal.countDown(); // 触发所有线程开始执行任务
+        System.out.println("触发所有线程开始执行任务");
+        doneSignal.await(); // 等待所有线程执行完毕
+        System.out.println("All threads have finished executing tasks.");
+    }
+}

JavaConcurrent/.idea/misc.xml

@@ -0,0 +1,42 @@
+package com.FlammulinaBlog.Java.Concurrent.Semaphore;
+
+import java.util.concurrent.Semaphore;
+
+public class SemaphoreExample {
+
+    public static void main(String[] args) {
+
+        Semaphore semaphore = new Semaphore(20); // 创建一个初始许可证数量为 3 的 Semaphore
+
+        // 创建 5 个线程并启动
+        for (int i = 0; i < 10; i++) {
+            Thread thread = new Thread(new Worker(semaphore, i + 1));
+            thread.start();
+        }
+
+    }
+
+    static class Worker implements Runnable {
+        private final Semaphore semaphore;
+        private final int id;
+
+        public Worker(Semaphore semaphore, int id) {
+            this.semaphore = semaphore;
+            this.id = id;
+        }
+
+        @Override
+        public void run() {
+            try {
+                semaphore.acquire(); // 获取许可证
+                System.out.println("Worker " + id + " is 工作中");
+                Thread.sleep(2000); // 模拟工作
+                System.out.println("Worker " + id + " 完成工作");
+                semaphore.release(); // 释放许可证
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+}