JAVA多线程（6）：Lock锁

最新推荐文章于 2023-07-07 15:36:11 发布
最新推荐文章于 2023-07-07 15:36:11 发布
阅读量196 收藏 1
点赞数
分类专栏： java多线程 文章标签： java 多线程 lock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010886217/article/details/104012619
版权

一、概念

Lock类是java.util.concurrent.locks下，可以和synchronized实现同样功能的线程锁。二者区别：

1.Sychronized：隐式锁

可以锁：（1）同步代码块；（2）同步方法

2.Lock：是显示锁

注意：需要通过lock.lock()上锁，并且必须在finally内通过lock.unlock方法释放锁。
 

二、lock解决实例

1.出现多线程共享变量访问问题

package com.algorithm.learn.test.JUC;

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

/**
 * Created by Administrator on 2020/1/16.
 */
public class TestLock {
    public static void main(String[] args) {
        Ticket ticket=new Ticket();
        new Thread(ticket,"1号窗口").start();
        new Thread(ticket,"2号窗口").start();
        new Thread(ticket,"3号窗口").start();
    }
}

class  Ticket implements Runnable{
    private int tick=100;
 
    @Override
    public void run() {
        while (true){

            if(tick>0){
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"完成售票，余票为："+ --tick);
            }

        }
    }
}

结果：
...
1号窗口完成售票，余票为：6
2号窗口完成售票，余票为：5
3号窗口完成售票，余票为：6
3号窗口完成售票，余票为：4
2号窗口完成售票，余票为：3
1号窗口完成售票，余票为：2
3号窗口完成售票，余票为：0
2号窗口完成售票，余票为：1
1号窗口完成售票，余票为：-1

2.添加lock解决

package com.algorithm.learn.test.JUC;

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

/**
 * Created by Administrator on 2020/1/16.
 */
public class TestLock {
    public static void main(String[] args) {
        Ticket ticket=new Ticket();
        new Thread(ticket,"1号窗口").start();
        new Thread(ticket,"2号窗口").start();
        new Thread(ticket,"3号窗口").start();
    }
}

class  Ticket implements Runnable{
    private int tick=100;
    private Lock lock=new ReentrantLock();

    @Override
    public void run() {
        while (true){
            //1.上锁
            lock.lock();

            try {
                if(tick>0){
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"完成售票，余票为："+ --tick);
                }
            }finally {
                //3.解锁：一定在finally里
                lock.unlock();
            }

        }
    }

//    @Override
//    public void run() {
//        while (true){
//
//            if(tick>0){
//                try {
//                    Thread.sleep(200);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                System.out.println(Thread.currentThread().getName()+"完成售票，余票为："+ --tick);
//            }
//
//        }
//    }
}

结果：
...
3号窗口完成售票，余票为：6
1号窗口完成售票，余票为：5
2号窗口完成售票，余票为：4
2号窗口完成售票，余票为：3
3号窗口完成售票，余票为：2
3号窗口完成售票，余票为：1
1号窗口完成售票，余票为：0

3.生产者消费者实例（等待唤醒）

（1）synchronized 实现生产者和消费者实例，有虚假唤醒

package com.algorithm.learn.test.JUC;

/**
 * Created by Administrator on 2020/1/16.
 */
public class TestProductorAndConsumer {

    public static void main(String[] args) {
        Clerk clerk=new Clerk();

        Producer producer=new Producer(clerk);
        Consumer consumer=new Consumer(clerk);

        new Thread(producer,"生产者A").start();
        new Thread(consumer,"消费者B").start();
    }
}

/**
 * 店员
 */
class Clerk{
    private int product=0;

    //进货
    public synchronized void get(){
        if(product>=10){
            System.out.println("产品已满！");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            System.out.println(Thread.currentThread().getName()+":"+ ++product);
            this.notifyAll();
        }
    }

    //卖货
    public synchronized void sale(){
        if(product<=0){
            System.out.println("产品已没有了！");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            System.out.println(Thread.currentThread().getName()+":"+ --product);
            this.notifyAll();
        }
    }
}

/**
 * 生产者
 */
class Producer implements Runnable{

    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            clerk.get();
        }
    }
}

/**
 * 消费者
 */
class Consumer implements Runnable{
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            clerk.sale();
        }
    }
}

结果：

