【Java语言学习】Synchronized和Lock锁的区别 , 生产者消费者问题的多种实现方式

最新推荐文章于 2022-04-25 15:57:48 发布
最新推荐文章于 2022-04-25 15:57:48 发布
阅读量104 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44126342/article/details/113510377
版权

文章目录

Synchronized 和 Lock的区别

1.Synchronized是java内置的关键字 , Lock是一个java类
2.Synchronized无法获取锁的状态 , Lock可以判断是否活得锁
3.Synchronized代码执行完立即释放锁, Lock需要手动开关,不释放就会死锁
4.Synchronized可重入锁,不可以中断,非公平 , Lock, 可重入锁,可以判断锁,公平性可以自己设置
5.Synchronized如果某个线程获得锁后被阻塞,那Synchronized的另一个线程就会一直处于等待状态,Lock锁加锁的两个线程不会生生这种死锁

唤醒方式

Synchronized  {
    //阻塞
    this.wait
    //唤醒
    this.notify() || this.nitifyAll();
}

Lock {
    //加锁 
    lock.lock();
    //释放锁
    lock.unlock();//一般加在finally中 , try中处理事务
    //监视器
    CCondition condition = lock.newCondition(); 
    //通过监视器阻塞和唤醒
    //阻塞
    condition.await();
    //唤醒
    condition.signal(); || condition.signalAll();
}

生产者消费者问题的实现

传统Synchronized实现

以下的线程均放在(lamda表达式中)

package com.cxy.javathread.myself;

public class A {

