java中的synchronized和Lock

xiaoxiao2021-03-01  4

synchronized是java中的一个关键字,也就是说是Java语言内置的特性。

java.util.concurrent.locks包下常用的类

首先,我们先看一下Lock接口的API:

public interface Lock { void lock(); void lockInterruptibly() throws InterruptedException; boolean tryLock(); boolean tryLock(long time, TimeUnit unit) throws InterruptedException; void unlock(); Condition newCondition(); }

lock():该方法用来获取锁。 如下:

Lock lock = new ReentrantLock(); lock.lock(); try { System.out.println(t.getName()+"获得了锁"); } catch (InterruptedException e) { e.printStackTrace(); } finally { System.out.println(t.getName()+"释放了锁"); lock.unlock(); }

注意:在finally块中释放锁,目的是保证锁一定会被释放,防止死锁的发生。 不要将获取锁的过程写在try块中,因为如果在获取锁(自定义锁的实现)时发生了异常,异常抛出的同时,也会导致锁无故释放。

lockInterruptibly():可中断地获取锁,和lock()方法不同的是该方法会响应中断,即在锁的获取中可以中断当前线程。 如,当两个线程同时通过lock.lockInterruptibly()想获取某个锁时,假若此时线程A获取到了锁,而线程B处于等待中,对线程B调用threadB.interrupt()会中断线程B的等待过程。 注意:当一个线程获取了锁之后,是不会被interrupt()方法中断的。只能中断阻塞中的线程。

tryLock():尝试非阻塞的获取锁,调用该方法后立刻返回,如果能够获取则返回true,否则返回false。 一般如下格式:

Lock lock = new ReentrantLock(); if(lock.tryLock()) { try { System.out.println(t.getName()+"获得了锁"); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); System.out.println(t.getName()+"释放了锁"); } }else { System.out.println(t.getName()+"获得锁失败"); }

tryLock(long time, TimeUnit unit):超时的获取锁,当前线程在以下3种情况下会返回: ① 当前线程在超时时间内获得了锁 ② 当前线程在超时时间内被中断 ③ 超时时间结束,返回false

可重入锁

重入锁ReentrantLock,顾名思义,就是支持重进入的锁,它表示该锁能够支持一个线程对资源的重复加锁。除此之外,该锁还支持获取锁时的公平和非公平性选择,这里我们对公平性不细说。

其实synchronized关键字支持的锁也是重入锁,可重入性在我看来实际上表明了锁的分配机制:基于线程的分配,而不是基于方法调用的分配。比如:当一个线程执行到某个synchronized方法时,比如说method1,而在method1中会调用另外一个synchronized方法method2,此时线程不必重新去申请锁,而是可以直接执行方法method2。

class Test{ public synchronized void method1() { method2(); } public synchronized void method2() { } }

假若synchronized不具备可重入性,此时线程A在method1方法中调用method2方法时,需要重新申请锁,这就会造成一个问题,因为线程A已经持有了该对象的锁,而又在申请获取该对象的锁,这样就会线程A一直等待永远不会获取到的锁。

public class TestLock { Lock lock = new ReentrantLock(); public static void main(String[] args) { final TestLock tl = new TestLock(); new Thread() { @Override public void run() { tl.insert(Thread.currentThread()); } }.start(); new Thread() { @Override public void run() { tl.insert(Thread.currentThread()); } }.start(); } public void insert(Thread t) throws InterruptedException { lock.lock(); try { System.out.println(t.getName()+"获得了锁"); Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } finally { System.out.println(t.getName()+"释放了锁"); lock.unlock(); } } }

输出结果: Thread-0获得了锁 Thread-0释放了锁 Thread-1获得了锁 Thread-1释放了锁

public class TestLock { Lock lock = new ReentrantLock(); public static void main(String[] args) { final TestLock tl = new TestLock(); new Thread() { @Override public void run() { tl.test(Thread.currentThread()); } }.start(); new Thread() { @Override public void run() { tl.test(Thread.currentThread()); } }.start(); } public void test(Thread t) { if(lock.tryLock()) { try { System.out.println(t.getName()+"获得了锁"); Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); System.out.println(t.getName()+"释放了锁"); } }else { System.out.println(t.getName()+"获得锁失败"); } } }

输出结果: Thread-0获得了锁 Thread-1获得锁失败 Thread-0释放了锁