生产者A:1
生产者A:2
生产者A:3
生产者A:4
生产者A:5
生产者A:6
生产者A:7
生产者A:8
生产者A:9
生产者A:10
产品已满！
消费者B:9
消费者B:8
消费者B:7
消费者B:6
消费者B:5
消费者B:4
消费者B:3
消费者B:2
消费者B:1
消费者B:0
产品已没有了！
生产者A:1
生产者A:2
生产者A:3
生产者A:4
生产者A:5
生产者A:6
生产者A:7
生产者A:8
生产者A:9
消费者B:8
消费者B:7
消费者B:6
消费者B:5
消费者B:4
消费者B:3
消费者B:2
消费者B:1
消费者B:0

（2）synchronized解决虚假唤醒（使用while替换if）

package com.algorithm.learn.test.JUC;

/**
 * Created by Administrator on 2020/1/16.
 */
public class TestProductorAndConsumer {

    public static void main(String[] args) {
        Clerk clerk=new Clerk();

        Producer producer=new Producer(clerk);
        Consumer consumer=new Consumer(clerk);

        new Thread(producer,"生产者A").start();
        new Thread(consumer,"消费者B").start();
        new Thread(producer,"生产者C").start();
        new Thread(consumer,"消费者D").start();
    }
}

/**
 * 店员
 */
class Clerk{
    private int product=0;

    //进货
    public synchronized void get(){
        while(product>=1){
            System.out.println("产品已满！");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //else{
//            System.out.println(Thread.currentThread().getName()+":"+ ++product);
//            this.notifyAll();
//        }
        System.out.println(Thread.currentThread().getName()+":"+ ++product);
        this.notifyAll();
    }

    //卖货
    public synchronized void sale(){
        while(product<=0){
            System.out.println("缺货！");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
//        else {
//            System.out.println(Thread.currentThread().getName()+":"+ --product);
//            this.notifyAll();
//        }
        System.out.println(Thread.currentThread().getName()+":"+ --product);
        this.notifyAll();
    }
}

/**
 * 生产者
 */
class Producer implements Runnable{

    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            //添加延迟
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.get();
        }
    }
}

/**
 * 消费者
 */
class Consumer implements Runnable{
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            //添加延迟
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.sale();
        }
    }
}

结果：
生产者A:1
消费者D:0
生产者C:1
消费者B:0
生产者A:1
消费者D:0
生产者C:1
消费者B:0
缺货！
生产者C:1
消费者B:0
缺货！
生产者A:1
消费者D:0
缺货！
生产者C:1
消费者B:0
缺货！
生产者A:1
消费者D:0
缺货！
生产者C:1
消费者B:0
缺货！
生产者A:1
消费者D:0
生产者A:1
消费者D:0
缺货！
生产者C:1
消费者B:0
生产者C:1
消费者B:0
缺货！
生产者A:1
消费者D:0
生产者C:1
消费者B:0
缺货！
生产者A:1
消费者D:0
生产者C:1
消费者B:0
缺货！
生产者A:1
消费者D:0
生产者C:1
消费者B:0
生产者A:1
消费者D:0
缺货！
缺货！

（3）Lock实现生产者和消费者实例

Condition对象中，await、signal和signalAll分别对应Synchronized中wait、notify和notifyAll方法。

package com.algorithm.learn.test.JUC;

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

/**
 * Created by Administrator on 2020/1/16.
 */
public class TestProductorAndConsumer {

    public static void main(String[] args) {
        Clerk clerk=new Clerk();

        Producer producer=new Producer(clerk);
        Consumer consumer=new Consumer(clerk);

        new Thread(producer,"生产者A").start();
        new Thread(consumer,"消费者B").start();
        new Thread(producer,"生产者C").start();
        new Thread(consumer,"消费者D").start();
    }
}

/**
 * 店员
 */
class Clerk{
    private int product=0;

    private Lock lock=new ReentrantLock();

    private Condition condition=lock.newCondition();

