java - java非法监控状态异常

Question

我有一个类用户，它将 json 对象写入文件

public class User {

    public static void main(String args[]) throws IOException, org.json.simple.parser.ParseException{
        writetofile();
        Q q= new Q();
        Writer write = new Writer("write",q);
//      System.out.println(q.queue.poll());
        Reader reader = new Reader("read",q);
    }
    public static void writetofile() throws IOException{
        FileWriter file = new FileWriter("file1.txt");
        for(int i=0;i<3;++i){
            JSONObject obj = new JSONObject();
            obj.put("Name", rand_s());
            obj.put("Age", rand_i());
            file.write(obj.toJSONString());
            file.flush();
            file.write("\r\n");
    //      System.out.println("Successfully Copied JSON Object to File...");
        //  System.out.println("\nJSON Object: " + obj);
        }
    }
    public static String rand_s(){
        final String AB = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        SecureRandom rnd = new SecureRandom();
        StringBuilder sb = new StringBuilder( 12 );
           for( int i = 0; i < 12; i++ ) 
              sb.append( AB.charAt( rnd.nextInt(AB.length()) ) );
           return sb.toString();
    }
    public static String rand_i(){
        final String AB = "0123456789";
        SecureRandom rnd = new SecureRandom();
        StringBuilder sb = new StringBuilder( 2 );
           for( int i = 0; i < 2; i++ ) 
              sb.append( AB.charAt( rnd.nextInt(AB.length()) ) );
           return sb.toString();
    }
}

我有一个类编写器，它将 Json 文档从文件写入队列，还有一个类读取器，它从队列读取并打印对象并将它们从队列中删除

下面是作家类(class)

package org.mmt;

import java.io.File;
import java.io.FileNotFoundException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Scanner;

import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;

public class Writer implements Runnable {
    Thread t;
    Q q;
    Writer(String name,Q q){
        t= new Thread(this,name);
        this.q = q;
        t.start();
    }
    @Override
    public void run(){
        String FileName="file1.txt";
        try {
            ArrayList<JSONObject> jsons=ReadJSON(new File(FileName),"UTF-8");
            for(JSONObject ob1 : jsons){
                q.put(ob1);
                notifyAll();
//              System.out.println(q.queue.poll());
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            e.printStackTrace();
        } catch (org.json.simple.parser.ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public static synchronized ArrayList<JSONObject> ReadJSON(File MyFile,String Encoding) throws FileNotFoundException, ParseException, org.json.simple.parser.ParseException {
        Scanner scn=new Scanner(MyFile,Encoding);
        ArrayList<JSONObject> json=new ArrayList<JSONObject>();
    //Reading and Parsing Strings to Json
        while(scn.hasNext()){
            JSONObject obj= (JSONObject) new JSONParser().parse(scn.nextLine());
            json.add(obj);
        }
        return json;
    }

}

下面是读者类(class)

package org.mmt;

import java.util.Queue;

import org.json.simple.JSONObject;

public class Reader implements Runnable {

    Thread t;
    Q q;
    Reader(String name,Q q){
        t=new Thread(this,name);
        this.q=q;
        t.start();
    }
    public void run() {
        // TODO Auto-generated method stub
        while(!q.empty()){
            JSONObject obj = new JSONObject();
            obj = q.get();
            System.out.println(obj);
        }
        while(q.empty()){
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

下面是 Q 类，其中包含必须写入数据的队列

package org.mmt;

import java.util.LinkedList;
import java.util.Queue;

import org.json.simple.JSONObject;


public class Q {
    public Queue<JSONObject> queue = new LinkedList<JSONObject>();
    public synchronized JSONObject get(){
        return queue.poll();
    }
    public synchronized void put(JSONObject obj){
        try{
        queue.add(obj);
        }
        catch (Exception e){
            System.out.println(e);
        }
    }
    public boolean empty(){
        return queue.isEmpty();
    }
}

我已经在读取器和写入器中启动了线程，以便同时读取和写入，每当队列为空时，读取器类 waits() 以及每当写入器将元素写入队列时，我都会使用 notificationall() 来让读取器恢复，但我收到非法监视器状态异常(exception)。我在互联网上搜索过，发现每当线程尝试锁定它不拥有的监视器时就会发生这种情况，但我无法解决该问题

Answer 1

您的 Reader 和 Writer 类需要共享监视器对象。在您的示例中，Reader 将自身用作监视器，而 Writer 将自身用作监视器。

在您的情况下，您可以使用Queue q本身作为监视器，因为这是您需要同步的状态。此外，调用者需要拥有监视器，他们通常像这样获取所有权:syncronized (q) {//do stuff on q}
换句话说，wait/notify 只能在同步块(synchronized block)中调用，该同步块(synchronized block)在对象上同步。

More about wait/notify here