    public static void main(String[] args) {
        th th = new th();
        
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    th.incred();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    th.decred();;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    th.incred();;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    th.decred();;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

class th{
    int num = 0;
    public synchronized void incred() throws InterruptedException {
        if (num!=0){
           this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"->"+num);
        this.notifyAll();
    }
    public synchronized void decred() throws InterruptedException {
        if(num==0){
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName()+"->"+num);
        this.notifyAll();
    }
}

运行发现上述代码有一个问题

虚假唤醒现象
A->1
B->0
A->1
B->0
A->1
B->0
A->1
B->0
A->1
B->0
A->1
B->0
C->1
B->0
A->1
B->0
C->1
B->0
A->1
B->0
C->1
D->0
C->1
A->2
C->3
D->2
D->1
D->0
C->1
A->2
C->3
D->2
D->1
D->0
C->1
D->0
C->1
D->0
C->1
D->0

Process finished with exit code 0

当只有两个线程在相互唤醒的过程中 , 两个线程交替打印 , 但是当线程多了以后,会发生虚假唤醒现象

所以需要吧 if 换成 while

if(num!=0){
    this.wait();
}
//换成
while(num!=0){
    this.wait();
}

package com.cxy.javathread.myself;

public class A {

    public static void main(String[] args) {
        th th = new th();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    th.incred();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    th.decred();;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    th.incred();;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    th.decred();;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

class th{
    int num = 0;
    public synchronized void incred() throws InterruptedException {
        if (num!=0){
           this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"->"+num);
        this.notifyAll();
    }
    public synchronized void decred() throws InterruptedException {
        if(num==0){
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName()+"->"+num);
        this.notifyAll();
    }
}

发现结果正确

//发现结果没用任何问题
A->1
B->0
A->1
B->0
A->1
B->0
A->1
B->0
C->1
B->0
A->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
C->1
D->0
A->1
D->0
C->1
D->0
C->1
D->0
C->1
D->0
C->1
D->0

Process finished with exit code 0

Lock锁

Lock锁使用Condition作为监视器来完成唤醒与阻塞

package com.cxy.javathread.myself;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class B {

    public static void main(String[] args) {
        th2 th = new th2();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                th.incred();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                th.decred();;
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                th.incred();;
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                th.decred();;
            }
        },"D").start();
    }
}

class th2{
    int num = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    public  void incred(){
        lock.lock();
        try {
            while (num!=0){
                condition.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName()+"->"+num);
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public  void decred(){
        lock.lock();
        try {
            while(num==0){
                condition.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName()+"->"+num);
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

精确唤醒的Lock锁

package com.cxy.javathread.myself;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class C {
    public static void main(String[] args) {
        th3 th = new th3();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                th.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                th.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                th.printC();
            }
        },"C").start();
    }
}
class th3{
    private int num = 1;
    private Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    public void printA(){
        lock.lock();
        try {
            //事务
            while(num!=1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"--->aaa--->"+num);
            num = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try {
            //事务
            while(num!=2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"--->bbb--->"+num);
            num = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
    public void printC(){
        lock.lock();
        try {
            //事务
            while(num!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"--->ccc--->"+num);
            num = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

运行结果

​ 交替打印

A--->aaa--->1
B--->bbb--->2
C--->ccc--->3
A--->aaa--->1
B--->bbb--->2
C--->ccc--->3
A--->aaa--->1
B--->bbb--->2
C--->ccc--->3
A--->aaa--->1
B--->bbb--->2
C--->ccc--->3
A--->aaa--->1
B--->bbb--->2
C--->ccc--->3
A--->aaa--->1
B--->bbb--->2
C--->ccc--->3
A--->aaa--->1
B--->bbb--->2
C--->ccc--->3
A--->aaa--->1
B--->bbb--->2
C--->ccc--->3
A--->aaa--->1
B--->bbb--->2
C--->ccc--->3
A--->aaa--->1
B--->bbb--->2
C--->ccc--->3

Process finished with exit code 0
白、º(陈*)
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java多种方式实现生产者消费者模式
08-18
Java多种方式实现生产者消费者模式 Java中实现生产者消费者模式有多种方式，...生产者消费者模式是一种经典的多线程同步模式，Java中有多种方式可以实现生产者消费者模式，选择合适的实现方式取决于具体的应用场景。
java生产者消费者问题代码实现
最新发布
12-25
Java 生产者消费者问题是计算机科学中的一种经典同步问题，它描述了多个生产者和消费者之间的关系，生产者负责生产数据，而消费者负责消费数据。在解决这个问题时，需要使用同步机制来确保生产者和消费者之间的正确...
【多线程】生产者消费者问题（Synchronized和Lock版本实现）
历乱的日记簿
05-05 116
一、Synchronized和Lock 【追根溯源】Sychronized 是Java内置的关键字，而Lock是一个类 【自动挡与手动挡】Sychronized 自动释放锁，而Lock是手动释放（unlock）。（假如没有手动释放，就会造成死锁） 【锁的状态】Sychronized 不能获取锁的状态，Lock可以； 【在一棵树上吊死】Sychronized 当一个线程获取资源的锁，那么另外想要该资源的线程会一直等待，而Lock有tryLock，超时放弃等待； 【锁的量】Sychronized 适用于锁少量
Java多线程生产者与消费者模型（分别使用synchronized和重入锁实现）
qq_38041105的博客
05-30 235
synchronized实现： 消费者： public class ConsumerThread implements Runnable { private Goods goods; @Override public void run() { //消费者 while(true){ //厂库不空则消费 synchronized (ThreadDemo.queue) { try
如何用synchronized和lock锁实现生产者和消费者模式
m0_53917137的博客
03-05 134
1.synchronized 2.Lock锁
Java语言synchronized与lock实现生产者消费者
dahongwudi的专栏
10-10 570
这个配合生产者，消费者问题来看最适合不过了，上代码package test;import java.util.LinkedList; import java.util.Queue; import java.util.Random;public class ProducerConsumer { public static void main(String args[]) { Q
java中lock在买票_JAVA并发（12）— Lock实现生产者消费者
weixin_35940949的博客
02-27 121
无论是synchronize还是Lock，均可以将其看做为Monitor模型。1. 条件变量&生产者消费者模型在Monitor管程中，存在条件变量。条件变量是管程内的一种数据结构，且只有在管程中才能访问它，它对管程内的所有过程是全局的。只能通过两个原子性操作来操纵它：c.wait()：将调用线(进)程移入条件变量c所持有的队列中，并释放管程，直到另一个线(进)程在条件变量c上调用signa...
Java基于Lock的生产者消费者模型示例
08-27
本示例中，我们使用了Lock和Condition来实现生产者消费者模型，避免了使用synchronized关键字的方式，而是使用了Lock和Condition来实现线程同步和通信，提高了程序的性能和可读性。 知识点： * Java中的生产者消费...
Java实现生产者消费者问题与读者写者问题详解
08-28
Java语言在多线程编程中提供了对同步机制的良好支持，解决生产者/消费者问题的方法可分为两类：（1）采用某种机制保护生产者和消费者之间的同步；（2）在生产者和消费者之间建立一个管道。以下是 Java 实现生产者...
Lock、Condition实现简单的生产者消费者模式示例
09-04
在Java多线程编程中，生产者消费者模式是一种常见的设计模式，用于协调生产者线程和消费者线程之间的协作，确保资源的有效利用和同步。在这个示例中，使用了Java的`java.util.concurrent.locks`包中的`Lock`接口和`...
java lock 信号_Java并发编程初级篇(十六)：Lock+Condition实现生产者消费者问题
weixin_28852151的博客
02-16 155
之前我们在“Java并发编程初级篇(十二)：使用wait和notify生产者消费者问题”，已经使用Java提供的synchronized关键字和wait()，notify()，notifyAll()方法实现过来生产者消费者问题。Java API还为我们提供了锁的解决方案。使用锁解决阻塞要用到Condition，它是通过Lock.newCondition()来获得的。就像wait()和notify(...
java多线程Lock synchronized Callable 生产者消费者
zzwpublic的专栏
09-15 96
只是个人的一个示例，怕忘，记录一下。要弄清锁的到底是什么东东，一般就是锁的对象（具体的实例对象，对同一个对象操作才需要锁） Callable纯属自己瞎玩，实在不知道生产都消费者用这个接口怎么玩。 JucLock.java 通过Lock 和 Condition实现ABCD 4个线程按顺序执行，实现生产者消费者功能 package juc; import java.util.concurrent.locks.Condition; import java.util.concurrent.lo.
Java并发编程-Lock锁与生产者消费者问题
Java硬件工程师的博客
12-31 2839
传统Synchronized锁 实现一个基本的售票例子： /* 真正的多线程开发，公司中的开发,降低耦合性 线程就是一个单独的资源类，没有任何附属的操作 1.属性，方法 * */ public class SaleTicketDemo1 { public static void main(String[] args) { //并发，多个线程操作同一个资源类,把资源类丢入线程 Ticket ticket=new Ticket(); //Runnable
synchronized和Lock的区别及生产者消费者模型的三种实现方式
知易行难
07-11 131
1、原始构成 sync是关键字属于JVM层面， monitorenter（底层通过monitor对象来完成，其实wait/notify等方法也依赖monitor对象，只有在同步代码块或方法中才能调用wait/notify等方法） montitorexit Lock是具体类（java.util.concurrent.locks.Lock）是API层面的锁 2、使用方法 sync不需要手动去释放锁，当sync代码完成后系统会自动让线程释放对锁的占用，不会产生死锁。 ReentrantLock 则需要手动去
Lock实现生产者消费者问题
qq_45979629的博客
01-03 321
什么是生产者消费者问题？ 所谓的生产者消费者问题，是通过一个容器来解决生产者和消费者的强耦合问题。通俗的讲，就是生产者在不断的生产，消费者也在不断的消费，可是消费者消费的产品是生产者生产的，这就必然存在一个中间容器，我们可以把这个容器想象成是一个货架，当货架空的时候，生产者要生产产品，此时消费者在等待生产者往货架上生产产品，而当货架满的时候，消费者可以从货架上拿走商品，生产者此时等待货架的空位，这样不断的循环。那么在这个过程中，生产者和消费者是不直接接触的，所谓的‘货架’其实就是一个阻塞队列，生产者..
面试突击42：synchronized和ReentrantLock有什么区别？
qwer123451234123的博客
04-25 125
在 Java 中，常用的锁有两种：synchronized（内置锁）和 ReentrantLock（可重入锁），二者的功效都是相同得，但又有很多不同点，所以我们今天就来聊聊。 区别1：用法不同 synchronized 可用来修饰普通方法、静态方法和代码块，而 ReentrantLock 只能用在代码块上。 synchronized 基础使用 使用 synchronized 修饰代码块： publicvoidmethod(){ //加锁代码 synchronized(t...
Java基于Lock锁来实现生产者消费者
华安小书童的博客
02-12 546
自己基于网上内容改编了一个，防止以后面试找不到上传一份。里面主要由生产者先进行生产10个物品之后，消费者开始消费。消费者消费一次用2秒，生产者生产一份需要1秒。 生产者代码 package com.macro.mall.demo.test.thread.productconsumer.lock; import java.util.LinkedList; import java.util.conc...
java生产者消费者简单代码--用的Lock锁
Jerry_run的博客
03-27 341
一共四个类 类名分别是 TestStudent -----Student -------Producer ------Consumer 个人理解 --- 只有消费者和生产者构不成消费者/生产者模式 ，想要构成该模式还需要一个缓冲区，这个缓冲区在消费者和生产 者之间类似仓库的作用 生产者类似餐厅 --- 制造菜品 ...
java 生产者消费者 例子_Java Lock应用示例-生产者与消费者
weixin_36247910的博客
03-05 146
Java Lock的使用以及与synchronized的区别很多文章已经讲解的很清楚了，这里不再详细讲解，可以参考java Lock讲解.总的来说Lock的功能比synchronized更强大，功能更多，但一般的线程同步业务synchronized已经能够满足，对于一些特殊的要求，比如要知道线程获取锁的结果，线程获取锁时没有获取到，要求等待一段时间后仍没获取到就不去获取了，去做别的事情或者等待锁的...
Java：分别利用 synchronized、Lock和阻塞队列的方法模拟生产者-消费者的同步问题。 分别利用 synchronized、Lock和阻塞队列的方法实现交替输出ABABABAB。
06-08
生产者-消费者同步问题的模拟： 使用synchronized： ```java public class ProducerConsumer { private static final int BUFFER_SIZE = 10; private static final Object lock = new Object(); private ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值