码迷,mamicode.com
首页 > 其他好文 > 详细

同步锁之lock

时间:2018-07-06 01:26:13      阅读:190      评论:0      收藏:0      [点我收藏+]

标签:接口   死锁   value   完成   interupt   generate   rate   on()   失败   

一、 synchronized的缺陷

当一个代码块被synchronized修饰时,同时该代码块被一个线程执行,其他线程便只能一直等待,等待获取锁的线程释放锁,而这里获取锁的线程释放锁只会有两种情况:

 1)获取锁的线程执行完成代码块,自动释放锁资源

 2)代码块中执行异常,由jvm释放锁资源

 如果在执行代码块时候,一个线程在代码块执行过程中Thread.sleep() 睡眠  线程被阻塞了,其他线程只能等待当前线程执行完成后才能执行。及其浪费效率。

另外当多个线程在执行写与写操作时,会发生线程冲突,但当多个线程用于读操作,其中一个线程读取占用的锁资源  而其他线程只能等待造成浪费资源。

通过多个线程读取操作线程不会冲突,通过lock可以实现。

不同点:

   synchronized是java内置的,是java关键字,lock 是一个接口  不是内置的通过这个接口可以实现同步访问

   synchronized不需要用户手动释放锁资源,当同步方法或者同步代码块执行完成后,系统会自动让线程释放锁资源。而Lock必须要手动释放锁资源,如果不释放会出现死锁

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

 1) Lock 是一个接口

     提供了六个方法

     void lock();    boolean tryLock(); boolean tryLock(long time,timeUnit unit); void  lockInteruptibly(); contition newContition()  void unlock();

    其中lock()  tryLock()   tryLock(long time,timeUnit unit)  lockInteruptibly() 用于获取锁    unlock() 用于释放锁

     由于采用lock  不会自动释放锁,需要手动释放锁  所以采用lock 必须在try{}catch(){}finally{}异常捕获中进行,在finally中释放锁

    lock()是最常用的获取锁的方式

     例子:

       Lock lock = ..

       lock.lock();

      try{

   }catch(Exception e){

         }finally{

    lock.unlock()

  }

   

    tryLock 尝试获取锁,如果获取到返回true 如果获取不到返回false   不会拿不到锁一致在等待

    tryLock(long time,TimeUnit unit) 与tryLock()一样都是尝试获取锁,如果获取到返回true  否则返回false  区别在于tryLock(long time ,TimeUnit unit)会等待一定时间,如果直接获取到锁返回true 或者在设置的等待时间内获取到锁返回true  否则返回flase

    Lock lock = ..

    if(lock.tryLock()){

  try{

  }catch(){

      }finally{

   lock.unlock(); 

     }

 }

    lockInterruptibly() 可以用来获取锁,但是如果在获取的锁已经被其他线程锁占用  在等待过程中可以中断当前线程的等待状态。通俗的将  如果 a  b两个线程通过Lock.lockInterruptibly()获取某一个锁时,如果a先获取到了锁   b处于等待状态 那么b可以调用b.interrup()方法中断b的等待状态

  由于lockInterruptibly()的声明中抛出了异常,所以lock.lockInterruptibly()必须放在try块中或者在调用lockInterruptibly()的方法外声明抛出InterruptedException。

   public void method () throws InterruptedException{

  lock.Interruptibly();

       try{

  }catch(){

      }finally{

       lock.unlock();

     }

 }

  当一个线程获取到了锁 是不会被interrup()方法中断  只有处于等待状态的线程在才能被中断。

2)ReadWriteLock  可重入锁

    ReadWriteLock是Lock接口的唯一实现类

    Lock 接口的实现方式:

  

技术分享图片
package cn.ac.bcc.lock;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockDemo {
    
    private List<Integer> list = new ArrayList<>();

    
    public static void main(String[] args) {
        
        //实例化当前类对象
        final LockDemo ld = new LockDemo();
        //创建两个线程对象  调用insert方法
         new Thread(new Runnable(){
            @Override
            public void run() {
                
              ld.insert(Thread.currentThread());

            }
            
        }).start();
         
         new Thread(new Runnable(){

            @Override
            public void run() {
                // TODO Auto-generated method stub
                ld.insert(Thread.currentThread());
            }
             
         }).start();
    }
    
    public void insert(Thread thread){
        
        //创建局部lock锁对象
        Lock lock = new ReentrantLock();
        System.out.println(lock);
        //获取锁
        lock.lock();
        try {
            for(int i=0;i<5;i++){
                list.add(i);
            }
            System.out.println(Thread.currentThread().getName()+"获取了锁");
        } catch (Exception e) {
            // TODO: handle exception
        }finally{
            //释放锁
            lock.unlock();
            System.out.println(Thread.currentThread().getName()+"释放了锁");
        }
    }

}
View Code

 

运行结果:

  

java.util.concurrent.locks.ReentrantLock@100363[Unlocked]
java.util.concurrent.locks.ReentrantLock@e0a386[Unlocked]
Thread-0获取了锁
Thread-1获取了锁
Thread-0释放了锁
Thread-1释放了锁

产生这种结果的原因: 当多个线程获取同一个对象的方法中的局部变量,每一个线程都会获取一个局部变量lock的副本   通过打印锁对象地址可以发现当前锁对象是不同的锁 所以他们可以获取不同的锁

