Java多线程实践：任务调度和同步问题

原创浅浅的花香味﹌ 2024-12-02 13:12 2阅读 0赞

在Java中，多线程主要应用于任务调度、数据共享等场景。以下是一些关于任务调度和同步问题的实战示例：

1. **任务调度**：
   - `java.util.concurrent` 包提供了很多工具类，比如 `ExecutorService`, `ScheduledExecutorService` 等。
   ```java
   // 创建固定线程数的线程池
   ExecutorService executor = Executors.newFixedThreadPool(5);

// 提交可中断的任务到线程池
   Future<String> future = executor.submit(() -> {
       Thread.sleep(2000); // 模拟耗时任务
       return "Task completed!";
     }));

// 等待任务完成，如果任务被中断，未来结果是取消状态
   try {
      System.out.println(future.get()); // 输出：Task completed!
   } catch (InterruptedException | ExecutionException e) {
      System.err.println("Error occurred: ", e);
   }
   executor.shutdown(); // 关闭线程池
   ```

2. **同步问题**：
   - `synchronized` 关键字用于同步代码块。
   ```java
   // 同步代码块，确保同一时间只有一个线程访问
   class Counter {
       private int count = 0;

synchronized void increment() {
           count++;
           notifyAll(); // 唤醒等待的线程
       }

synchronized int getCount() {
           return count;
       }
   }

public class Main {
       public static void main(String[] args) {
           Counter counter = new Counter();

// 创建线程A，尝试增加计数器
           Thread threadA = new Thread(() -> {
               try {
                   counter.increment();
               } catch (InterruptedException e) {
                   System.err.println("Error occurred: ", e);
               }
           }));

// 创建线程B，等待增加计数器的机会
           Thread threadB = new Thread(() -> {
               while (!counter.getCount() % 2)) {
                   try {
                       counter.increment();
                       break; // 确保计数器只被一个线程修改
                   } catch (InterruptedException e) {
                       System.err.println("Error occurred: ", e);
                   }
                   synchronized (counter) { // 使用同步锁保护访问计数器
                     if (!counter.getCount() % 2)) {
                       continue; // 如果计数器还是偶数，继续等待
                      }
                      break; // 找到机会更新计数器
                   }
               }
           }));

// 启动线程A和B
           threadA.start();
           threadB.start();

// 等待所有任务完成
           try {
               threadA.join(); // 线程A等待结束后，主线程继续执行
               threadB.join(); // 同理，线程B等待结束后，主线程继续执行
           } catch (InterruptedException e) {
               System.err.println("Error occurred: ", e);
           }
       }
   }
   ```

以上就是Java多线程在任务调度和同步问题上的实践应用。