Java并发编程--Lock的用法

最新推荐文章于 2024-07-31 09:07:01 发布

溜达的地鼠

最新推荐文章于 2024-07-31 09:07:01 发布

阅读量258

点赞数

分类专栏：并发文章标签：并发线程

本文链接：https://blog.csdn.net/jlj417/article/details/74937142

版权

并发专栏收录该内容

9 篇文章 0 订阅

订阅专栏

本文深入探讨了Java中synchronized与Lock接口的差异，包括Lock的各种方法如tryLock和lockInterruptibly，以及ReentrantLock和ReentrantReadWriteLock的具体应用。通过实例展示了如何提高并发程序的效率。

摘要由CSDN通过智能技术生成

概要

上一节提到了线程同步互斥的方法采用的是synchronized加锁的方法，但这种方式有个缺点就是其它线程会一直被阻塞，直到拿到锁后才能继续执行

另一个缺点就是当线程执行异常后会自动释放到加锁对象

试想这样一种场景，当前线程获取了一个临界锁，而这个时候线程要去处理很长的一个操作，比如IO读取文件，或者批量操作数据库，这个时候其它线程就会一直处理等待阻塞的状态，什么也做不了，导致效率极低。

对于这种情况就体现出了Lock的好处

总结一下，也就是说Lock提供了比synchronized更多的功能。但是要注意以下几点：

　　1）Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；

　　2）Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

　　3）Lock可以知道我们是否加锁成功，可以获取到加锁状态

LOCK

接口

public abstract interface java.util.concurrent.locks.Lock {

  public abstract void lock();

  public abstract void lockInterruptibly() throws InterruptedException;

  public abstract boolean tryLock();

  public abstract boolean tryLock(long arg0, TimeUnit arg1) throws InterruptedException;

  public abstract void unlock();

  public abstract  newCondition();

}

lock()

获取锁如果锁被其它线程锁持有，会一直等待，之前已经说过lock需要人工释放锁，因此lock加锁必须放在try/catch/finally中，确保在finally中对锁进行释放，防止死锁

Lock lock ....
lock.lock()
try{

}catch(){

}finally{
    lock.unlock();
}

tryLock()

获取锁会立刻返回一个结果值，拿到锁返回true，没有拿到锁则返回FALSE，也就是说这种加锁的方法会立刻返回，如果没有拿到锁就会返回FALSE，不会一直等待。

tryLock(long arg0, TimeUnit arg1)

和上面的用法一样，不同的是如果拿不到锁会等待一定的时间，如果超过这个设定的时间点还是没有拿到锁，则返回FALSE，如果中间或者方开始就拿到锁，则返回true

Lock lock = ...;
if(lock.tryLock()) {
     try{
         //处理任务
     }catch(Exception ex){

     }finally{
         lock.unlock();   //释放锁
     } 
}else {
    //如果不能获取锁，则直接做其他事情
}

lockInterruptibly()

通过lockInterruptibly获取锁比较特殊，当lockInterruptibly获取锁在等待的过程中，该线程是可以被中断的。

比如线程A和线程B同时通过lockInterruptibly获取锁，此时A获取到了，B处于等待状态，这个时候我们可以调用线程B的interrupt()中断B的等待，让B去做其它事情。

当一个线程获取了锁之后，是不会被interrupt()方法中断的。因为本身在前面的文章中讲过单独调用interrupt()方法不能中断正在运行过程中的线程，只能中断阻塞过程中的线程
通过 lockInterruptibly获取锁只有在没有获取到锁处于等待状态的线程才能被中断
synchronized方法获取锁是不能被打断的，只会一直等待下去，除非执行结束或者异常退出才会释放锁

ReentrantLock

ReentrantLock是唯一一个实现了Lock接口的类

由于Lock是对对象的方法或者成员加锁的，因此必须将Lock变量设置为成员变量。

public class Test {

    private ArrayList<Integer> list = new ArrayList<Integer>();

    Lock                       lock = new ReentrantLock();

    public void addNum(Thread thread) {

        lock.lock();

        try {

            for (int i = 0; i < 5; i++)
                System.out.println(thread.getName() + "执行, i =  " + i);

        } catch (Exception e) {

        } finally {

            lock.unlock();
        }
    }

    public static void main(String[] args) {

        final Test test = new Test();

        new Thread() {

            @Override
            public void run() {

                test.addNum(Thread.currentThread());
            }
        }.start();

        new Thread() {

            @Override
            public void run() {

                test.addNum(Thread.currentThread());
            }
        }.start();

    }

}

执行结果：

Thread-1执行, i =  0
Thread-1执行, i =  1
Thread-1执行, i =  2
Thread-1执行, i =  3
Thread-1执行, i =  4
Thread-2执行, i =  0
Thread-2执行, i =  1
Thread-2执行, i =  2
Thread-2执行, i =  3
Thread-2执行, i =  4

下面使用tryLock()

public class Test {

    private ArrayList<Integer> list = new ArrayList<Integer>();

    Lock                       lock = new ReentrantLock();

    public void addNum(Thread thread) {

        if (lock.tryLock()) {
            try {

                thread.sleep(500);

                for (int i = 0; i < 5; i++)
                    System.out.println(thread.getName() + "执行, i =  " + i);

            } catch (Exception e) {

            } finally {

                lock.unlock();
            }
        } else {

            System.out.println(thread.getName() + "没有获取到锁");
        }
    }

    public static void main(String[] args) {

        final Test test = new Test();

        new Thread() {

            @Override
            public void run() {

                test.addNum(Thread.currentThread());
            }
        }.start();

        new Thread() {

            @Override
            public void run() {

                test.addNum(Thread.currentThread());
            }
        }.start();

    }

}

执行结果

