栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java(二十一) -- 重入锁

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java(二十一) -- 重入锁

目录

重入锁

JUC 勾优C

公平锁和非公平锁的区别

Tips

ReentrantLock

ReentrantLock 限时性


重入锁

JUC 勾优C

        java.util.concurrent

        Java 并发编程工具包,Java 官方提供的一套专门用来处理并发编程的工具集合(接口+类)

        并发:单核 CPU,多个线程"同时"运行,实际是交替执行,只不过速度太快,看起来是同时执行。

        并行:多核 CPU,真正的多个线程同时运行。

        重入锁是 JUC 使用频率非常高的一个类 ReentrantLock

        ReentrantLock 就是对 synchronized 的升级,目的也是为了实现线程同步。

  • ReentrantLock 是一个类,synchronized 是一个关键字。

  • ReentrantLock 是 JDK 实现,synchronized 是 JVM 实现。

  • synchronized 可以自动释放锁,ReentrantLock 需要手动释放。

        ReentrantLock 是 Lock 接口的实现类。

公平锁和非公平锁的区别

        公平锁:线程同步时,多个线程排队,依次执行

        非公平锁:线程同步时,可以插队

线程的实现有两种方式

  • 继承 Thread

  • 实现 Runnable

实现 Runnable 的耦合度更低

 

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
​
public class Test {
    public static void main(String[] args) {
        Account account = new Account();
        new Thread(()->{
            account.count();
        },"A") .start();
        new Thread(()->{
            account.count();
        },"B") .start();
    }
}
​

class Account{
    private static int num;
    public void count() {
        num++;
        try {
            TimeUnit.MILLISECONDS.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"是当前的第"+num+"位访客");
    }
}

import java.util.concurrent.TimeUnit;
​
public class Test2 {
    public static void main(String[] args) {
        Account2 account = new Account2();
        new Thread(account,"A").start();
        new Thread(account,"B").start();
    }
}
​
class Account2 implements Runnable{
    
    private static int num;
​
    @Override
    public void run() {
        // TODO Auto-generated method stub
        num++;
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"是当前的第"+num+"位访客");
    }
    
}

  

Tips
class Account{
    private static Integer num = 0;
    private static Integer id = 0;
    public void count() {
        synchronized (num) {
            num++;
            try {
                TimeUnit.MILLISECONDS.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"是当前的第"+num+"位访客");
        }   
    }
}

        锁定 num 不能同步,锁定 id 可以同步,原因是什么?

                synchronized 必须锁定唯一的元素才可以实现同步

                num 的值每次都在变,所以 num 所指向的引用一直在变,所以不是唯一的元素,肯定无法实现同步。

                id 的值永远不变,所以是唯一的元素,可以实现同步。

ReentrantLock
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
​
public class Test3 {
    public static void main(String[] args) {
        Account3 account = new Account3();
        new Thread(()->{
            account.count();
        },"A").start();
        new Thread(()->{
            account.count();
        },"B").start();
    }
}
​
class Account3{
    private static int num;
    private ReentrantLock reentrantLock = new ReentrantLock();
    
    public void count() {
        //上锁
        reentrantLock.lock();
        reentrantLock.lock();
        num++;
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"是当前的第"+num+"位访客");
        //解锁
        reentrantLock.unlock();
        reentrantLock.unlock();
    }
}
  • Lock 上锁和解锁都需要开发者手动完成。

  • 可以重复上锁,上几把锁就需要解几把锁。

        ReentrantLock 除了可以重入之外,还有一个可以中断的特点,可中断是指某个线程在等待获取锁的过程中可以主动终止线程。

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
​
public class Test5 {
    public static void main(String[] args) {
        StopLock stopLock = new StopLock();
        Thread t1 = new Thread(()->{
            stopLock.service();
        },"A");
        Thread t2 =new Thread(()->{
            stopLock.service();
        },"B");
        t1.start();
        t2.start();
        try {
            TimeUnit.SECONDS.sleep(1);
            t2.interrupt();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
​
class StopLock{
    
    private ReentrantLock reentrantLock = new ReentrantLock();
    
    public void service() {
        
        try {
            reentrantLock.lockInterruptibly();
            
            System.out.println(Thread.currentThread().getName()+"get lock");
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        } catch (InterruptedException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }
        
    }
}

ReentrantLock 限时性

        判断某个线程在一定的时间内能否获取锁,通过 tryLock 方法来实现

        tryLock(long time,TimeUnit unit)

                time 指时间数值

                unit 时间单位

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
​
public class Test {
    public static void main(String[] args) {
        TimeLock timeLock = new TimeLock();
        
        new Thread(()->{
            timeLock.lock();
        },"A").start();
        new Thread(()->{
            timeLock.lock();
        },"B").start();
    }
}
​
class TimeLock{
​
    private ReentrantLock reentrantLock = new ReentrantLock();
​
    public void lock(){
        
        try {
            if(reentrantLock.tryLock(3, TimeUnit.SECONDS)){
                System.out.println(Thread.currentThread().getName()+" get lock");
                TimeUnit.SECONDS.sleep(5);
            }else{
                System.out.println(Thread.currentThread().getName()+" not lock");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if(reentrantLock.isHeldByCurrentThread()){
                reentrantLock.unlock();
            }
        }
    }
}

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/950992.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号