精华内容
下载资源
问答
  • synchronized Lock

    2016-06-14 23:07:17
    synchronized Lock
    java中使用锁的两个基本工具是 synchronized 和 Lock。
    
     
    一直很喜欢synchronized,因为使用它很方便。比如,需要对一个方法进行同步,那么只需在方法的签名添加一个synchronized关键字。
     
    // 未同步的方法
    public void test() {}
    // 同步的方法
    pubilc synchronized void test() {}
     
    synchronized 也可以用在一个代码块上,看
     
    public void test() {
         synchronized(obj) {
              System.out.println("===");
         }
    }
     
    synchronized 用在方法和代码块上有什么区别呢?
     
    synchronized 用在方法签名上(以test为例),当某个线程调用此方法时,会获取该实例的对象锁,方法未结束之前,其他线程只能去等待。当这个方法执行完时,才会释放对象锁。其他线程才有机会去抢占这把锁,去执行方法test,但是发生这一切的基础应当是所有线程使用的同一个对象实例,才能实现互斥的现象。否则synchronized关键字将失去意义。
     
    但是如果该方法为类方法,即其修饰符为static,那么synchronized 意味着某个调用此方法的线程当前会拥有该类的锁,只要该线程持续在当前方法内运行,其他线程依然无法获得方法的使用权!
     
    synchronized 用在代码块的使用方式:synchronized(obj){//todo code here}
     
    当线程运行到该代码块内,就会拥有obj对象的对象锁,如果多个线程共享同一个Object对象,那么此时就会形成互斥!特别的,当obj == this时,表示当前调用该方法的实例对象。即
     
    public void test() {
         ...
         synchronized(this) {
              // todo your code
         }
         ...
    }
     
    此时,其效果等同于
    public synchronized void test() {
         // todo your code
    }
     
     
    使用synchronized代码块,可以只对需要同步的代码进行同步,这样可以大大的提高效率。
     
    小结:
    使用synchronized 代码块相比方法有两点优势:
    1、可以只对需要同步的使用
    2、与wait()/notify()/nitifyAll()一起使用时,比较方便
     
    ----------------------------------------------------------------------------------------------------------------------------------------------------------
     
    wait() 与notify()/notifyAll()
     
    这三个方法都是Object的方法,并不是线程的方法!
    wait():释放占有的对象锁,线程进入等待池,释放cpu,而其他正在等待的线程即可抢占此锁,获得锁的线程即可运行程序。而sleep()不同的是,线程调用此方法后,会休眠一段时间,休眠期间,会暂时释放cpu,但并不释放对象锁。也就是说,在休眠期间,其他线程依然无法进入此代码内部。休眠结束,线程重新获得cpu,执行代码。wait()和sleep()最大的不同在于wait()会释放对象锁,而sleep()不会!
     
    notify(): 该方法会唤醒因为调用对象的wait()而等待的线程,其实就是对对象锁的唤醒,从而使得wait()的线程可以有机会获取对象锁。调用notify()后,并不会立即释放锁,而是继续执行当前代码,直到synchronized中的代码全部执行完毕,才会释放对象锁。JVM则会在等待的线程中调度一个线程去获得对象锁,执行代码。需要注意的是,wait()和notify()必须在synchronized代码块中调用
     
    notifyAll()则是唤醒所有等待的线程。
     
    为了说明这一点,举例如下:
    两个线程依次打印"A""B",总共打印10次。
     
    public class Consumer implements Runnable {
     
         @Override
         public synchronized void run() {
                // TODO Auto-generated method stub
                int count = 10;
                while(count > 0) {
                     synchronized (Test. obj) {
                         
                         System. out.print( "B");
                         count --;
                         Test. obj.notify(); // 主动释放对象锁
                         
                          try {
                               Test. obj.wait();
                               
                         } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                               e.printStackTrace();
                         }
                    }
                    
               }
         }
    }
     
    public class Produce implements Runnable {
     
         @Override
         public void run() {
                // TODO Auto-generated method stub
                int count = 10;
                while(count > 0) {
                     synchronized (Test. obj) {
                         
                          //System.out.print("count = " + count);
                         System. out.print( "A");
                         count --;
                         Test. obj.notify();
                         
                          try {
                               Test. obj.wait();
                         } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                               e.printStackTrace();
                         }
                    }
                    
               }
     
         }
     
    }
     
    测试类如下:
     
    public class Test {
     
         public static final Object obj = new Object();
         
         public static void main(String[] args) {
               
                new Thread( new Produce()).start();
                new Thread( new Consumer()).start();
               
         }
    }
     
    这里使用static obj作为锁的对象,当线程Produce启动时(假如Produce首先获得锁,则Consumer会等待),打印“A”后,会先主动释放锁,然后阻塞自己。Consumer获得对象锁,打印“B”,然后释放锁,阻塞自己,那么Produce又会获得锁,然后...一直循环下去,直到count = 0.这样,使用Synchronized和wait()以及notify()就可以达到线程同步的目的。
     
    ----------------------------------------------------------------------------------------------------------------------------------------------------------
     
    除了wait()和notify()协作完成线程同步之外,使用Lock也可以完成同样的目的。
     
    ReentrantLock 与synchronized有相同的并发性和内存语义,还包含了中断锁等候和定时锁等候,意味着线程A如果先获得了对象obj的锁,那么线程B可以在等待指定时间内依然无法获取锁,那么就会自动放弃该锁。
     
    但是由于synchronized是在JVM层面实现的,因此系统可以监控锁的释放与否,而ReentrantLock使用代码实现的,系统无法自动释放锁,需要在代码中finally子句中显式释放锁lock.unlock();
     
    同样的例子,使用lock 如何实现呢?
     
    public class Consumer implements Runnable {
     
         private Lock lock;
         public Consumer(Lock lock) {
                this. lock = lock;
         }
         @Override
         public void run() {
                // TODO Auto-generated method stub
                int count = 10;
                while( count > 0 ) {
                     try {
                          lock.lock();
                         count --;
                         System. out.print( "B");
                    } finally {
                          lock.unlock(); //主动释放锁
                          try {
                               Thread. sleep(91L);
                         } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                               e.printStackTrace();
                         }
                    }
               }
     
         }
     
    }
     
    public class Producer implements Runnable{
     
         private Lock lock;
         public Producer(Lock lock) {
                this. lock = lock;
         }
         @Override
         public void run() {
                // TODO Auto-generated method stub
                int count = 10;
                while (count > 0) {
                     try {
                          lock.lock();
                         count --;
                         System. out.print( "A");
                    } finally {
                          lock.unlock();
                          try {
                               Thread. sleep(90L);
                         } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                               e.printStackTrace();
                         }
                    }
               }
         }
    }
     
    调用代码:
     
    public class Test {
     
         public static void main(String[] args) {
               Lock lock = new ReentrantLock();
               
               Consumer consumer = new Consumer(lock);
               Producer producer = new Producer(lock);
               
                new Thread(consumer).start();
                new Thread( producer).start();
               
         }
    }
     
     
    使用建议:
     
    在并发量比较小的情况下,使用synchronized是个不错的选择,但是在并发量比较高的情况下,其性能下降很严重,此时ReentrantLock是个不错的方案。
    展开全文
  • 详解synchronized与Lock的区别与使用

    万次阅读 多人点赞 2017-03-22 13:12:02
    想起自己在上次面试也遇到了synchronized与Lock的区别与使用。于是,我整理了两者的区别和使用情况,同时,对synchronized的使用过程一些常见问题的总结,最后是参照源码和说明文档,对Lock的使用写了几个简单的Demo...

    ###引言:
    昨天在学习别人分享的面试经验时,看到Lock的使用。想起自己在上次面试也遇到了synchronized与Lock的区别与使用。于是,我整理了两者的区别和使用情况,同时,对synchronized的使用过程一些常见问题的总结,最后是参照源码和说明文档,对Lock的使用写了几个简单的Demo。请大家批评指正。

    技术点:

    1、线程与进程:

    在开始之前先把进程与线程进行区分一下,一个程序最少需要一个进程,而一个进程最少需要一个线程。关系是线程–>进程–>程序的大致组成结构。所以线程是程序执行流的最小单位,而进程是系统进行资源分配和调度的一个独立单位。以下我们所有讨论的都是建立在线程基础之上。

    2、Thread的几个重要方法:

    我们先了解一下Thread的几个重要方法。a、start()方法,调用该方法开始执行该线程;b、stop()方法,调用该方法强制结束该线程执行;c、join方法,调用该方法等待该线程结束。d、sleep()方法,调用该方法该线程进入等待。e、run()方法,调用该方法直接执行线程的run()方法,但是线程调用start()方法时也会运行run()方法,区别就是一个是由线程调度运行run()方法,一个是直接调用了线程中的run()方法!!

    看到这里,可能有些人就会问啦,那wait()和notify()呢?要注意,其实wait()与notify()方法是Object的方法,不是Thread的方法!!同时,wait()与notify()会配合使用,分别表示线程挂起和线程恢复。

    这里还有一个很常见的问题,顺带提一下:wait()与sleep()的区别,简单来说wait()会释放对象锁而sleep()不会释放对象锁。这些问题有很多的资料,不再赘述。

    3、线程状态:

    这里写图片描述

    线程总共有5大状态,通过上面第二个知识点的介绍,理解起来就简单了。

    • 新建状态:新建线程对象,并没有调用start()方法之前

    • 就绪状态:调用start()方法之后线程就进入就绪状态,但是并不是说只要调用start()方法线程就马上变为当前线程,在变为当前线程之前都是为就绪状态。值得一提的是,线程在睡眠和挂起中恢复的时候也会进入就绪状态哦。

    • 运行状态:线程被设置为当前线程,开始执行run()方法。就是线程进入运行状态

    • 阻塞状态:线程被暂停,比如说调用sleep()方法后线程就进入阻塞状态

    • 死亡状态:线程执行结束

    4、锁类型

    • 可重入锁:在执行对象中所有同步方法不用再次获得锁

    • 可中断锁:在等待获取锁过程中可中断

    • 公平锁: 按等待获取锁的线程的等待时间进行获取,等待时间长的具有优先获取锁权利

    • 读写锁:对资源读取和写入的时候拆分为2部分处理,读的时候可以多线程一起读,写的时候必须同步地写


    ###synchronized与Lock的区别

    1、我把两者的区别分类到了一个表中,方便大家对比:

    类别 synchronized Lock
    存在层次 Java的关键字,在jvm层面上 是一个类
    锁的释放 1、以获取锁的线程执行完同步代码,释放锁 2、线程执行发生异常,jvm会让线程释放锁 在finally中必须释放锁,不然容易造成线程死锁
    锁的获取 假设A线程获得锁,B线程等待。如果A线程阻塞,B线程会一直等待 分情况而定,Lock有多个锁获取的方式,具体下面会说道,大致就是可以尝试获得锁,线程可以不用一直等待
    锁状态 无法判断 可以判断
    锁类型 可重入 不可中断 非公平 可重入 可判断 可公平(两者皆可)
    性能 少量同步 大量同步
    或许,看到这里还对LOCK所知甚少,那么接下来,我们进入LOCK的深入学习。
    

    ###Lock详细介绍与Demo

    以下是Lock接口的源码,笔者修剪之后的结果:

    public interface Lock {
    
        /**
         * Acquires the lock.
         */
        void lock();
    
        /**
         * Acquires the lock unless the current thread is
         * {@linkplain Thread#interrupt interrupted}.
         */
        void lockInterruptibly() throws InterruptedException;
    
        /**
         * Acquires the lock only if it is free at the time of invocation.
         */
        boolean tryLock();
    
        /**
         * Acquires the lock if it is free within the given waiting time and the
         * current thread has not been {@linkplain Thread#interrupt interrupted}.
         */
        boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    
        /**
         * Releases the lock.
         */
        void unlock();
    	
    }
    
    从Lock接口中我们可以看到主要有个方法,这些方法的功能从注释中可以看出:
    
    • lock():获取锁,如果锁被暂用则一直等待

    • unlock():释放锁

    • tryLock(): 注意返回类型是boolean,如果获取锁的时候锁被占用就返回false,否则返回true

    • tryLock(long time, TimeUnit unit):比起tryLock()就是给了一个时间期限,保证等待参数时间

    • lockInterruptibly():用该锁的获得方式,如果线程在获取锁的阶段进入了等待,那么可以中断此线程,先去做别的事

    通过 以上的解释,大致可以解释在上个部分中“锁类型(lockInterruptibly())”,“锁状态(tryLock())”等问题,还有就是前面子所获取的过程我所写的“大致就是可以尝试获得锁,线程可以不会一直等待”用了“可以”的原因。

    下面是Lock一般使用的例子,注意ReentrantLock是Lock接口的实现。
    

    lock():

    
    package com.brickworkers;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class LockTest {
    	private Lock lock = new ReentrantLock();
    
    	//需要参与同步的方法
    	private void method(Thread thread){
    		lock.lock();
    		try {
    			System.out.println("线程名"+thread.getName() + "获得了锁");
    		}catch(Exception e){
    			e.printStackTrace();
    		} finally {
    			System.out.println("线程名"+thread.getName() + "释放了锁");
    			lock.unlock();
    		}
    	}
    	
    	public static void main(String[] args) {
    		LockTest lockTest = new LockTest();
    		
    		//线程1
    		Thread t1 = new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				lockTest.method(Thread.currentThread());
    			}
    		}, "t1");
    		
    		Thread t2 = new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				lockTest.method(Thread.currentThread());
    			}
    		}, "t2");
    		
    		t1.start();
    		t2.start();
    	}
    }
    //执行情况:线程名t1获得了锁
    //         线程名t1释放了锁
    //         线程名t2获得了锁
    //         线程名t2释放了锁
    

    tryLock():

    package com.brickworkers;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class LockTest {
    	private Lock lock = new ReentrantLock();
    
    	//需要参与同步的方法
    	private void method(Thread thread){
    /*		lock.lock();
    		try {
    			System.out.println("线程名"+thread.getName() + "获得了锁");
    		}catch(Exception e){
    			e.printStackTrace();
    		} finally {
    			System.out.println("线程名"+thread.getName() + "释放了锁");
    			lock.unlock();
    		}*/
    		
    		
    		if(lock.tryLock()){
    			try {
    				System.out.println("线程名"+thread.getName() + "获得了锁");
    			}catch(Exception e){
    				e.printStackTrace();
    			} finally {
    				System.out.println("线程名"+thread.getName() + "释放了锁");
    				lock.unlock();
    			}
    		}else{
    			System.out.println("我是"+Thread.currentThread().getName()+"有人占着锁,我就不要啦");
    		}
    	}
    	
    	public static void main(String[] args) {
    		LockTest lockTest = new LockTest();
    		
    		//线程1
    		Thread t1 = new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				lockTest.method(Thread.currentThread());
    			}
    		}, "t1");
    		
    		Thread t2 = new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				lockTest.method(Thread.currentThread());
    			}
    		}, "t2");
    		
    		t1.start();
    		t2.start();
    	}
    }
    
    //执行结果: 线程名t2获得了锁
    //         我是t1有人占着锁,我就不要啦
    //         线程名t2释放了锁
    
    

    看到这里相信大家也都会使用如何使用Lock了吧,关于tryLock(long time, TimeUnit unit)和lockInterruptibly()不再赘述。前者主要存在一个等待时间,在测试代码中写入一个等待时间,后者主要是等待中断,会抛出一个中断异常,常用度不高,喜欢探究可以自己深入研究。

    前面比较重提到“公平锁”,在这里可以提一下ReentrantLock对于平衡锁的定义,在源码中有这么两段:
    
    
     /**
         * Sync object for non-fair locks
         */
        static final class NonfairSync extends Sync {
            private static final long serialVersionUID = 7316153563782823691L;
    
            /**
             * Performs lock.  Try immediate barge, backing up to normal
             * acquire on failure.
             */
            final void lock() {
                if (compareAndSetState(0, 1))
                    setExclusiveOwnerThread(Thread.currentThread());
                else
                    acquire(1);
            }
    
            protected final boolean tryAcquire(int acquires) {
                return nonfairTryAcquire(acquires);
            }
        }
    
        /**
         * Sync object for fair locks
         */
        static final class FairSync extends Sync {
            private static final long serialVersionUID = -3000897897090466540L;
    
            final void lock() {
                acquire(1);
            }
    
            /**
             * Fair version of tryAcquire.  Don't grant access unless
             * recursive call or no waiters or is first.
             */
            protected final boolean tryAcquire(int acquires) {
                final Thread current = Thread.currentThread();
                int c = getState();
                if (c == 0) {
                    if (!hasQueuedPredecessors() &&
                        compareAndSetState(0, acquires)) {
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }
                else if (current == getExclusiveOwnerThread()) {
                    int nextc = c + acquires;
                    if (nextc < 0)
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);
                    return true;
                }
                return false;
            }
        }
    

    从以上源码可以看出在Lock中可以自己控制锁是否公平,而且,默认的是非公平锁,以下是ReentrantLock的构造函数:

       public ReentrantLock() {
            sync = new NonfairSync();//默认非公平锁
        }
    

    ###尾记录:

    笔者水平一般,不过此博客在引言中的目的已全部达到。这只是笔者在学习过程中的总结与概括,如存在不正确的,欢迎大家批评指出。
    

    延伸学习:对于LOCK底层的实现,大家可以参考:
    点击Lock底层介绍博客

    两种同步方式性能测试,大家可以参考:
    点击查看两种同步方式性能测试博客

    ##博主18年3月新增:
    回来看自己博客。发现东西阐述的不够完整。这里在做补充,因为这篇博客访问较大,所以为了不误导大家,尽量介绍给大家正确的表述:
    1、两种锁的底层实现方式:
    synchronized:我们知道java是用字节码指令来控制程序(这里不包括热点代码编译成机器码)。在字节指令中,存在有synchronized所包含的代码块,那么会形成2段流程的执行。
    这里写图片描述

    我们点击查看SyncDemo.java的源码SyncDemo.class,可以看到如下:
    这里写图片描述

    如上就是这段代码段字节码指令,没你想的那么难吧。言归正传,我们可以清晰段看到,其实synchronized映射成字节码指令就是增加来两个指令:monitorenter和monitorexit。当一条线程进行执行的遇到monitorenter指令的时候,它会去尝试获得锁,如果获得锁那么锁计数+1(为什么会加一呢,因为它是一个可重入锁,所以需要用这个锁计数判断锁的情况),如果没有获得锁,那么阻塞。当它遇到monitorexit的时候,锁计数器-1,当计数器为0,那么就释放锁。

    那么有的朋友看到这里就疑惑了,那图上有2个monitorexit呀?马上回答这个问题:上面我以前写的文章也有表述过,synchronized锁释放有两种机制,一种就是执行完释放;另外一种就是发送异常,虚拟机释放。图中第二个monitorexit就是发生异常时执行的流程,这就是我开头说的“会有2个流程存在“。而且,从图中我们也可以看到在第13行,有一个goto指令,也就是说如果正常运行结束会跳转到19行执行。

    这下,你对synchronized是不是了解的很清晰了呢。接下来我们再聊一聊Lock。

    Lock:Lock实现和synchronized不一样,后者是一种悲观锁,它胆子很小,它很怕有人和它抢吃的,所以它每次吃东西前都把自己关起来。而Lock呢底层其实是CAS乐观锁的体现,它无所谓,别人抢了它吃的,它重新去拿吃的就好啦,所以它很乐观。具体底层怎么实现,博主不在细述,有机会的话,我会对concurrent包下面的机制好好和大家说说,如果面试问起,你就说底层主要靠volatile和CAS操作实现的。

    现在,才是我真正想在这篇博文后面加的,我要说的是:尽可能去使用synchronized而不要去使用LOCK

    什么概念呢?我和大家打个比方:你叫jdk,你生了一个孩子叫synchronized,后来呢,你领养了一个孩子叫LOCK。起初,LOCK刚来到新家的时候,它很乖,很懂事,各个方面都表现的比synchronized好。你很开心,但是你内心深处又有一点淡淡的忧伤,你不希望你自己亲生的孩子竟然还不如一个领养的孩子乖巧。这个时候,你对亲生的孩子教育更加深刻了,你想证明,你的亲生孩子synchronized并不会比领养的孩子LOCK差。(博主只是打个比方)

    那如何教育呢?
    在jdk1.6~jdk1.7的时候,也就是synchronized16、7岁的时候,你作为爸爸,你给他优化了,具体优化在哪里呢:

    1、线程自旋和适应性自旋
    我们知道,java’线程其实是映射在内核之上的,线程的挂起和恢复会极大的影响开销。并且jdk官方人员发现,很多线程在等待锁的时候,在很短的一段时间就获得了锁,所以它们在线程等待的时候,并不需要把线程挂起,而是让他无目的的循环,一般设置10次。这样就避免了线程切换的开销,极大的提升了性能。
    而适应性自旋,是赋予了自旋一种学习能力,它并不固定自旋10次一下。他可以根据它前面线程的自旋情况,从而调整它的自旋,甚至是不经过自旋而直接挂起。

    2、锁消除
    什么叫锁消除呢?就是把不必要的同步在编译阶段进行移除。
    那么有的小伙伴又迷糊了,我自己写的代码我会不知道这里要不要加锁?我加了锁就是表示这边会有同步呀?
    并不是这样,这里所说的锁消除并不一定指代是你写的代码的锁消除,我打一个比方:
    在jdk1.5以前,我们的String字符串拼接操作其实底层是StringBuffer来实现的(这个大家可以用我前面介绍的方法,写一个简单的demo,然后查看class文件中的字节码指令就清楚了),而在jdk1.5之后,那么是用StringBuilder来拼接的。我们考虑前面的情况,比如如下代码:

    String str1="qwe";
    String str2="asd";
    String str3=str1+str2;
    

    底层实现会变成这样:

    StringBuffer sb = new StringBuffer();
    sb.append("qwe");
    sb.append("asd");
    

    我们知道,StringBuffer是一个线程安全的类,也就是说两个append方法都会同步,通过指针逃逸分析(就是变量不会外泄),我们发现在这段代码并不存在线程安全问题,这个时候就会把这个同步锁消除。

    3、锁粗化
    在用synchronized的时候,我们都讲究为了避免大开销,尽量同步代码块要小。那么为什么还要加粗呢?
    我们继续以上面的字符串拼接为例,我们知道在这一段代码中,每一个append都需要同步一次,那么我可以把锁粗化到第一个append和最后一个append(这里不要去纠结前面的锁消除,我只是打个比方)

    4、轻量级锁

    5、偏向锁

    关于最后这两种,我希望留个有缘的读者自己去查找,我不希望我把一件事情描述的那么详细,自己动手得到才是你自己的,博主可以告诉你的是,最后两种并不难。。加油吧,各位。

    展开全文
  • Synchronized与Lock

    2021-04-12 17:31:28
    Synchronized与Lock 为什么存在线程安全问题 单线程执行指令不会出现问题,多线程情况下,当访问一个共享资源,如一个变量、一个对象等统称为临界资源,因为线程执行的不可控,所以导致可能出现线程安全问题。 如何...

    Synchronized与Lock

    为什么存在线程安全问题

    单线程执行指令不会出现问题,多线程情况下,当访问一个共享资源,如一个变量、一个对象等统称为临界资源,因为线程执行的不可控,所以导致可能出现线程安全问题。

    如何解决问题

    采用序列化访问临界资源的方式,即在同一时刻,只能有一个线程访问临界资源。通常来说就是在临界资源上加锁,Java中提供了两个同步互斥的方法synchronized和lock。

    Synchronized

    Java中的每一个对象中都有一个monitor内部锁,synchronize的原理就是通过获取对象的内部锁实现同步互斥,使用monitorenter、monitorexit指令对对象锁计数操作加减1,当一个线程拿到锁后,其他线程阻塞,等待线程释放锁,阻塞过程是不能被中断的。

    注意:

    1. 当一个线程访问一个对象中的synchronized方法时,其他线程不能访问该对象中任何synchronized方法,非synchronized方法可以,因为一个对象只有一把锁
    2. 类其实也有一把锁,用于控制对static成员变量的访问,与对象锁互不干扰

    img

    img

    img

    当执行synchronized代码块或方法时,出现异常时,jvm会释放当前线程的锁,因此不会出现死锁的情况复制代码
    

    synchronized的缺陷

    1. 等待中的线程不能被中断
    2. 获取锁有没有成功无法获知
    3. 当多个线程只是进行读操作时,可以实现线程不冲突

    Lock

    Java中另外一个实现锁的接口

    由于lock不能实现自动释放锁,所以需要手动释放,容易造成死锁,特别注意复制代码
    

    主要方法包括:

    1. lock()–获取锁,如果其他线程已经获取锁则等待,不可中断
    2. unlock()–解锁
    3. trylock()–获取锁,成功获取返回true,否则不等待直接返回false
    4. trylock(long time, TimeUnit unit)–在3的基础上,如果未获取锁则等待time时间,在此期间如果获取到锁则返回true,否则false
    5. lockInteruptly()–获取锁,如果其他线程已经获取锁则等待,可以中断

    ReentrantLock–可重入锁

    ReadWriteLock–读写锁

    img

    lock与synchronize的区别

    1. lock是接口,synchronized是Java关键字
    2. synchronized可以自动释放锁(执行完毕或异常),lock需要手动释放
    3. synchronized等待中的线程不可中断,lock可以
    4. lock可以提高多线程读的效率
    5. lock可以得到获取锁的结构

    锁概念

    • 可重入锁

    表示线程可以重复获取已经获得的锁。从可重入锁可以看出,锁的分配机制,是根据线程分配而不是根据方法分配,比如线程1获取到一个对象的锁,对象中包含两个synchronized修饰的方法,方法A中调用方法B,当线程执行A时无需再获取一次锁,否则将进入死循环

    • 可中断锁
    lock.lockInteruptly()复制代码
    
    • 公平锁

    公平锁表示尽量按照请求锁的先后顺序分配锁,即一个线程释放锁后,由等待时间最长的线程获取锁,在初始化ReentrantLock时

    Lock lock = new ReentrantLock(true); 表示使用公平锁,默认为false

    • 读写锁
    ReentrantReadWriteLock
    
    展开全文
  • synchronized与Lock

    2021-04-13 20:05:53
    视频 Java面试热点问题,synchronized原理剖析与优化_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili 添加链接描述 笔记 Java面试热点问题,synchronized原理剖析与优化_Fengshana的博客-CSDN...synchronized与Lock的区别 ...

    Java面试热点问题,synchronized原理剖析与优化_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili
    视频
    Java面试热点问题,synchronized原理剖析与优化_Fengshana的博客-CSDN博客
    笔记

    synchronized遇见异常会释放锁吗

    会释放锁。
    如果在同步代码块当中出现了异常;monitor会自动帮助释放锁即monitorexit字节码指令。

    在这里插入图片描述

    synchronized与Lock的区别

    展开全文
  • synchronized lock

    2015-09-10 19:34:43
    synchronized lock (1)代码层 Lock是基于在语言层面实现的锁,Lock锁可以被中断,支持定时锁。在安全的前提下,可以很随意的释放锁,如果安全的话。 Synchronized是基于JVM实现的,称之为对象的内置锁,...
  • synchronized与lock

    2018-08-30 20:10:59
    Java存在两种锁机制:synchronizedlock synchronized 介绍 synchronized 是Java的关键字,是Java的内置特性,在JVM层面实现了对临界资源的同步互斥访问,通过对对象的头文件来操作,从而达到加锁和释放锁的...
  • synchronized与LOCK

    2018-12-24 10:03:54
    synchronized的定义:开始执行代码块前,先对同步监视器锁定。执行完,释放锁定。 wait:调用该方法的当前线程会释放对该同步监视器的锁定 wait()notify()方法是Object的方法,不是Thread的方法 要有锁才能释放...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,982
精华内容 1,592
关键字:

synchronized与lock