解决这种方案:

 将获取锁对象成员变量  属于当前对象

技术分享图片
package cn.ac.bcc.lock;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockDemo {
    
    private List<Integer> list = new ArrayList<>();
    //创建局部lock锁对象
    private Lock lock = new ReentrantLock();
    
    public static void main(String[] args) {
        
        //实例化当前类对象
        final LockDemo ld = new LockDemo();
        //创建两个线程对象  调用insert方法
         new Thread(new Runnable(){
            @Override
            public void run() {
                
              ld.insert(Thread.currentThread());

            }
            
        }).start();
         
         new Thread(new Runnable(){

            @Override
            public void run() {
                // TODO Auto-generated method stub
                ld.insert(Thread.currentThread());
            }
             
         }).start();
    }
    
    public void insert(Thread thread){
        

        System.out.println(lock);
        //获取锁
        lock.lock();
        try {
            for(int i=0;i<5;i++){
                list.add(i);
            }
            System.out.println(Thread.currentThread().getName()+"获取了锁");
        } catch (Exception e) {
            // TODO: handle exception
        }finally{
            //释放锁
            lock.unlock();
            System.out.println(Thread.currentThread().getName()+"释放了锁");
        }
    }

}
View Code

运行结果:

java.util.concurrent.locks.ReentrantLock@bcda2d[Unlocked]
java.util.concurrent.locks.ReentrantLock@bcda2d[Locked by thread Thread-0]
Thread-0获取了锁
Thread-0释放了锁
Thread-1获取了锁
Thread-1释放了锁

tryLock()

 

技术分享图片
package cn.ac.bcc.lock;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockDemo {
    
    private List<Integer> list = new ArrayList<>();
    //创建局部lock锁对象
    private Lock lock = new ReentrantLock();
    
    public static void main(String[] args) {
        
         //实例化当前类对象
         final LockDemo ld = new LockDemo();
        //创建两个线程对象  调用insert方法
         new Thread(new Runnable(){
            @Override
            public void run() {
                
              ld.insert(Thread.currentThread());

            }
            
        }).start();
         
         new Thread(new Runnable(){

            @Override
            public void run() {
                // TODO Auto-generated method stub
                ld.insert(Thread.currentThread());
            }
             
         }).start();
    }
    
    public void insert(Thread thread){
        

        System.out.println(lock);
        //获取锁
        if(lock.tryLock()){
            try {
                for(int i=0;i<5;i++){
                    list.add(i);
                }
                System.out.println(Thread.currentThread().getName()+"获取了锁");
            } catch (Exception e) {
                // TODO: handle exception
            }finally{
                //释放锁
                lock.unlock();
                System.out.println(Thread.currentThread().getName()+"释放了锁");
            }
        }else{
            System.out.println(Thread.currentThread().getName()+"没有获取到锁");
        }
        
    }

}
View Code

运行结果:

java.util.concurrent.locks.ReentrantLock@14e8cee[Unlocked]
java.util.concurrent.locks.ReentrantLock@14e8cee[Locked by thread Thread-0]
Thread-1没有获取到锁
Thread-0获取了锁
Thread-0释放了锁

当多个线程获取同一个锁对象时,当线程a 获取锁  b尝试获取锁失败返回false

lockInterruptibly()

技术分享图片
package cn.ac.bcc.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class InterruptiblyDemo {

    Lock lock = new ReentrantLock();
    
    public static void main(String[] args) {
        
        InterruptiblyDemo interruptiblyDemo = new InterruptiblyDemo();
        
        MyThread myThread = new MyThread(interruptiblyDemo);
        MyThread myThread2 = new MyThread(interruptiblyDemo);
        myThread.start();
        myThread2.start();
        
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        //中断线程2
        myThread2.interrupt();
    }
    
    public  void  insert() throws InterruptedException{
        lock.lockInterruptibly();
        try{
            System.out.println(Thread.currentThread().getName()+"得到了锁");
            long startTime = System.currentTimeMillis();
            for(;;){
                
                if(System.currentTimeMillis()-startTime>=Integer.MAX_VALUE){
                    break;
                }
                
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            System.out.println(Thread.currentThread().getName()+"释放了锁");
            lock.unlock();
        }
    }
}
class MyThread extends Thread{
    
    InterruptiblyDemo interruptiblyDemo;
    
    public MyThread(InterruptiblyDemo interruptiblyDemo){
        this.interruptiblyDemo=interruptiblyDemo;
    }
    
    @Override
    public void run(){
        try {
            interruptiblyDemo.insert();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println(Thread.currentThread().getName()+"锁被中断");
        }
    }
    
}
View Code

运行结果:

Thread-0得到了锁
java.lang.InterruptedException
Thread-1锁被中断
at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:896)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1221)
at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:340)
at cn.ac.bcc.lock.InterruptiblyDemo.insert(InterruptiblyDemo.java:30)
at cn.ac.bcc.lock.MyThread.run(InterruptiblyDemo.java:60)

 

 

 

 

 

  

     

  

 

 

    https://www.cnblogs.com/baizhanshi/p/6419268.html

同步锁之lock

标签:接口   死锁   value   完成   interupt   generate   rate   on()   失败   

原文地址:https://www.cnblogs.com/lwdmaib/p/9266326.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!