java中的线程同步是什么？相信大部分人都不太了解，今天小编为了让大家更加了解线程同步，给大家总结了以下内容，跟随小编一起来看看吧。

在成都做网站、成都网站设计过程中，需要针对客户的行业特点、产品特性、目标受众和市场情况进行定位分析，以确定网站的风格、色彩、版式、交互等方面的设计方向。成都创新互联公司还需要根据客户的需求进行功能模块的开发和设计，包括内容管理、前台展示、用户权限管理、数据统计和安全保护等功能。

线程同步

多线程之间调用同一对象时，为了运行的安全和准确性，需要对该对象进行同步，确保每一个线程用到的时候该对象的结果都是正确的，该对象的状态都是合理的，这部分涉及到同步、线程锁等知识点。这部分的只是就涉及到了synchronized、同步锁（Lock）的概念。

synchronized

synchronized关键词可以修饰对象、方法，通常用法如下：

//同步代码块
synchronized（Object object）{
...
}
//或者
//同步方法
public synchronized void test(){
...
}

其中有一个同步监视器的概念，比如上面同步代码块的object对象以及同步方法的this对象就会同步监视，多个线程同时调用一个同步的代码块或者方法时，在任何时刻只能够一个线程能够获得该同步监视的对象锁，执行完代码之后才会释放该锁，在此期间其他调用的线程只能等待该锁被释放后才能调用。

上文中提到的SellRunnable类中的sell方法也用到了synchronized，上文中代码执行太快，所以感知不到，如果修改一下就能明白有没有synchronized的区别了。

public class ThreadTest {
    public static void main(String[] args) {
        SellRunnable sellRunnable = new SellRunnable();
        Thread thread1 = new Thread(sellRunnable, "1");
        Thread thread2 = new Thread(sellRunnable, "2");
        Thread thread3 = new Thread(sellRunnable, "3");
        thread2.start();
        thread1.start();
        thread3.start();
    }
}
class SellRunnable implements Runnable {
    //有十张票
    int index = 10;
    public void sell() {
        if (index >= 1) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            index--;
            System.out.println("售货窗口：" + Thread.currentThread().getName() + 
            " 卖出了一张票,剩余：
            " + index);
        } else {
            System.out.println("售货窗口：" + Thread.currentThread().getName() + " 买票时没票了");
        }
    }
    @Override
    public void run() {
        while (index > 0) {
            System.out.println("售货窗口：" + Thread.currentThread().getName() + " 开始买票");
            sell();
        }
    }
}
//执行结果：
售货窗口：1 开始买票
售货窗口：2 开始买票
售货窗口：3 开始买票
售货窗口：2  卖出了一张票,剩余：9
售货窗口：2 开始买票
售货窗口：1  卖出了一张票,剩余：9
售货窗口：1 开始买票
售货窗口：3  卖出了一张票,剩余：8
售货窗口：3 开始买票
售货窗口：1  卖出了一张票,剩余：6
售货窗口：1 开始买票
售货窗口：2  卖出了一张票,剩余：6
售货窗口：2 开始买票
售货窗口：3  卖出了一张票,剩余：5
售货窗口：3 开始买票
售货窗口：1  卖出了一张票,剩余：4
售货窗口：1 开始买票
售货窗口：2  卖出了一张票,剩余：3
售货窗口：3  卖出了一张票,剩余：2
售货窗口：3 开始买票
售货窗口：2 开始买票
售货窗口：3  卖出了一张票,剩余：1
售货窗口：2  卖出了一张票,剩余：0
售货窗口：1  卖出了一张票,剩余：1
Process finished with exit code 0  //可以看到，票数减少是错误的
//sell方法添加synchronized修饰符后 执行结果：
public synchronized void sell() {
        if (index >= 1) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            index--;
            System.out.println("售货窗口：" + Thread.currentThread().getName() + 
            " 卖出了一张票,剩余：
            " + index);
        } else {
            System.out.println("售货窗口：" + Thread.currentThread().getName() + " 买票时没票了");
        }
    }
