多个线程向一个文件写数据

你的名字 2022-05-22 11:55 125阅读 0赞

package com.bean;
    
    import java.io.File;
    import java.io.FileWriter;
    import java.io.IOException;
    /** * 多个线程向一个文件写数据 */
    public class ThreadDemo { 
        static Write write = new Write(); 
        public static void main(String[] args)
        {
            String path = "C:\\Users\\DOG\\Desktop\\aa.txt";
            String message1 = Thread.currentThread().getName()+":hello";
            String message2 = "world";
            //创建100个线程
            for(int i=0;i<100;i++){
                new Thread(new Runnable(){
                    @Override
                    public void run(){
                        write.write(path, message1,message2);
                    }
                }).start();
            }
        }
    }
    class Write
    {
        public synchronized void write(String path,String message1,String message2){
            FileWriter writer = null;
            try {
                File file = new File(path);
                writer = new FileWriter(file,true);//追加写入
                writer.write(message1);
                Thread.sleep(100);
                writer.write(message2+"\n");
            } catch (IOException | InterruptedException e) {
                e.printStackTrace();
            } finally {
                if(writer != null){
                    try {
                        writer.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }   
    }

写到文件里如下：

main:helloworld
    main:helloworld
    main:helloworld
    main:helloworld
    main:helloworld
    main:helloworld
    main:helloworld
    main:helloworld
    main:helloworld
    main:helloworld
    ...

可以看出代码是线程安全的，没有出现写乱的情况，但是把Write类的write方法上的synchronized关键字去掉，发现写入文件里也是和没去掉synchronized关键字时一样的效果，跟踪java.io.FileWriter的write方法：

public void write(String str) throws IOException {
            write(str, 0, str.length());
    }
    
    public void write(String str, int off, int len) throws IOException {
            synchronized (lock) {
                char cbuf[];
                if (len <= WRITE_BUFFER_SIZE) {
                    if (writeBuffer == null) {
                        writeBuffer = new char[WRITE_BUFFER_SIZE];
                    }
                    cbuf = writeBuffer;
                } else {    // Don't permanently allocate very large buffers.
                    cbuf = new char[len];
                }
                str.getChars(off, (off + len), cbuf, 0);
                write(cbuf, 0, len);
            }
        }

发现write方法里有synchronized代码块，锁为当前对象（lock），因为写入文件的操作只new了一个FileWriter对象（new FileWriter(file,true);），所以所有的线程竞争同一把锁，自然也就是线程安全的了，但是如果写的操作new了多个FileWriter对象，就会出现写乱的情况，因为不是竞争的同一把锁，如下：

class Write
    {
        public void write(String path,String message1,String message2){
            FileWriter writer1 = null;
            FileWriter writer2 = null;
            try {
                File file = new File(path);
                //new两个FileWriter对象
                writer1 = new FileWriter(file,true);//追加写入
                writer2 = new FileWriter(file,true);//追加写入
                writer1.write(message1);
                Thread.sleep(100);
                writer2.write(message2+"\n");
            } catch (IOException | InterruptedException e) {
                e.printStackTrace();
            } finally {
                if(writer1 != null){
                    try {
                        writer1.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(writer2 != null){
                    try {
                        writer2.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }   
    }

写到文件里如下：

main:hellomain:helloworld
    world
    main:hellomain:helloworld
    world
    main:hellomain:hellomain:helloworld
    world
    world
    main:hellomain:hellomain:hellomain:hellomain:hellomain:hellomain:hellomain:hellomain:helloworld
    world
    world
    world
    main:hellomain:hellomain:helloworld
    ...

可以发现文件写乱了，线程不安全，因为竞争的不是同一把锁对象。如果在Write类的write方法上加上synchronized关键字，可以发现写入不乱了，因为这个synchronized关键字的锁对象为main方法里的write对象（static Write write = new Write();），锁为同一把锁，线程安全。但是每个线程new一个Write对象，发现线程是不安全的，代码和结果如下：

package com.bean;
    
    import java.io.File;
    import java.io.FileWriter;
    import java.io.IOException;
    /** * 多个线程向一个文件写数据 */
    public class ThreadDemo { 
    // static Write write = new Write(); 
        public static void main(String[] args)
        {
            String path = "C:\\Users\\DOG\\Desktop\\aa.txt";
            String message1 = Thread.currentThread().getName()+":hello";
            String message2 = "world";
            //创建100个线程
            for(int i=0;i<100;i++){
                new Thread(new Runnable(){
                    @Override
                    public void run(){
                        new Write().write(path, message1,message2);
                    }
                }).start();
            }
        }
    }
    class Write
    {
        public synchronized void write(String path,String message1,String message2){
            FileWriter writer1 = null;
            FileWriter writer2 = null;
            try {
                File file = new File(path);
                //new两个FileWriter对象
                writer1 = new FileWriter(file,true);//追加写入
                writer2 = new FileWriter(file,true);//追加写入
                writer1.write(message1);
                Thread.sleep(100);
                writer2.write(message2+"\n");
            } catch (IOException | InterruptedException e) {
                e.printStackTrace();
            } finally {
                if(writer1 != null){
                    try {
                        writer1.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(writer2 != null){
                    try {
                        writer2.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }   
    }

写到文件里如下：

main:hellomain:hellomain:hellomain:hellomain:hellomain:helloworld
    world
    world
    world
    world
    world
    main:hellomain:helloworld
    world
    main:hellomain:hellomain:helloworld
    world
    main:helloworld
    world
    main:helloworld
    main:hellomain:hellomain:helloworld
    ...

因为多个线程调用Write类的write方法时，每个线程用了一个Write对象，锁对象不是同一个，线程是不安全的。