面试题：Java多态代码复用在高并发场景下的挑战与优化

高并发场景下基于Java多态代码复用可能面临的问题

资源竞争
- 问题描述：当多个线程通过多态调用共享资源（如文件、数据库连接等）的方法时，可能会出现资源竞争。例如，多个线程同时调用子类中操作共享文件的方法，可能导致文件内容混乱。
- 示例代码：

class FileOperator {
    public void writeToFile(String content) {
        // 实际文件写入逻辑省略，假设这里直接打印内容模拟写入
        System.out.println("Writing: " + content);
    }
}

class SubFileOperator extends FileOperator {
    @Override
    public void writeToFile(String content) {
        super.writeToFile(content);
    }
}

public class ResourceCompetitionExample {
    public static void main(String[] args) {
        FileOperator fileOperator = new SubFileOperator();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                fileOperator.writeToFile("Content from thread " + Thread.currentThread().getName());
            }).start();
        }
    }
}

理论依据：多个线程并发访问共享资源，在没有同步机制的情况下，操作顺序无法保证，从而导致资源竞争。

线程安全
- 问题描述：多态方法中可能包含共享的可变状态，多个线程同时访问和修改这些状态时，可能导致数据不一致或其他线程安全问题。比如，子类重写的方法中操作了一个共享的计数器。
- 示例代码：

class Counter {
    private int count = 0;
    public void increment() {
        count++;
    }
    public int getCount() {
        return count;
    }
}

class SubCounter extends Counter {
    @Override
    public void increment() {
        super.increment();
    }
}

public class ThreadSafetyExample {
    public static void main(String[] args) {
        Counter counter = new SubCounter();
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> {
                counter.increment();
            }).start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Expected count: 1000, Actual count: " + counter.getCount());
    }
}

理论依据：count++ 操作不是原子性的，它包含读取、增加和写入三个步骤，在多线程环境下可能出现脏读等问题。

优化策略

同步机制
- 策略描述：使用 synchronized 关键字或 java.util.concurrent.locks 包中的锁机制来同步对共享资源或共享状态的访问。
- 示例代码（使用 synchronized）：

class SynchronizedFileOperator {
    public synchronized void writeToFile(String content) {
        // 实际文件写入逻辑省略，假设这里直接打印内容模拟写入
        System.out.println("Writing: " + content);
    }
}

class SubSynchronizedFileOperator extends SynchronizedFileOperator {
    @Override
    public synchronized void writeToFile(String content) {
        super.writeToFile(content);
    }
}

public class SynchronizedResourceExample {
    public static void main(String[] args) {
        SynchronizedFileOperator fileOperator = new SubSynchronizedFileOperator();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                fileOperator.writeToFile("Content from thread " + Thread.currentThread().getName());
            }).start();
        }
    }
}

理论依据：synchronized 关键字保证同一时间只有一个线程可以进入同步块或方法，从而避免资源竞争和线程安全问题。

使用线程安全的类
- 策略描述：对于共享状态，使用Java提供的线程安全类，如 AtomicInteger 代替普通的 int 类型。
- 示例代码：

import java.util.concurrent.atomic.AtomicInteger;

class AtomicCounter {
    private AtomicInteger count = new AtomicInteger(0);
    public void increment() {
        count.incrementAndGet();
    }
    public int getCount() {
        return count.get();
    }
}

class SubAtomicCounter extends AtomicCounter {
    @Override
    public void increment() {
        super.increment();
    }
}

public class AtomicThreadSafetyExample {
    public static void main(String[] args) {
        AtomicCounter counter = new SubAtomicCounter();
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> {
                counter.increment();
            }).start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Expected count: 1000, Actual count: " + counter.getCount());
    }
}

理论依据：AtomicInteger 类中的方法是原子性的，通过硬件级别的操作保证多线程环境下数据的一致性。

减少共享状态
- 策略描述：尽量减少多态方法中共享可变状态的使用，将状态变为局部变量或不可变对象。
- 示例代码：

class ImmutableFileOperator {
    public void writeToFile(String content) {
        String newContent = "Prefix: " + content;
        // 实际文件写入逻辑省略，假设这里直接打印内容模拟写入
        System.out.println("Writing: " + newContent);
    }
}

class SubImmutableFileOperator extends ImmutableFileOperator {
    @Override
    public void writeToFile(String content) {
        super.writeToFile(content);
    }
}

public class ImmutableExample {
    public static void main(String[] args) {
        ImmutableFileOperator fileOperator = new SubImmutableFileOperator();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                fileOperator.writeToFile("Content from thread " + Thread.currentThread().getName());
            }).start();
        }
    }
}

理论依据：不可变对象不存在线程安全问题，因为它们的状态不可改变，每个线程操作的都是独立的副本。

面试题：Java多态代码复用在高并发场景下的挑战与优化

知识考点

面试题答案

高并发场景下基于Java多态代码复用可能面临的问题

优化策略