JAVA高级面试面试---多线程优化技巧与实战

java复制代码
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ImageProcessor {
private static final int THREAD_POOL_SIZE = 4; // 根据CPU核心数设置线程池大小
private static final ExecutorService executorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
public static void processImage(String filePath) {
// 图像处理逻辑
        System.out.println("Processing image: " + filePath);
try {
            Thread.sleep(1000); // 模拟处理时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
public static void main(String[] args) {
        String[] imageFiles = {"image1.jpg", "image2.jpg", "image3.jpg", /* ... */};
for (String filePath : imageFiles) {
            executorService.submit(() -> processImage(filePath));
        }
        executorService.shutdown();
    }
}

java复制代码
import java.util.concurrent.atomic.AtomicInteger;
public class LockFreeQueue<T> {
private static class Node<T> {
        T item;
        Node<T> next;
        Node(T item) {
this.item = item;
        }
    }
private final AtomicInteger head = new AtomicInteger();
private final AtomicInteger tail = new AtomicInteger();
private volatile Node<T> dummy = new Node<>(null);
public boolean enqueue(T item) {
        Node<T> newNode = new Node<>(item);
int currentTail, nextTail;
do {
            currentTail = tail.get();
            nextTail = (currentTail + 1) & (Integer.MAX_VALUE - 1);
        } while (!tail.compareAndSet(currentTail, nextTail));
        newNode.next = dummy.next;
if (!dummy.compareAndSet(dummy.next, newNode)) {
            tail.set(currentTail); // 回滚tail指针
return false;
        }
return true;
    }
@SuppressWarnings("unchecked")
public T dequeue() {
        Node<T> oldHead;
        Node<T> newHead;
do {
            oldHead = dummy;
            newHead = oldHead.next;
        } while (oldHead != head.get() || oldHead == newHead);
if (newHead == dummy) {
return null; // 队列为空
        }
T item = newHead.item;
if (!head.compareAndSet(oldHead, newHead)) {
return null; // CAS失败，重新尝试
        }
return item;
    }
public static void main(String[] args) {
        LockFreeQueue<Integer> queue = new LockFreeQueue<>();
// 生产者线程
Thread producer = new Thread(() -> {
for (int i = 0; i < 100; i++) {
                queue.enqueue(i);
                System.out.println("Produced: " + i);
            }
        });
// 消费者线程
Thread consumer = new Thread(() -> {
for (int i = 0; i < 100; i++) {
Integer item = queue.dequeue();
if (item != null) {
                    System.out.println("Consumed: " + item);
                }
            }
        });
        producer.start();
        consumer.start();
    }
}

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;
public class ParallelSum extends RecursiveTask<Integer> {
private static final int THRESHOLD = 1000; // 阈值，用于决定何时停止拆分任务
private final int[] array;
private final int start;
private final int end;
public ParallelSum(int[] array, int start, int end) {
this.array = array;
this.start = start;
this.end = end;
    }
@Override
protected Integer compute() {
int length = end - start;
if (length <= THRESHOLD) {
// 如果任务足够小，则直接计算
int sum = 0;
for (int i = start; i < end; i++) {
                sum += array[i];
            }
return sum;
        } else {
// 否则，将任务拆分为两个子任务并发执行
int mid = (start + end) / 2;
ParallelSum leftTask = new ParallelSum(array, start, mid);
ParallelSum rightTask = new ParallelSum(array, mid, end);
            invokeAll(leftTask, rightTask); // 并发执行任务
return leftTask.join() + rightTask.join(); // 合并结果
        }
    }
public static void main(String[] args) {
int[] array = new int[10000];
for (int i = 0; i < array.length; i++) {
            array[i] = i;
        }
ForkJoinPool pool = new ForkJoinPool();
ParallelSum task = new ParallelSum(array, 0, array.length);
Integer result = pool.invoke(task);
        System.out.println("Sum: " + result);
        pool.shutdown();
    }
}