    //进货
    public void get(){
        lock.lock();

        try {
            while(product>=1){  //为了避免虚假唤醒问题，应该总是使用在循环中
                System.out.println("产品已满！");
                try {
//                    this.wait();
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //else{
//            System.out.println(Thread.currentThread().getName()+":"+ ++product);
//            this.notifyAll();
//        }
            System.out.println(Thread.currentThread().getName()+":"+ ++product);
//            this.notifyAll();
            condition.signalAll();
        }finally {
            lock.unlock();
        }
    }

    //卖货
    public void sale(){

        lock.lock();
        try {
            while(product<=0){  //为了避免虚假唤醒问题，应该总是使用在循环中
                System.out.println("缺货！");
                try {
//                    this.wait();
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
//        else {
//            System.out.println(Thread.currentThread().getName()+":"+ --product);
//            this.notifyAll();
//        }
            System.out.println(Thread.currentThread().getName()+":"+ --product);
//            this.notifyAll();
            condition.signalAll();
        }finally {
            lock.unlock();
        }
    }
}

/**
 * 生产者
 */
class Producer implements Runnable{

    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            //添加延迟
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.get();
        }
    }
}

/**
 * 消费者
 */
class Consumer implements Runnable{
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            //添加延迟
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.sale();
        }
    }
}

结果：
...
生产者C:1
产品已满！
消费者D:0
缺货！
生产者A:1
消费者B:0
生产者C:1
消费者B:0
生产者A:1
消费者D:0
生产者C:1
产品已满！
消费者B:0
缺货！
生产者A:1
消费者D:0