售货窗口：2 开始买票
售货窗口：3 开始买票
售货窗口：1 开始买票
售货窗口：2  卖出了一张票,剩余：9
售货窗口：2 开始买票
售货窗口：1  卖出了一张票,剩余：8
售货窗口：1 开始买票
售货窗口：3  卖出了一张票,剩余：7
售货窗口：3 开始买票
售货窗口：1  卖出了一张票,剩余：6
售货窗口：1 开始买票
售货窗口：2  卖出了一张票,剩余：5
售货窗口：2 开始买票
售货窗口：1  卖出了一张票,剩余：4
售货窗口：1 开始买票
售货窗口：1  卖出了一张票,剩余：3
售货窗口：1 开始买票
售货窗口：3  卖出了一张票,剩余：2
售货窗口：3 开始买票
售货窗口：1  卖出了一张票,剩余：1
售货窗口：1 开始买票
售货窗口：1  卖出了一张票,剩余：0
售货窗口：2 买票时没票了
售货窗口：3 买票时没票了
Process finished with exit code 0  // 可以看到，票数是正常减少的

以上对于sell方法进行同步之后，在某一瞬间，只会有一个线程调用该方法，所以里面判断index的时候得到的结果就是正确的结果。

以上同步的时候，是以降低运行效率的方式来保证线程安全的，为此，不要对线程使用类中没必要的方法、对象进行同步标识，只对有竞争的资源或者代码进行同步标识。

同步标识后，有以下几点可以释放该锁：

代码块、方法执行完毕（正常完毕、return或break、抛出异常）

调用了wait方法，使得当前线程暂停。

当线程执行到同步代码块时，sleep、yield方法不会释放该同步锁，挂起方法suspend也不会（线程操作过程中尽量避免使用suspend、resume来操作线程状态，容易导致死锁。）

同步锁Lock

上文中提到的synchronized是java中的一个关键词，也提到了在sleep的时候、进行IO操作的时候该线程不会释放线程锁，其他线程就需要一直等待，这样有时会降低执行的效率，所以就需要一个可以在线程阻塞时可以释放线程锁的替代方案，Lock就是为了解决这个问题出现的。

Lock是一个java中的类，在java.util.concurrent.locks包中，具体的代码如下：

public interface Lock {
    void lock();//加锁
    void lockInterruptibly() throws InterruptedException;//加锁
    boolean tryLock();//加锁
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;//加锁
    void unlock();//释放锁
    Condition newCondition();//线程协作中用到
}

Lock接口的一个实现子类为ReentrantLock，在java.util.concurrent.locks包下，ReentrantLock的源代码如下：

public class ReentrantLock implements Lock, Serializable {
    private static final long serialVersionUID = 7373984872572414699L;
    private final ReentrantLock.Sync sync;
    public ReentrantLock() {
        this.sync = new ReentrantLock.NonfairSync();
    }
    public ReentrantLock(boolean var1) {//是否创建公平锁
        this.sync = (ReentrantLock.Sync)(var1?new ReentrantLock.FairSync():new  ReentrantLock.
        NonfairSync());
    }
    public void lock() {
        this.sync.lock();
    }
    public void lockInterruptibly() throws InterruptedException {
        this.sync.acquireInterruptibly(1);
    }
    public boolean tryLock() {
        return this.sync.nonfairTryAcquire(1);
    }
    public boolean tryLock(long var1, TimeUnit var3) throws InterruptedException {
        return this.sync.tryAcquireNanos(1, var3.toNanos(var1));
    }
    public void unlock() {
        this.sync.release(1);
    }
    public Condition newCondition() {
        return this.sync.newCondition();
    }
    public int getHoldCount() {//当前线程持有该锁的数量
        return this.sync.getHoldCount();
    }
    public boolean isHeldByCurrentThread() {//该锁是否被当前线程持有
        return this.sync.isHeldExclusively();
    }
    public boolean isLocked() {//是否被其他线程持有该锁
        return this.sync.isLocked();
    }
    public final boolean isFair() {//是否是公平锁
        return this.sync instanceof ReentrantLock.FairSync;
    }
    protected Thread getOwner() {//当前锁的持有线程
        return this.sync.getOwner();
    }
    public final boolean hasQueuedThreads() {//是否有线程在等待该锁
        return this.sync.hasQueuedThreads();
    }
    public final boolean hasQueuedThread(Thread var1) {//目标线程是否在等待该锁
        return this.sync.isQueued(var1);
    }
    public final int getQueueLength() {//等待该锁线程的数量
        return this.sync.getQueueLength();
    }
    protected Collection getQueuedThreads() {//获取所有等待该锁的线程集合
        return this.sync.getQueuedThreads();
    }
    ...
    
}