Thread-2没有获取到锁
Thread-1执行, i =  0
Thread-1执行, i =  1
Thread-1执行, i =  2
Thread-1执行, i =  3
Thread-1执行, i =  4

使用lockInterruptibly方法获取锁

public class Test extends Thread {

    private ArrayList<Integer> list = new ArrayList<Integer>();

    private Lock               lock = new ReentrantLock();

    public void addNum(Thread thread) throws InterruptedException {

        lock.lockInterruptibly();

        try {

            thread.sleep(1000);

            System.out.println(thread.getName() + "执行中");

        } catch (Exception e) {

            System.out.println(thread.getName() + "获取锁异常");

        } finally {

            lock.unlock();
            System.out.println(thread.getName() + "释放锁");
        }

    }

    @Override
    public void run() {

        try {

            addNum(Thread.currentThread());

        } catch (Exception e) {

            System.out.println(Thread.currentThread().getName() + "被打断");
        }
    }

    public static void main(String[] args) throws InterruptedException {

        final Test test = new Test();

        Mytest test1 = new Mytest(test);
        Mytest test2 = new Mytest(test);

        test1.start();
        test2.start();

        Thread.sleep(300);

        test2.interrupt();

    }

}

class Mytest extends Thread {

    private Test test;

    public Mytest(Test test) {

        this.test = test;

    }

    /** 
     * @see java.lang.Thread#run()
     */
    @Override
    public void run() {

        try {

            test.addNum(Thread.currentThread());

        } catch (Exception e) {

            System.out.println(Thread.currentThread().getName() + "被打断");
        }
    }

}

执行结果：

Thread-3被打断
Thread-2执行中
Thread-2释放锁

ReadWriteLock

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实现了ReadWriteLock接口。

我们之前提过相对于synchronized来说，线程通过synchronized获取锁后，其它线程只能等待，直到之前线程释放锁后线程拿到锁才能正常往下执行。

比如目前多个线程要对文件进行读操作，通过synchronized的话任何时候只能有一个线程进行读操作，而ReentrantReadWriteLock 则可以实现多个线程的读操作。

public class Test extends Thread {

    private ArrayList<Integer>     list = new ArrayList<Integer>();

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void addNum(Thread thread) throws InterruptedException {

        lock.readLock().lock();

        try {

            thread.sleep(1000);

            System.out.println(thread.getName() + "执行中");

        } catch (Exception e) {

            System.out.println(thread.getName() + "获取锁异常");

        } finally {

            lock.readLock().unlock();
            System.out.println(thread.getName() + "释放锁");
        }

    }

    @Override
    public void run() {

        try {

            addNum(Thread.currentThread());

        } catch (Exception e) {

            System.out.println(Thread.currentThread().getName() + "被打断");
        }
    }

    public static void main(String[] args) throws InterruptedException {

        final Test test = new Test();

        Mytest test1 = new Mytest(test);
        Mytest test2 = new Mytest(test);
        Mytest test3 = new Mytest(test);

        test1.start();
        test2.start();
        test3.start();


    }

}

class Mytest extends Thread {

    private Test test;

    public Mytest(Test test) {

        this.test = test;

    }

    /** 
     * @see java.lang.Thread#run()
     */
    @Override
    public void run() {

        try {

            test.addNum(Thread.currentThread());

        } catch (Exception e) {

            System.out.println(Thread.currentThread().getName() + "被打断");
        }
    }

}

执行结果：

Thread-4执行中
Thread-3执行中
Thread-2执行中
Thread-3释放锁
Thread-4释放锁
Thread-2释放锁

可见三个线程都获取去到读锁，这样就大大提升了读操作的效率。

　　不过要注意的是，如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。

　　如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

Lock和synchronized的区别

lock	synchronized
lock是一个接口	synchronized是一个Java的关键字
lock可以获取到加锁状态	synchronized不知道是否加锁成功
可以中断正在等待的线程	不能人工中断
需要手动释放锁否则会发生死锁	执行完毕或在线程异常退出后才能释放锁
可以提供多个线程的读的效率	只能单个线程获取锁，其它线程会一直等待，效率低

锁的概念

重入锁

比如当线程获取到A对象的一个锁方法method1，而method1中又调用了另一个锁方法method2，这个时候就不需要再申请锁，而是直接可以使用method2的方法，这就是重入锁。

即锁是面向线程的，当前线程获取了这个对象的锁，则可以使用这个对象中的其它加锁的方法

synchronized和Lock都具备可重入性

可中断锁

可中断锁顾名思义就是可以被中断的锁

synchronized就不是可中断锁，而Lock是可中断锁

公平锁

公平锁即尽量以请求锁的顺序来获取锁。比如同是有多个线程在等待一个锁，当这个锁被释放时，等待时间最久的线程（最先请求的线程）会获得该所，这种就是公平锁。

　　非公平锁即无法保证锁的获取是按照请求锁的顺序进行的。这样就可能导致某个或者一些线程永远获取不到锁。

　　在Java中，synchronized就是非公平锁，它无法保证等待的线程获取锁的顺序。

　　而对于ReentrantLock和ReentrantReadWriteLock，它默认情况下是非公平锁，但是可以设置为公平锁。

在ReentrantLock中定义了2个静态内部类，一个是NotFairSync，一个是FairSync，分别用来实现非公平锁和公平锁。

我们可以在创建ReentrantLock对象时，通过以下方式来设置锁的公平性：

ReentrantLock lock = new ReentrantLock(true);

读写锁

将读锁和写锁分开，线程可以分别获取读锁和写锁

正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。

ReadWriteLock就是读写锁，它是一个接口，ReentrantReadWriteLock实现了这个接口。

可以通过readLock()获取读锁，通过writeLock()获取写锁。

溜达的地鼠

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录