RayBreslin
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程之Lock锁
weixin_45264992的博客
03-22 136
Java多线程之Lock锁 在我们学习synchronized之后，我们知道了两种办法对进程内对象加速，使得我们的数据安全，一个就是synchronized方法锁，这可以直接对一个方法进行同步，简单除暴，但是仅能获取方法造作的this对象的锁。而另一个就是synchronized代码块，可以对我们选中的代码进行同步，相比第一种，它可以操作不同的对象。 但相比与前两者，我现在要说的是另外一种，Lock锁。 Lock锁由我们手动开启和关闭，且Lock没有方法锁，只有代码块锁。 使用Lock锁，JVM将花费更少的
Java Lock锁多线程中实现流水线任务
08-19
Java Lock锁多线程中实现流水线任务是Java多线程编程中非常重要的一个主题。在多线程编程中，如何保证线程安全和避免死锁是两个主要的问题。Java提供了多种方式来解决这些问题，包括使用synchronized关键字、Lock...
Java多线程中Lock锁的使用总结
08-18
主要介绍了Java多线程中Lock锁的使用总结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java多线程-Lock锁
weixin_45203607的博客
10-03 626
Java多线程-Lock锁 介绍 在 jdk1.5 之后，并发包中新增了 Lock 接口(以及相关实现类)用来实现锁功能，Lock 接口提供了与 synchronized 关键字类似的同步功能，但需要在使用时手动获取锁和释放锁。 Lock 接口与synchronized关键字的区别 Lock 接口可以尝试非阻塞地获取锁 当前线程尝试获取锁。如果这一时刻锁没有被其他线程获取到，则成功获取并持有锁。 Lock 接口能被中断地获取锁 与 synchronized 不同，获取到锁的线程能够响应中断，当获取到的锁的线
Java 多线程-Lock锁
刘伟佳的博客
03-05 276
Lock锁
[Java基础]线程同步之卖票案列分析
m0_51955470的博客
06-08 212
案列: 卖票。 需求: 某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票。 代码如下: package SellTicketPack; public class SellTicket implements Runnable{ private int tickets = 100; @Override public void run() { while (true) { if (tickets
Java多线程基础——Lock类
08-31
Java多线程基础中的Lock类提供了比`synchronized`更强大的同步控制能力。Lock是一个接口，它定义了比`synchronized`更灵活的锁定机制，允许更细粒度的控制。在Java 1.5及之后的版本中引入，Lock类的主要目的是提高...
Java多线程编程之Lock用法实例
09-03
// 解锁 } }}在Java多线程编程中，`Lock`接口是Java并发包(`java.util.concurrent.locks`)提供的一个高级锁机制，相较于传统的`synchronized`关键字，`Lock`提供了更细粒度的锁控制和更多的特性。`Lock`接口提供了...
Java多线程锁机制相关原理实例解析
08-18
Java多线程锁机制相关原理实例解析 Java多线程锁机制是指在Java编程语言中，用于解决多线程并发访问共享资源的机制。该机制主要通过锁机制来实现线程同步，确保多线程之间的安全访问共享资源。 锁机制是Java多线程...
Java多线程_Lock锁
LinJava-X的博客
06-28 146
Lock锁 JDK5.0版本开始，就提供更加强大的线程同步机制，通过显式定义同步锁对象来实现同步，同步锁使用Lock对象来充当 Lock接口控制多个线程对共享资源镜像访问的工具，锁提供了对共享资源的独占访问共享资源之前应先获得Lock对象 ReentrantLock类实现了Lock，它拥有与synchromized相同并性和内存语义，在实现线程安全的控制找那个，比较常用的是ReentrantLock，可以显式加锁，释放锁 经典用例1：没有加锁的情况，数字出现了相同的值。 public class TestL
Synchronized与lock_Allione_新浪博客
dsydly的博客
08-23 96
总结来说，Lock和synchronized有以下几点不同： ​1、ReentrantLock 拥有Synchronized相同的并发性和内存语义，此外还多了 锁投票，定时锁等候和中断锁等候。 线程A和B都要获取对象O的锁定，假设A获取了对象O锁，B将等待A释放对O的锁定， 如果使用 synchronized ，如果A不释放，B将一直等下去，不能...
JAVA多线程——锁Lock
万里顾一程的博客
09-03 1232
JAVA多线程——锁Lock Lock是一个接口，是在JUC包下的，Lock接口是控制多个线程对共享资源进行访问的工具。每次只能有一个线程拿到Lock对象的锁，线程开始访问共享资源前应先获得Lock对象。 不加锁，线程不安全 package com.peng.lock; import java.util.concurrent.locks.ReentrantLock; //测试lock锁 public class TestLock { public static void main(String[
java lock锁_Java多线程之Lock（锁）
weixin_39943101的博客
02-18 144
Java多线程之Lock(锁)定义：在Java多线程中，可以使用synchronized关键字实现线程之间的同步，在JDK5后新增的ReentrantLock类同样可达到此效果，且在使用上比synchronized更加灵活。特征：从JDK5开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步；同步锁使用Lock对象来充当；import java.util.concurren...
使用Lock锁解决线程安全问题
冲出仁川，走出马德里，故事还会再继续
04-22 249
文章目录1、Lock锁2、Lock锁解决线程安全问题3、总结3.1、synchronized 与 Lock的异同？ 1、Lock锁 java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的 工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象 加锁，线程开始访问共享资源之前应先获得Lock对象。 ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和 内存语义，在实现线程安全的控制中，比较常用的是Re
Java-12-多线程(Lock锁)
Void的博客
03-12 138
Java-多线程(Lock锁) 从JDK5.0开始,Java提供了更强大的线程同步机制,通过显式定义同步锁对象来实现同步,同步锁使用Lock对象充当 java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具,锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源前应先获得Lock对象 ReentrantLock(可重入锁)类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控
java多线程06_Lock锁
安德的博客
03-19 223
前面章节我们学习了如何使用关键字synchronized来实现同步访问。本文我们继续来探讨这个问题，从JDK1.5之后，在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问，那就是Lock。 也许有朋友会问，既然都可以通过synchronized来实现同步访问了，那么为什么还需要提供Lock？这个问题将在下面进行阐述。本章节先从synchronized的缺陷讲...
java之多线程(三)——lock锁解决线程安全问题
最新发布
weixin_42902126的博客
07-07 417
Lock(锁) 1、从JDK 5.0开始，java提供了更加强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。 2、*java.util.concurrent.locks.Lock接口时控制多个线程对共享资源进行访问的工具。*锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。 3、ReentrantL...
JAVA基础-多线程中锁机制
骑牛小道士
11-22 2608
JAVA基础-多线程锁机制
Java多线程学习（五）Lock锁的使用
陈东东的博客
11-01 421
Lock接口 1.Lock接口介绍 锁是用于通过多个线程控制对共享资源的访问的工具。通常，锁提供对共享资源的独占访问：一次只能有一个线程可以获取锁，并且对共享资源的所有访问都要求首先获取锁。 但是，一些锁可能允许并发访问共享资源，如ReadWriteLock的读写锁。 在Lock接口出现之前，Java程序是靠synchronized关键字实现锁功能的。JDK1.5之后并发包中新增了Lock接口以...
Java多线程：死锁防范与Lock锁的应用
在Java多线程编程中，死锁是一种常见的并发问题，当多个线程相互等待对方释放资源而陷入僵局时，就会发生死锁。死锁通常由以下原因导致： 1. **线程之间的资源竞争**：当两个或更多线程各自持有部分资源，并且都在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值