Lock的使用方法

lock

lock() 用来获取锁，如果该锁被其他线程占用，则进入等待。

public class LockTest {
    public static void main(String[] args) {
        com.test.java.SellRunnable sellRunnable = new com.test.java.SellRunnable();
        Thread thread1 = new Thread(sellRunnable, "1号窗口");
        Thread thread2 = new Thread(sellRunnable, "2号窗口");
        Thread thread3 = new Thread(sellRunnable, "3号窗口");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

public class SellRunnable implements Runnable {
    //有十张票
    int index = 10;
    Lock lock = new ReentrantLock();
    public void sell() {
        try {
            lock.lock();
            System.out.println("售货柜台：" + Thread.currentThread().getName() + 
            "获取了票源+++++");
            if (index >= 1) {
                index--;
                System.out.println("售货柜台：" + Thread.currentThread().getName() + 
                "卖出了一张票,剩余：
                " + index);
            } else {
                System.out.println("售货柜台：" + Thread.currentThread().getName() + 
                "买票时没票了000");
            }
        } finally {
            lock.unlock();
        }
    }
    @Override
    public void run() {
        while (index > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            sell();
        }
    }
}

运行结果：

售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：9
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：8
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：7
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：6
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：5
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：4
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：3
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：2
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：1
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：0
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口买票时没票了000
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口买票时没票了000
Process finished with exit code 0  //每一个窗口都随机获取票源、然后卖出票

tryLock

tryLock()尝试获取锁，如果获取成功返回true，如果失败，则返回false，不会进入等待状态。

public class SellRunnable implements Runnable {
    //有十张票
    int index = 10;
    Lock lock = new ReentrantLock();
    public void sell() {
        if (lock.tryLock()) {
            try {
                System.out.println("售货柜台：" + Thread.currentThread().getName() + 
                "获取了票源+++++");
                if (index >= 1) {
                    index--;
                    System.out.println("售货柜台：" + Thread.currentThread().getName() + 
                    "卖出了一张票,剩余：" + index);
                } else {
                    System.out.println("售货柜台：" + Thread.currentThread().getName() + 
                    "买票时没票了000");
                }
            } finally {
                lock.unlock();
            }
        } else {
           System.out.println("售货柜台：" + Thread.currentThread().getName()+"没有获取票源！！！");
        }
    }
    @Override
    public void run() {
        while (index > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            sell();
        }
    }
}

运行结果：

售货柜台：1号窗口获取了票源+++++
售货柜台：3号窗口没有获取票源！！！
售货柜台：2号窗口没有获取票源！！！
售货柜台：1号窗口卖出了一张票,剩余：9
售货柜台：2号窗口没有获取票源！！！
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：8
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：7
售货柜台：1号窗口没有获取票源！！！
售货柜台：3号窗口没有获取票源！！！
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：6
售货柜台：1号窗口获取了票源+++++
售货柜台：2号窗口没有获取票源！！！
售货柜台：3号窗口没有获取票源！！！
售货柜台：1号窗口卖出了一张票,剩余：5
售货柜台：2号窗口获取了票源+++++
售货柜台：1号窗口没有获取票源！！！
售货柜台：2号窗口卖出了一张票,剩余：4
售货柜台：3号窗口没有获取票源！！！
售货柜台：1号窗口获取了票源+++++
售货柜台：2号窗口没有获取票源！！！
售货柜台：3号窗口没有获取票源！！！
售货柜台：1号窗口卖出了一张票,剩余：3
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：2
售货柜台：2号窗口获取了票源+++++
售货柜台：3号窗口没有获取票源！！！
售货柜台：2号窗口卖出了一张票,剩余：1
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：0
售货柜台：3号窗口没有获取票源！！！
售货柜台：2号窗口没有获取票源！！！
Process finished with exit code 0//没有获取到货源的票口，就直接没有等待，进入下次买票

tryLock(long time, TimeUnit unit)

tryLock(long time, TimeUnit unit)可以设置拿不到锁的时候等待一段时间。//第一个参数时常长，第二个参数时间单位

public class SellRunnable implements Runnable {
    //有十张票
    int index = 10;
    Lock lock = new ReentrantLock();
    public void sell() {
        try {
            if (lock.tryLock(1000, TimeUnit.MILLISECONDS)) {
                try {
                    System.out.println("售货柜台：" + Thread.currentThread().getName() + 
                    "获取了票源+++++");
                    if (index >= 1) {
                        index--;
                        System.out.println("售货柜台：" + Thread.currentThread().getName()
                         +"卖出了一张票,剩余：" + index);
                    } else {
                        System.out.println("售货柜台：" + Thread.currentThread().
                        getName()  + "买票时没票了000");
                    }
                    try {
                        Thread.sleep(2000);//人为加入买票时间
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } finally {
                    lock.unlock();
                }
            } else {
                System.out.println("售货柜台：" + Thread.currentThread().getName() + 
                "没有获取票源！！！");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        while (index > 0) {
            try {
                Thread.sleep(500);//要不执行太快，看不出效果
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            sell();
        }
    }
}

执行结果：

售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：9
售货柜台：2号窗口没有获取票源！！！
售货柜台：3号窗口没有获取票源！！！
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：8
售货柜台：3号窗口没有获取票源！！！
售货柜台：1号窗口没有获取票源！！！
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：7
售货柜台：1号窗口没有获取票源！！！
售货柜台：2号窗口没有获取票源！！！
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：6
售货柜台：2号窗口没有获取票源！！！
售货柜台：3号窗口没有获取票源！！！
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：5
售货柜台：3号窗口没有获取票源！！！
售货柜台：1号窗口没有获取票源！！！
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：4
售货柜台：1号窗口没有获取票源！！！
售货柜台：2号窗口没有获取票源！！！
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：3
售货柜台：2号窗口没有获取票源！！！
售货柜台：3号窗口没有获取票源！！！
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：2
售货柜台：3号窗口没有获取票源！！！
售货柜台：1号窗口没有获取票源！！！
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：1
售货柜台：1号窗口没有获取票源！！！
售货柜台：2号窗口没有获取票源！！！
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：0
售货柜台：2号窗口没有获取票源！！！
售货柜台：3号窗口没有获取票源！！！
Process finished with exit code 0 //当买票时间大约等待时间时，则没有获取票源的窗口不买票，进入下个买票机会

将买票时间缩短：

try {
    Thread.sleep(500);//人为加入买票时间
} catch (InterruptedException e) {
    e.printStackTrace();
}

执行结果：

售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：9
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：8
售货柜台：3号窗口没有获取票源！！！
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：7
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：6
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：5
售货柜台：3号窗口没有获取票源！！！
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：4
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：3
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：2
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：1
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：0
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口买票时没票了000
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口买票时没票了000
Process finished with exit code 0 //等待时间内获取到票源了，也就卖出票了

lockInterruptibly

lockInterruptibly()通过该方法获取锁时，如果该锁正在被其他线程持有，则进入等待状态，但是这个等待过程是可以被中断的，通过调用Thread对象的interrupt方法就可中断等待，中断时抛出异常InterruptedException，需要捕获或者声明抛出。

public class ThreadTest {
    public static void main(String[] args) {
        SellRunnable sellRunnable = new SellRunnable();
        Thread thread1 = new Thread(sellRunnable, "1号窗口");
        Thread thread2 = new Thread(sellRunnable, "2号窗口");
        Thread thread3 = new Thread(sellRunnable, "3号窗口");
        thread1.start();
        try {
            Thread.sleep(500);//确保窗口1号先获取锁
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.start();
        thread3.start();
        try {
            Thread.sleep(2000);//等待两秒后，打断窗口2、3的等待
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.interrupt();
        thread3.interrupt();
    }
}
SellRunnable中等待时间加长：
try {
    Thread.sleep(5000);//人为加入买票时间
} catch (InterruptedException e) {
    e.printStackTrace();
}

执行结果：

售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：9
售货柜台：3号窗口被打断了      //这个地方被打断了
售货柜台：2号窗口被打断了      //这个地方被打断了
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：8
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：7
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：6
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：5
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：4
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：3
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口卖出了一张票,剩余：2
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口卖出了一张票,剩余：1
售货柜台：1号窗口获取了票源+++++
售货柜台：1号窗口卖出了一张票,剩余：0
售货柜台：2号窗口获取了票源+++++
售货柜台：2号窗口买票时没票了000
售货柜台：3号窗口获取了票源+++++
售货柜台：3号窗口买票时没票了000
Process finished with exit code 0

synchronized和Lock对比

通过以上代码，可以看出Lock和synchronized的几点关联和区别：

两者都是可重入锁

可重入锁是指当一个线程获得对象锁之后，该线程可以再次获取该对象的锁而不被阻塞。比如同一个类中有多个方法（或一个方法递归调用）被synchronized修饰或者被Lock加持后，同一个线程在调用这两个方法时都可以获取该对象的锁而不被阻塞。

不可重入锁的示例：

public class Lock{
    private boolean isLocked = false;
    public void lock(){
        while(isLocked){    
            wait();
        }
        isLocked = true;
    }
    public void unlock(){
        isLocked = false;
        notify();
    }
}
//使用方法：
public class Test{
    Lock lock = new Lock();
    public void test1(){
        lock.lock();
        test2();
        lock.unlock();
    }
    public void test2(){
        lock.lock();
        ...
        lock.unlock();
    }
}

Test类在调用test1方法的时候，执行完lock.lock()后调用test2的时候，就会一直等待，变成死锁。

可重入锁设计原理：

public class Lock{
    private boolean isLocked = false;
    private Thread lockedThread = null;
    int lockedCount = 0;
    public void lock(){
        Thread thread = Thread.currentThread();
        while(isLocked && thread != lockedThread){    
            wait();
        }
        isLocked = true;
        lockedCount++;
        lockedThread = thread;
    }
    public void unlock(){
        Thread thread = Thread.currentThread();
        if(thread == lockedThread){    
            lockedCount--;
            if(lockedCount == 0){
                isLocked = false;
                lockedThread = null;
                notify();
            }
        }
    }
}

这样调用Test类的test1方法后，test2方法也能顺利被执行。

synchronized在实现上也基本上是采用记数器的方式来实现可重入的。

Lock是可中断锁，synchronized不可中断。

当一个线程B执行被锁的对象的代码时，发现线程A已经持有该锁，那么线程B就会进入等待，但是synchronized就无法中断该等待过程，而Lock就可以通过lockInterruptibly方法抛出异常从而中断等待，去处理别的事情。

Lock可创建公平锁，synchronized是非公平锁。

公平锁的意思是按照请求的顺序来获取锁，不平公锁就无法保证线程获取锁的先后次序。

Lock可以知道是否获取到锁，synchronized不可以。

synchronized在发生异常或者运行完毕，会自动释放线程占有的锁。而Lock需要主动释放锁，否则会锁死；

synchronized在阻塞时，别的线程无法获取锁，Lock可以（这也是lock设计的一个目的）。

读写锁

多个线程对同一个文件进行写操作时，会发生冲突所以需要加锁，但是对同一个文件进行读操作的时候，使用上面的方法会造成效率的降低，所以基于这种情况，产生了ReadWriteLock这个接口：

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading.
     */
    Lock readLock();//读的锁
 
    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing.
     */
    Lock writeLock();//写的锁
}

这个接口的实现类是ReentrantReadWriteLock，其源代码如下：

public class ReentrantReadWriteLock implements ReadWriteLock, Serializable {
    private static final long serialVersionUID = -6992448646407690164L;
    private final ReentrantReadWriteLock.ReadLock readerLock;
    private final ReentrantReadWriteLock.WriteLock writerLock;
    ...
    public ReentrantReadWriteLock.WriteLock writeLock() {//获取write lock
        return this.writerLock;
    }
    public ReentrantReadWriteLock.ReadLock readLock() {//获取read lock
        return this.readerLock;
    }
    ...
}

使用方法和Lock一样，使用到write时调用writeLock()方法获取lock进行加锁，使用到read时调用readLock()方法进行加锁，需要注意的知识点如下：

线程A占用写锁，线程B在申请写、读的时候需要等待。

线程A占用读锁，线程B在申请写操作时，需要等待。

线程A占用读锁，线程B获取读操作时可以获取到。

总结

如果需要效率提升，则建议使用Lock，如果效率要求不高，则synchronized满足使用条件，业务逻辑写起来也简单，不需要手动释放锁。

创新互联，有大量免费的JAVA入门教程，欢迎大家学习！

看完上述内容，你们对java中的线程同步有进一步的了解吗？如果还想了解更多相关内容，欢迎关注创新互联行业资讯频道，感谢各位的阅读。

标题名称：java中的线程同步是什么
链接分享：http://chengdu.cdxwcx.cn/article/jeisph.html