Java中“无封闭实例”错误解析与静态嵌套类实践

public static void main(String args[]) {
    ReaderWriter readerWriter = new ReaderWriter(); // 错误发生在此处
    // ...
}

class Reader extends Thread {
    // ... 其他成员 ...
    class ReaderWriter { // ReaderWriter 是 Reader 的一个非静态内部类
        // ... ReaderWriter 的成员和方法 ...
        public static void main(String args[]) {
            ReaderWriter readerWriter = new ReaderWriter(); // 尝试实例化 ReaderWriter
            // ...
        }
    }
}

import BSsync.Lock;
import BSsync.Condition;

class File {
    String content = "";
}

class Reader extends Thread {
    ReaderWriter readerWriter; // 注意：这里ReaderWriter现在是一个静态嵌套类
    String identifier;

    public Reader (String identifier, ReaderWriter readerWriter) {
        this.identifier = identifier;
        this.readerWriter = readerWriter;
    }

    public void run () {
        for (int i = 0; i < 10; i++) {
            String message = readerWriter.read(identifier);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // Writer 类也可能需要考虑是否声明为静态，取决于其是否需要访问 Reader 的非静态成员
    class Writer extends Thread { // 如果Writer不需要访问Reader的非静态成员，也应考虑设为static
        ReaderWriter readerWriter;
        String identifier;

        public Writer (String identifier, ReaderWriter readerWriter) {
            this.identifier = identifier;
            this.readerWriter = readerWriter;
        }

        public void run() {
            for (int i = 0; i < 10; i++) {
                String message = "Message " + i + " of writer " + identifier;
                readerWriter.write(message);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 将 ReaderWriter 声明为静态嵌套类
    static class  ReaderWriter { // 添加 static 关键字
        final static int MAX_READERS = 3;

        Lock mutex = new Lock();
        Condition okToWrite = mutex.newCondition();
        Condition maxReaders = mutex.newCondition();
        int activeReaders = 0;
        boolean busy = false;
        File file = new File();

        public String read (String identifierOfReader) {
            readStart();
            String result = file.content;
            System.out.println("\tReader " + identifierOfReader + " has read: " + result);
            readStop();
            return result;
        }

        public void write (String content) {
            writeStart();
            System.out.println(content + " was written");
            file.content = content;
            writeStop();
        }

        private void readStart() {
            mutex.lock();

            while (busy) {
                okToWrite.await();
            }

            while (activeReaders + 1 > MAX_READERS) {
                maxReaders.await();
            }

            activeReaders++;
            mutex.unlock();
        }

        private void readStop() {
            mutex.lock();
            activeReaders--;
            maxReaders.signalAll();
            if (activeReaders == 0) {
                okToWrite.signalAll();
            }
            mutex.unlock();
        }

        private void writeStart() {
            mutex.lock();
            while (busy || activeReaders > 0) {
                okToWrite.await();
            }
            busy = true;
            mutex.unlock();
        }

        private void writeStop() {
            mutex.lock();
            busy = false;
            okToWrite.signalAll();
            mutex.unlock();
        }

        // main 方法现在可以正常实例化 ReaderWriter
        public static void main(String args[]) {
            ReaderWriter readerWriter = new ReaderWriter(); // 现在可以正常工作

            // 注意：如果 Writer 仍然是非静态内部类，这里创建 Writer 实例的方式也需要调整
            // 例如：Reader dummyReader = new Reader("dummy", readerWriter);
            // Writer writerA = dummyReader.new Writer("A", readerWriter);
            // 更好的做法是将 Writer 也声明为 static
            ReaderWriter.Writer writerA = new ReaderWriter.Writer("A", readerWriter); // 假设 Writer 也已改为静态嵌套类
            ReaderWriter.Writer writerB = new ReaderWriter.Writer("B", readerWriter); // 假设 Writer 也已改为静态嵌套类
            writerA.start();
            writerB.start();

            for (int i = 0; i < 50; i++) {
                Reader r = new Reader(Integer.toString(i), readerWriter);
                r.start();
            }
        }
    }
}