public class TestLock { Lock lock = new ReentrantLock(); public static void main(String[] args) { final TestLock tl = new TestLock(); Thread t1 = new Thread(new MyThread(tl)); Thread t2 = new Thread(new MyThread(tl)); t1.start(); t2.start(); t2.interrupt(); } public void insert(Thread t) throws InterruptedException { lock.lockInterruptibly();//该方法会响应中断获取锁 try { System.out.println(t.getName()+"获得了锁"); Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } finally { System.out.println(t.getName()+"释放了锁"); lock.unlock(); } } } class MyThread implements Runnable{ TestLock tl; public MyThread(TestLock tl) { this.tl = tl; } @Override public void run() { try { tl.insert(Thread.currentThread()); } catch (InterruptedException e) { System.out.println(Thread.currentThread().getName()+"被中断"); } } }

输出结果: Thread-0获得了锁 Thread-1被中断 Thread-0释放了锁

ReadWriteLock也是一个接口,它表示读写锁。里面有2个方法,一个用来获取读锁,一个用来获取写锁,ReentrantReadWriteLock是ReadWriteLock的实现类。

下面来看一下读写锁的具体用法,假如多个线程同时进行读操作,看一下synchronized的效果:

public class TestReadWriteLock { public static void main(String[] args) { final TestReadWriteLock trw = new TestReadWriteLock(); new Thread() { @Override public void run() { trw.get(Thread.currentThread()); } }.start(); new Thread() { @Override public void run() { trw.get(Thread.currentThread()); } }.start(); } public synchronized void get(Thread thread) { long start = System.currentTimeMillis(); while(System.currentTimeMillis() - start <= 1) { System.out.println(thread.getName()+"正在进行读操作"); } System.out.println(thread.getName()+"读操作完毕"); } }

输出结果: Thread-0正在进行读操作 Thread-0正在进行读操作 Thread-0正在进行读操作 … Thread-0读操作完毕 Thread-1正在进行读操作 Thread-1正在进行读操作 Thread-1正在进行读操作 … Thread-1读操作完毕

如果改成读写锁,效果如下:

public class TestReadWriteLock { ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); public static void main(String[] args) { final TestReadWriteLock trw = new TestReadWriteLock(); new Thread() { @Override public void run() { trw.get1(Thread.currentThread()); } }.start(); new Thread() { @Override public void run() { trw.get1(Thread.currentThread()); } }.start(); } public void get1(Thread thread) { lock.readLock().lock(); try { long start = System.currentTimeMillis(); while(System.currentTimeMillis() - start <= 1) { System.out.println(thread.getName()+"正在进行读操作"); } System.out.println(thread.getName()+"读操作完毕"); } finally { lock.readLock().unlock(); } } }

输出结果: Thread-0正在进行读操作 Thread-0正在进行读操作 Thread-0正在进行读操作 Thread-1正在进行读操作 … Thread-1正在进行读操作 Thread-1正在进行读操作 Thread-0正在进行读操作 Thread-1正在进行读操作 Thread-0正在进行读操作 Thread-1正在进行读操作 Thread-0正在进行读操作 Thread-1正在进行读操作 … Thread-0读操作完毕 Thread-1正在进行读操作 Thread-1读操作完毕

通过以上可以2种不同的方式可以看出,读锁是同时进行的,而synchronized每次只能允许一个锁。

通过以上总结一下Lock与synchronized的区别。 1)Lock是一个接口,而synchronized是Java中的关键字,是代码级的,synchronized是内置的语言实现,是JVM级的; 2)synchronized在发生异常时,会自动释放线程占有的锁,因此不会导致死锁现象发生;而Lock在发生异常时,如果没有主动通过unLock()去释放锁,则很可能造成死锁现象,因此使用Lock时需要在finally块中释放锁; 3)Lock可以让等待锁的线程响应中断,而synchronized却不行,使用synchronized时,等待的线程会一直等待下去,不能够响应中断; 4)通过Lock可以知道有没有成功获取锁,而synchronized却无法办到。 5)Lock可以提高多个线程进行读操作的效率。 6)Lock可以实现公平锁,synchronized只能是非公平的。

注意:与synchronized对应的Object的监视器模型上,一个对象拥有一个同步队列和等待队列,而并发包中的Lock(确切的说是同步器)拥有一个同步队列和多个等待队列。

转载请注明原文地址: https://www.6miu.com/read-3350267.html

最新回复(0)