如何使用Java进行并发编程问题示例

原创末蓝、 2024-10-07 11:27 38阅读 0赞

在Java中，并发编程主要涉及到线程、锁（同步机制）和各种并发工具。以下是一个简单的并发编程问题示例：

**问题：** 有一个任务列表，每个任务都需要特定时间来完成。现在需要并发执行这些任务，并确保所有任务按照它们的预计时间顺序完成。

**解决方案：**

1. **定义任务类**：创建一个Task类，包含任务名称、预计执行时间等属性。

```java
class Task {
    String name;
    long estimatedTime;

// constructor, getters and setters
}
```

2. **创建任务列表**：创建一个任务列表，可以是一个ArrayList或LinkedList。

3. **并发执行任务**：使用Java的线程库（如`ExecutorService`和`Callable`接口）来并发执行这些任务。为了确保按预计时间顺序完成，你可以使用`PriorityQueue`作为线程池，它会自动按照优先级执行任务。

```java
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.PriorityBlockingQueue;

class ConcurrentTaskExample {
    static class TaskWithEstimate implements Callable<Void> {
        String name;
        long estimatedTime;

TaskWithEstimate(String name, long estimatedTime) {
            this.name = name;
            this.estimatedTime = estimatedTime;
        }

@Override
        public Void call() throws Exception {
            System.out.println("Task: " + name);
            Thread.sleep(estimatedTime); // simulate execution time
            return null;
        }
    }

static void main(String[] args) {
        List<TaskWithEstimate> tasks = new ArrayList<>();
        // Add tasks with estimated times

ExecutorService executor = new ThreadPoolExecutor(
                1, // core pool size
                Integer.MAX_VALUE, // maximum pool size
                0L, // keep alive time
                TimeUnit.MILLISECONDS, // time unit
                new PriorityBlockingQueue<>(tasks.size()) // priority queue as a sink
        );

for (TaskWithEstimate task : tasks) {
            executor.submit(task);
        }

// Wait until all tasks are completed
        executor.shutdown();
        while (!executor.isTerminated())) {
            try {
                Thread.sleep(100); // wait for 1 sec
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

System.out.println("All tasks completed.");
    }
}
```

这个例子中，我们创建了一个任务列表，每个任务都有预计的执行时间。然后使用`ThreadPoolExecutor`并发地提交这些任务。通过控制线程池大小和优先级队列，确保了任务按照预计的时间顺序完成。