什么是java线程同步

Java  /  管理员 发布于 8年前   169

线程同步

多线程之间调用同一对象时，为了运行的安全和准确性，需要对该对象进行同步，确保每一个线程用到的时候该对象的结果都是正确的，该对象的状态都是合理的，这部分涉及到同步、线程锁等知识点。这部分的只是就涉及到了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  卖出了一张票,剩余：1Process 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<Thread> 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号窗口买票时没票了000Process 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号窗口买票时没票了000Process 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号窗口买票时没票了000Process 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线程同步的详细内容，更多请关注其它相关文章！