欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

java 锁机制(synchronized 与 Lock)

程序员文章站 2022-07-02 17:05:07
在java中,解决同步问题,很多时候都会使用到synchronized和Lock,这两者都是在多线程并发时候常使用的锁机制。 synchronized是java中的一个关键字,也就是说是java内置的一个特性。当一个线程访问一个被synchronized修饰的代码块,会自动获取对应的一个锁,并在执行 ......

     在java中,解决同步问题,很多时候都会使用到synchronized和lock,这两者都是在多线程并发时候常使用的锁机制。

     synchronized是java中的一个关键字,也就是说是java内置的一个特性。当一个线程访问一个被synchronized修饰的代码块,会自动获取对应的一个锁,并在执行该代码块时,其他线程想访问这个代码块,会一直处于等待状态,自有等该线程释放锁后,其他线程进行资源竞争,竞争获取到锁的线程才能访问该代码块。

  线程释放synchronized修饰的代码块锁的方式有两种:

  1. 该线程执行完对应代码块,自动释放锁。
  2. 在执行该代码块是发生了异常,jvm会自动释放锁。

  采用synchronized关键字来实现同步,会导致如果存在多个线程想执行该代码块,而当前获取到锁的线程又没有释放锁,可想而知,其他线程只有一只等待,这将严重印象执行效率。lock锁机制的出现就是为了解决该现象。lock是一个java接口,通过这个接口可以实现同步,使用lock时,用户必须手动进行锁的释放,否则容易出现死锁。

       java 锁机制(synchronized 与 Lock)

  reentranlock是lock的唯一实现类。下面简单介绍一下reentranlock与synchronized的区别:

  • synchronized是一个同步锁。当一个线程a访问synchronized修饰的代码块时,线程a就会获取该代码块的锁,如果这时存在其他线程范围该代码块时,将会阻塞,但是不影响这些线程访问其他非同步代码块。
  • reentranlock是可重入锁。由构造方法可知,该锁支持两种锁模式,公平锁和非公平锁。默认是非公平的。java 锁机制(synchronized 与 Lock)

  公平锁:当线程a获取访问该对象,获取到锁后,此时内部存在一个计数器num+1,其他线程想访问该对象,就会进行排队等待(等待队列最前一个线程处于待唤醒状态),直到线程a释放锁(num = 0),此时会唤醒处于待唤醒状态的线程进行获取锁的操作,一直循环。如果线程a再次尝试获取该对象锁是,会检查该对象锁释放已经被占用,如果被占用,会做一次是否为当前线程占用锁的判断,如果是内部计数器num+1,并且不需要进入等待队列,而是直接回去当前锁。

  非公平锁:当线程a在释放锁后,等待对象的线程会进行资源竞争,竞争成功的线程将获取该锁,其他线程继续睡眠。

  公平锁是严格的以fifo的方式进行锁的竞争,但是非公平锁是无序的锁竞争,刚释放锁的线程很大程度上能比较快的获取到锁,队列中的线程只能等待,所以非公平锁可能会有“饥饿”的问题。但是重复的锁获取能减小线程之间的切换,而公平锁则是严格的线程切换,这样对操作系统的影响是比较大的,所以非公平锁的吞吐量是大于公平锁的,这也是为什么jdk将非公平锁作为默认的实现。

  下面是接口lock的方法:

  java 锁机制(synchronized 与 Lock)

  附上对接口lock方法的测试,有什么问题欢迎各位大佬留言评论。

import java.util.concurrent.timeunit;
import java.util.concurrent.locks.lock;
import java.util.concurrent.locks.reentrantlock;

public class testlock {
    // reentrantlock为lock的唯一实现类
    private lock lock = new reentrantlock();

    /**
     * 测试使用lock 的 lock()方法 :如果锁已经被其他线程获取,则等待
     * @param thread
     */
    public void testlock(thread thread){
        try {
            // 1.获取锁
            lock.lock();
            system.out.println("线程 " + thread.getname() + " 获取了锁!");
        }catch (exception e){
            e.printstacktrace();
        }finally {
            system.out.println("线程 " + thread.getname() + " 释放了锁!");
            // 必须在 finally 中释放锁,防止死锁
            lock.unlock();
        }
    }

    /**
     * 测试使用lock 的 lock()方法 :通过这个方法去获取锁时,如果线程正在等待获取锁,则这个线程能够响应中断,即中断线程的等待状态。
     * @param thread
     */
    public void testlockinterruptibly(thread thread){
        try {
            // 1.获取锁
            lock.lockinterruptibly();
            system.out.println("线程 " + thread.getname() + " 获取了锁!");
            thread.sleep(3000);
        }catch (exception e){
            e.printstacktrace();
        }finally {
            system.out.println("线程 " + thread.getname() + " 释放了锁!");
            // 必须在 finally 中释放锁,防止死锁
            lock.unlock();
        }
    }

    /**
     * 测试使用lock 的 trylock()方法 :如果获取成功,则返回true,如果获取失败(即锁已被其他线程获取),则返回false
     * @param thread
     */
    public void testtrylock(thread thread){
        if(lock.trylock()){// 如果获取到了锁
            try {
                system.out.println("线程 " + thread.getname() + " 获取了锁!");
                thread.sleep(3000);
            }catch (exception e){
                e.printstacktrace();
            }finally {
                system.out.println("线程 " + thread.getname() + " 释放了锁!");
                // 必须在 finally 中释放锁,防止死锁
                lock.unlock();
            }
        }else {
            // 没有获取到锁
            system.out.println("线程 " + thread.getname() + " 没有获取到锁!");
        }
    }

    /**
     * 测试使用lock 的 trylock(long time, timeunit unit)方法 :和trylock()方法是类似的,只不过区别在于这个方法在拿不到锁时会等待一定的时间,
     * 在时间期限之内如果还拿不到锁,就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁,则返回true。
     * @param thread
     */
    public void testtrylock_time_unit(thread thread){
        try {
            if(lock.trylock(1000, timeunit.milliseconds)){// 如果获取到了锁
                try {
                    system.out.println("线程 " + thread.getname() + " 获取了锁!");
                }catch (exception e){
                    e.printstacktrace();
                }finally {
                    system.out.println("线程 " + thread.getname() + " 释放了锁!");
                    // 必须在 finally 中释放锁,防止死锁
                    lock.unlock();
                }
            }else {
                // 没有获取到锁
                system.out.println("线程 " + thread.getname() + " 没有获取到锁!");
            }
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
    }

    public static void main(string[] args){
        testlock testlock = new testlock();
        thread a = new thread("a") {
            @override
            public void run() {
                /*// 测试 lock()
                testlock.testlock(thread.currentthread());*/
                /*// 测试 lockinterruptibly()
                testlock.testlockinterruptibly(thread.currentthread());*/
                /*// 测试 trylock()
                testlock.testtrylock(thread.currentthread());*/
                /*// 测试 trylock(long time, timeunit unit)
                testlock.testtrylock_time_unit(thread.currentthread());*/
                testlock.testtrylock_time_unit(thread.currentthread());
            }
        };
        thread b = new thread("b") {
            @override
            public void run() {
                testlock.testtrylock(thread.currentthread());
            }
        };
        a.start();
        b.start();
    }
}