Write data into text file with multiple threads (simultaneously, in different lines of file)

Create k threads that simultaneously write characters into the same file:

• the first thread writes a digit 0 exactly 20 times on the first line of the file;
• the second thread writes a digit 1 exactly 20 times on the second line of the file;
  >...
• the tenth thread writes a digit 9 exactly 20 times on the tenth line of the file;

Requirements to the implementation.

1. It is required to set a 1 millisecond pause for writing of each digit.

2. Use the RandomAccessFile for writing data to the file.

3. You can use not more than one object of the RandomAccessFile class!

I wrote something like this:

import java.io.IOException;
import java.io.RandomAccessFile;
public class Part5 {
// creates string before writing to the file
public static String createString(int integer){
StringBuilder result = new StringBuilder("");
for(int i = 0; i < 20; i++){
result.append(integer);
}
result.append("\n");
return result.toString();
}
// writes string into the file
public static void writeString(String st) {
try(RandomAccessFile file = new RandomAccessFile("part5.txt", "rw")){
st+="\n";
file.write(st.getBytes());
}catch(IOException ex){
ex.getMessage();
}
}
// starts writing threads
public static void startThread(int number){
Thread thread = new Thread(){
@Override
public void run() {
synchronized (this){
writeString(createString(number));
}
}
};
thread.start();
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(final String[] args) {
for(int i = 0; i < 9; i++){
startThread(i);
}
}
}

My implementation only rewrites first line of the file, but should write something like this:

00000000000000000000
11111111111111111111 
22222222222222222222 
33333333333333333333 
44444444444444444444 
55555555555555555555 
66666666666666666666 
77777777777777777777 
88888888888888888888 
99999999999999999999

How can I fix my "concurrency part" of code to make it work correctly?
Thank you in advance!

When you write to file, you need to move the pointer to the correct position. You need to call "seek" method in RandomAccessFile and then move the pointer by number of bytes. For example first thread will seek to 0, second will seek to 21 and so on.

The way your program is right now, every thread will overwrite every other thread.

There may also be a problem with parallelization.

I didn't want to give a ready made solution, but I got curious. So here's something you could learn from

import java.io.IOException;
import java.io.RandomAccessFile;
public class Blah {
// creates string before writing to the file
public static String createString(int integer){
StringBuilder result = new StringBuilder("");
for(int i = 0; i < 20; i++){
result.append(integer);
}
result.append("\n");
return result.toString();
}
public static void main(final String[] args) throws IOException {
RandomAccessFile file = new RandomAccessFile("part5.txt", "rw");
Blah blah = new Blah();
for(int i = 0; i <= 9; i++){
Thread thread = new Thread(blah.new NumberWriter(i, file));
thread.start();
}
file.close();
}
private class NumberWriter implements Runnable {
int number;
RandomAccessFile file;
public NumberWriter(int number, RandomAccessFile file) {
this.number = number;
this.file = file;
}
public void run() {
try {
int seek = this.number * 20 + number;
System.out.println("number is  : " + number + " : seeking to : " + seek);
file.seek(seek);
file.write((createString(this.number)).getBytes());
} catch (IOException ioex) {
ioex.printStackTrace();
}
}
}
}
</details>