多线程并发控制：Java实例展示

原创左手的ㄟ右手 2024-09-22 21:15 66阅读 0赞

在Java中，多线程并发控制主要通过以下几种方式实现：

1. 同步(synchronized)：
   - synchronized关键字可以修饰方法或代码块。
   - 在同步代码块内部，所有线程进入前必须获得锁。
   - 示例：
   ```java
   class SharedResource {
       private int count = 0;
       
       // synchronized method to increment count
       synchronized void increment() {
           count++;
       }
   }

public class MultiThreadExample {
       public static void main(String[] args) {
           // 创建共享资源对象
           SharedResource sharedResource = new SharedResource();

// 创建两个线程，分别增加count
           Thread thread1 = new Thread(() -> {
               while (true) {  // 运行无限循环
                   if (sharedResource.increment() == 0) {  // 当count为0时跳出循环
                       break;
                   }
               }
           }));

Thread thread2 = new Thread(() -> {
               while (true) {  // 运行无限循环
                   sharedResource.increment();  // 每次迭代都增加count
               }
           }));

// 启动两个线程
           thread1.start();
           thread2.start();

// 等待所有线程完成
           try {
               thread1.join();
               thread2.join();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }

// 输出共享资源的最终count值
           System.out.println("Final count: " + sharedResource.count);
       }
   }
```

以上代码创建了两个线程，分别增加一个共享资源（`SharedResource`）的计数。通过`synchronized`关键字确保线程安全。

2. 管道(channel)与选择(select)：
   - Java并发API中的`Channel`接口和`Selector`类可以用于多路通信。
   - 示例较少，通常用于网络编程中，如TCP连接建立、数据传输等场景。

3. 任务队列(Executor)：
   - `Executor`接口提供了异步执行任务的能力。
   - 使用`ThreadPoolExecutor`实现线程池管理任务的执行。
   - 示例：
   ```java
   import java.util.concurrent.ExecutorService;
   import java.util.concurrent.Executors;

public class ExecutorExample {
       public static void main(String[] args) {
           // 创建一个固定大小的线程池（10个线程）
           ExecutorService executor = Executors.newFixedThreadPool(10);

// 提交任务到线程池，每个任务是独立执行的
           for (int i = 0; i < 50; i++) {
               executor.submit(() -> {
                   System.out.println("Task " + i + " started...");
                   try {
                       Thread.sleep(100);  // 模拟任务执行时间
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   System.out.println("Task " + i + " completed...");
               });
           }

// 关闭线程池，释放所有资源
           executor.shutdown();

// 等待所有任务完成，或者超时（10秒）
           while (!executor.isTerminated()) {
               try {
                   Thread.sleep(500);  // 检查每500毫秒一次
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }

System.out.println("Executor completed.");
       }
   }
```

以上代码展示了如何使用`ExecutorService`实现异步任务的执行。通过线程池管理多个任务，提高了并发性能。