多线程操作文件

问：Java 多线程文件读写操作怎么保证并发安全？

答：多线程文件并发安全其实就是在考察线程并发安全，最普通的方式就是使用 wait/notify、Condition、synchronized、ReentrantLock 等方式，这些方式默认都是排它操作（排他锁），也就是说默认情况下同一时刻只能有一个线程可以对文件进行操作，所以可以保证并发文件操作的安全性，但是在并发读数量远多于写数量的情况下性能却不那么好。因此推荐使用 ReadWriteLock 的实现类 ReentrantReadWriteLock，它也是 Lock 的一种实现，允许多个读线程同时访问，但不允许写线程和读线程、写线程和写线程同时访问。所以相对于排他锁来说提高了并发效率。ReentrantReadWriteLock 读写锁里面维护了两个继承自 Lock 的锁，一个用于读操作（ReadLock），一个用于写操作（WriteLock）。
自定义的读写类：

package boss.bes.basedata.myutil.reentrantReadWriteLock;

import com.google.common.io.Files;

import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @version V1.0
 * @ClassName MyReentrantReadWriteLock
 * @PackageName boss.bes.basedata.myutil.reentrantReadWriteLock
 * @Description: (用一句话描述该文件做什么)
 * @date: 2020/7/9 16:15
 * @author: lang
 */
public class MyReadWriteLockTask {
    private String fileName;
    private File file;
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public MyReadWriteLockTask(String fileName) {
        this.fileName = fileName;
        file = new File(fileName);
    }

    public List<String> read() {
        List<String> result = new ArrayList<>();
        try {
            lock.readLock().lock();
            result = Files.readLines(file, StandardCharsets.UTF_8);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
            return result;
        }
    }

    /**
     * @Description: 覆盖写
     */
    public void write(String s) {
        try {
            lock.writeLock().lock();
            Files.write(s.getBytes(), file);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }

    /**
     * @Description: 追加写
     */
    public void append(String s) {
        try {
            lock.writeLock().lock();
            Files.append(s, file, StandardCharsets.UTF_8);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }
}

测试类：

package boss.bes.basedata.myutil.reentrantReadWriteLock;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @version V1.0
 * @ClassName ReadReadTest
 * @PackageName boss.bes.basedata.myutil.reentrantReadWriteLock
 * @Description: (用一句话描述该文件做什么)
 * @date: 2020/7/9 16:14
 * @author: lang
 */
public class ReadReadTest {
    public static void main(String[] args) {
        MyReadWriteLockTask readWriteLockTask = new MyReadWriteLockTask("E:/垃圾/test.txt");
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 10, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>(2));
        poolExecutor.execute(new Runnable() {
            @Override
            public void run() {
                readWriteLockTask.write("123");
                System.out.println(Thread.currentThread().getName() + "start1");
            }
        });
        poolExecutor.execute(new Runnable() {
            @Override
            public void run() {
                readWriteLockTask.append("323");
              System.out.println(Thread.currentThread().getName() + "start2");
            }
        });
        System.out.println(readWriteLockTask.read());
    }
}

通过上面案例可以发现 ReentrantReadWriteLock 支持公平和非公平锁；还支持可重入特性，读线程在获取了读锁后还可以获取读锁，写线程在获取了写锁之后既可以再次获取写锁又可以获取读锁；此外还允许从写入锁降级为读取锁（操作方式是先获取写入锁，然后获取读取锁，最后释放写入锁），但是不允许从读取锁升级到写入锁，因为可能会出现数据不一致问题。

概念：

1. 公平锁和非公平锁概念

1.公平锁：是指多个线程按照申请锁的顺序来获取锁，类似排队打饭，先来先到。
2.非公平锁：是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，在高并发的情况下，有可能会造成优先级反转或者饥饿现象。非公平锁的优点在于吞吐量比公平锁大

2. 公平锁和非公平锁区别

1.公平锁：Threads acquire a fair lock in which they requested
2.公平锁：就是很公平，在并发坏境中．每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个，就占有锁．否则就会加入到等待队列中．以后会按照FIFO的规则从队列中取到自己。
3.非公平锁：a nonfair lock permis barging:threads requesting a lock can jump ahead of the queue of waiting threads if the lock
happens to be available when it is requested.
4.非公平锁比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁那种方式。

4. ReentrantLock和synchronized是公平锁还是非公平锁？

Java ReentrantLock 而言，通过构造函数指定该锁是否为公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。源码如下

 Lock lock = new ReentrantLock();

公平锁设置如下：
当我们传入true参数后，源码为

Lock lock = new ReentrantLock(true);

1、可重入锁（也叫递归锁）：指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁，也即是说，线程可以进入任何一个它己经拥有的锁所同步着的代码块。

lock：获取一个锁。

lockInterruptibly：可中断的获取锁。

tryLock：阻塞式获取锁，没有获取就一直等待，直到成功。

tryLock(long timeout, TimeUnit unit)：获取一个锁，在指定的时间内获取。

unlock：释放一个锁。

其实对于ReentrantReadWriteLock的使用还是比较常见的，比如说缓存机制中。感谢大家支持。