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文件从文件写入队列和类读取器，它从队列中读取并打印对象并从队列中删除它们

以下是作家类

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;
    }

}

以下是读者类

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();
    }
}

我已经在读取器和写入器中启动了线程，用于同时读取和写入，并且每当队列为空时读取器类等待（）并且每当写入器将元素写入队列时，我都会使用notifyall（）让读者恢复但我得到非法的监视器状态例外。我已经搜索了互联网，发现只要线程试图锁定它不拥有的监视器，但我无法解决问题，就会发生这种情况

Answer 1

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

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

More about wait/notify here

Answer 2

您获得该异常是因为不在监视器中。

public class User {
    public static final Object lock = new Object();

    ...

    synchronized(User.lock) {
        while(q.empty()){
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

public class Writer implements Runnable {
    ...
        for(JSONObject ob1 : jsons){
            q.put(ob1);
            synchronized(User.lock) {
                notifyAll();
            }
     //     System.out.println(q.queue.poll());
        }

请注意我暂时没有使用synchronized和这样的并发，所以我不确定这是否完全是线程安全的。

主要是因为如果你最终得到

synchronized(lock) {
    synchronized(Q) {

和

synchronized(Q) {
    synchronized(lock) {

然后你会在某个时候陷入僵局，你的应用程序将会冻结。这就是为什么我个人对synchronized方法持谨慎态度。

非法监视器状态异常java

2 个答案: