Memorydoc
首页
  • 前端文章

    • JavaScript
  • 学习笔记

    • 《JavaScript教程》
    • 《JavaScript高级程序设计》
    • 《ES6 教程》
    • 《Vue》
    • 《React》
    • 《TypeScript 从零实现 axios》
    • 《Git》
    • TypeScript
    • JS设计模式总结
    • HTML
    • CSS
    • 前端拓展
  • 编程之道

    • 并发编程
    • 设计模式
    • 数据结构算法
    • 技术拓展
    • 技术陷阱
    • 面试宝典
  • 分布式

    • 微服务
    • 数据库
  • 项目优化实战

    • JVM 优化
    • 线程池优化
    • 模板引擎优化
    • 任务调度优化
    • 内存优化
  • 学习
  • 面试
  • 心情杂货
  • 实用技巧
  • 友情链接
关于
收藏
  • 分类
  • 标签
  • 归档
GitHub (opens new window)

Memorydoc

术尚可求
首页
  • 前端文章

    • JavaScript
  • 学习笔记

    • 《JavaScript教程》
    • 《JavaScript高级程序设计》
    • 《ES6 教程》
    • 《Vue》
    • 《React》
    • 《TypeScript 从零实现 axios》
    • 《Git》
    • TypeScript
    • JS设计模式总结
    • HTML
    • CSS
    • 前端拓展
  • 编程之道

    • 并发编程
    • 设计模式
    • 数据结构算法
    • 技术拓展
    • 技术陷阱
    • 面试宝典
  • 分布式

    • 微服务
    • 数据库
  • 项目优化实战

    • JVM 优化
    • 线程池优化
    • 模板引擎优化
    • 任务调度优化
    • 内存优化
  • 学习
  • 面试
  • 心情杂货
  • 实用技巧
  • 友情链接
关于
收藏
  • 分类
  • 标签
  • 归档
GitHub (opens new window)
  • 并发编程

    • 多线程基础
    • Atomic
    • synchronized
    • volatile(内存可见)
    • ReentrantLock
      • 代替synchronized
      • tryLock
      • lockInterruptibly
    • Lock 和 CountDownLatch
    • 线程池
    • 并发集合
    • 综合
    • 线程约束
    • 线程通信
    • 情景案例
    • AQS(AbstractQueuedSynchronizer)
    • 自己实现锁
    • 通过lock 手写阻塞队列
    • 通过Condition 手写阻塞队列
    • 阻塞队列实现生产者消费者模式
    • StampedLock 乐观读写锁
  • 设计模式

  • 数据结构算法

  • 技术拓展

  • 技术陷阱

  • 面试宝典

  • 微服务

  • 数据库

  • 项目优化背景

  • JVM优化

  • 技术架构
  • 并发编程
Memorydoc
2021-11-27
代替synchronized
tryLock
lockInterruptibly

ReentrantLock原创

# 代替synchronized

ReentRantLock 可以用来代替synchronized 的手动锁

下面代码使用 ReentrantLock 手动加锁的方式锁住了对count变量的操作

public class T implements  Runnable{
    private int count = 10;
    private ReentrantLock reentrantLock =new ReentrantLock();
    @Override
    public void run() {
        reentrantLock.lock();
        try{
            count--;
            System.out.println(Thread.currentThread().getName() + "count = " + count);
        }catch (Exception ex){
            ex.printStackTrace();
        }finally {
            reentrantLock.unlock();
        }
    }

    public static void main(String[] args) {
        T t =new T();
        for (int i = 0; i< 5; i++){
            new Thread(t, "THREAD" + i ).start();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

这个地方的count可以使用原子类,而不是使用整型,使用AtomicInteger 原子类代替

# tryLock

尝试获取锁: 可以设置超时时间,如果超过超时时间,还没有获取到锁,则执行下面代码

    public class T {
        List<Integer> list = new ArrayList<>();
        private ReentrantLock reentrantLock = new ReentrantLock();
    
        public void m1() {
            for (int i = 0; i < 10; i++) {
                reentrantLock.lock();
                list.add(i);
                System.out.println(i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    reentrantLock.unlock();
                }
            }
        }
    
        public void m2() {
            boolean lock = false;
            try {//代码1
                lock = reentrantLock.tryLock(5, TimeUnit.SECONDS);
                System.out.println("m2 begin");
            } catch (InterruptedException e) {
                System.out.println("Thread interrupted");
            } finally {
                if (lock) reentrantLock.unlock();
            }
           /* try {// 代码2
                reentrantLock.lock();
                System.out.println("m2 begin");
            } catch (Exception ex) {
                ex.printStackTrace();
            } finally {
                reentrantLock.unlock();
            }*/
    
    
        }
    
        public static void main(String[] args) {
            T t = new T();
            new Thread(t::m1).start();//t1线程 java8 的简写形式
    
            new Thread(t::m2).start();//t2线程
        }
    
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

代码块2 是不同lock形式,会一直等待10秒之后才能执行 m2 begin ,但是代码块1使用 tryLock() 方法,线程尝试获取锁,如果在制定的时间内获取不到锁 那么会返回false,并且继续往下执行

# lockInterruptibly

可打断锁: 当前锁不会一直锁定,基本的lock()方法会一直等待,lockInterruptibly();可以将锁设置成可以打断的锁,这样可以在主线程中或者其他线程种将线程打断 并抛出异常

public class T {
    List<Integer> list = new ArrayList<>();
    private ReentrantLock reentrantLock = new ReentrantLock();

    public void m1() {
        for (int i = 0; i < 10; i++) {
            reentrantLock.lock();
            list.add(i);
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                reentrantLock.unlock();//这里会抛异常,因为这里线程被打断了 不能调用unlock()方法了
            }
        }
    }

    public void m2() {
        try {
            reentrantLock.lockInterruptibly();
            System.out.println("m2 begin");
        } catch (InterruptedException e) {
            System.out.println("Thread interrupted");
        } finally {
            if(reentrantLock.isLocked()){
                reentrantLock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        T t = new T();
        new Thread(t::m1).start();//t1线程

        Thread t2 = new Thread(() -> t.m2());//t2线程
        t2.start();
        try {
            TimeUnit.SECONDS.sleep(2);
            t2.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
编辑 (opens new window)
上次更新: 2022/05/01, 19:42:49
volatile(内存可见)
Lock 和 CountDownLatch

← volatile(内存可见) Lock 和 CountDownLatch→

最近更新
01
命令模式 原创
05-03
02
桥接模式 原创
05-02
03
优雅写代码三 原创
04-29
更多文章>
Theme by Memorydoc | Copyright © 2021-2025 Memorydoc | MIT License
  • 跟随系统
  • 浅色模式
  • 深色模式
  • 阅读模式