Thread: Handling IO Synchronization

I have a class (WriteExcel) which writes to an excel file. For those who don't know, Excel doesn't handle multiple access well (or at all).
I then have another class (WriteManager) which creates a new thread for each write command, and then calls a method from the WriteExcel class.
Other classes in my project calls methods from WriteManager to send their requests.
My situation looks like this:
1) Thread 1: Someclass -> WriteManager.write1stPage(write) -> Creates Thread 2 -> WriteExcel.write1stPage(write) -> Start Excel Write
2) Thread 1: Someclass -> WriteManager.write2ndPage(write) -> Creates Thread 3 -> WriteExcel.write2ndPage(write) -> Start Excel Write
3) Thread 1: Someclass -> WriteManager.write3rdPage(write) -> Creates Thread 4 -> WriteExcel.write3rdPage(write) -> Start Excel Write
4) Thread 2: Finished writing and ready to save -> Throws exception due to multiple Excel access
5) Thread 3: Finished writing and ready to save -> Throws exception due to multiple Excel access
6) Thread 4: Finished writing and ready to save -> Throws exception due to multiple Excel access

I need to figure out a way to restrict access to WriteExcel until the writing is finished. So I need something like this:
1) Thread 1: Someclass -> WriteManager.write1stPage(write) -> Creates Thread 2 -> WriteExcel.write1stPage(write) -> Start Excel Write
2) Thread 1: Someclass -> WriteManager.write2ndPage(write) -> Creates Thread 3 -> Waits Until WriteExcel is free
3) Thread 1: Someclass -> WriteManager.write3rdPage(write) -> Creates Thread 4 -> Waits Until WriteExcel is free
4) Thread 2: Finished writing and ready to save -> Saves and frees WriteExcel
5) Thread 3: WriteExcel is free -> WriteExcel.write2ndPage(write) -> Start Excel Write
6) Thread 3: Finished writing and ready to save -> Saves and frees WriteExcel
7) Thread 4: WriteExcel is free -> WriteExcel.write3rdPage(write) -> Start Excel Write
8) Thread 4: Finished writing and ready to save -> Saves and frees WriteExcel

What is currently the best approach in java for handling this sort of situation?

I'm unclear of the need for Thread's 2-4. But be that as it may, if you need to write to the file asynchronous relative to Thread 1, you might consider using a queue - for instance create a thread pool of size 1 using Executors...in this manner only one write will occur at any given time and they will occur sequentially

The other threads were being created because I had no way of really monitoring when certain write requests were sent, and each write request needed to run on a thread other than the one which called it.

I actually managed to come up with a somewhat elegant approach. Instead of multiple threads, I created a single writing thread. The writing thread contains a queue of requests, which it cycles through. When the queue runs out, the thread tells itself to wait. When a new request is added to the queue, the thread is told to continue on. This way I don't have the thread looping continuously in the background for no reason.

Tell me what you think about this. I've ran it a few times with perfect success, but that doesn't mean there isn't something serious I've overlooked. This does require a class: WriteRequest, which just contains a type and a payload to pass onto the excel writer.

public class ServiceManager {
    private WriteDatabaseThread writeDatabaseThread;
 
    public void addRequest(WriteRequest request) {
        this.writeDatabaseThread.requests.add(request);
        synchronized (this.writeDatabaseThread) {
            this.writeDatabaseThread.notifyAll();
        }
    }
 
    public void setWriteDatabaseInterface(WriteDatabaseInterface databaseInterface) {
        this.writeDatabaseThread = new WriteDatabaseThread(databaseInterface);
        this.writeDatabaseThread.start();
    }
 
    public void write1stPage(...) {
        if (this.writeDatabaseThread == null) {
            return;
        }
        this.addRequest(new WriteRequest(TYPE_ONE,...));
    }
 
	public void write2ndPage(...) {
		if (this.writeDatabaseThread == null) {
            return;
        }
        this.addRequest(new WriteRequest(TYPE_TWO,...));
	}
	...
}

public class WriteDatabaseThread extends Thread {
    public volatile Queue<WriteRequest> requests = new LinkedList<>();
    private WriteDatabaseInterface writeDatabaseInterface;
 
    public WriteDatabaseThread(WriteDatabaseInterface writeDatabaseInterface) {
        this.writeDatabaseInterface = writeDatabaseInterface;
    }
 
    @Override
    public void run() {
        while (true) {
            try {
                if (this.requests.size() == 0) {
                    synchronized (this) {
                        this.wait();
                    }
                }
                WriteRequest request = this.requests.poll();
                if (request != null) {
                    ... payload = request.getPayload();
                    switch (request.getType()) {
                        case TYPE_ONE: {
                            this.writeDatabaseInterface.write1st(...);
                            break;
                        }
                        case TYPE_TWO: {
                            this.writeDatabaseInterface.write2nd(...);
                            break;
                        }
                        ...
                    }
                }
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }
}

Would the ConcurrentLinkedQueue collection resolve that issue? ConcurrentLinkedQueue (Java Platform SE 7 )