java多线程（一）线程间同步传统方式，线程的唤醒

最新推荐文章于 2022-06-02 17:59:43 发布
最新推荐文章于 2022-06-02 17:59:43 发布
阅读量199 收藏
点赞数
分类专栏： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bck1453925668/article/details/108041363
版权

1.synchronized

本质：队列    锁  
特点：java关键字  比较慢
 

public class synchronizedTest {
    public static void main(String[] args) {
        Data data = new Data();

        for (int i = 0; i <30 ; i++) {
            new Thread(()->{
                data.sale();
            },"A").start();
        }
        for (int i = 0; i <30 ; i++) {
            new Thread(()->{
                data.sale();
            },"B").start();
        }
    }
}


class Data{
    private int num=50;
    public synchronized void sale(){   //传统方式
        synchronized (this){    }
        if (num>0){
            System.out.println(Thread.currentThread().getName()+"卖票: "+num--);
        }
    }
}

2.锁

public interface java.util.concurrent.locks.Lock
所有已知实现类：ReentrantLock(可重入锁 常用) ， ReentrantReadWriteLock.ReadLock ， ReentrantReadWriteLock.WriteLock

Lock实现提供比使用synchronized方法和语句可以获得的更广泛的锁定操作。 它们允许更灵活的结构化，可能具有完全不同的属性，并且可以支持多个相关联的对象Condition 。

随着这种增加的灵活性，额外的责任。 没有块结构化锁定会删除使用synchronized方法和语句发生的锁的自动释放。 在大多数情况下，应使用以下惯用语：

   Lock l = ...; l.lock(); try { // access the resource protected by this lock } finally { l.unlock(); }

ReentrantLock()

公平锁：可以先来后到
非公平锁 ： 可以插队   
 

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

public class LockTest {
    public static void main(String[] args) {
        Data2 data = new Data2();

        new Thread(()->{
            for (int i = 0; i <30 ; i++) {
                data.sale();
            } },"A").start();
        new Thread(()->{
            for (int i = 0; i <30 ; i++) {
                data.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i <30 ; i++) {
                data.sale();
            }
        },"C").start();
    }
}


class Data2{
    private int num=50;
    Lock lock=new ReentrantLock();
    public  void sale(){
        lock.lock();  //加锁
        try {    //  业务代码
            if (num>0){
                System.out.println(Thread.currentThread().getName()+"卖票: "+num--);
            }
        }catch (Exception e){

        }finally {
            lock.unlock();   //解锁
        }

    }
}

synchronized和lock区别

1. synchronize 内置关键字      lock  一个java类
2.synchronize  无法判断锁的状态   lock 可以获取状态
3.synchronize  自动释放锁   lock 需要手动释放锁，死锁
4.synchronize  线程1（获得锁，等待）线程2（一直等待）； lock：不一定会带等待下去
5.synchronize  可重入锁 不可以中断 非公平   lock：可重入锁 可以判断锁 非公平（可以设置）
6.synchronize  适合少量代码同步问题   lock适合大量同步代码块

可以尝试获取锁

 

生产者消费者问题 传统sync方式

import jdk.nashorn.internal.ir.CallNode;

public class ProductConsumer {
    public static void main(String[] args) {
        Data3 data3 = new Data3();
        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                try {
                    data3.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 30 ; i++) {
                try {
                    data3.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                try {
                    data3.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(()->{
            for (int i = 0; i < 30 ; i++) {
                try {
                    data3.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();

    }
}

class Data3{
    private int num=0;

    public synchronized void increment() throws InterruptedException {
        if (num!=0){   // 会出现负值 使用while 解决 // while (num==0){
            //等待
            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName()+">>"+num);
        //通知其他线程
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        if (num==0){    // while (num==0){
            //等待
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName()+">>"+num);
        //通知其他线程
        this.notifyAll();
    }
}




//此处结果会出现 负值

产生了虚假唤醒问题  if 使用while代替

 

生产者消费者问题 JUC方式

Lock lock=new ReentrantLock();
Condition condition = lock.newCondition();
condition.await();
condition.signalAll();
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class newConditionTest {
    public static void main(String[] args) {
        Data4 data3 = new Data4();
        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                try {
                    data3.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 30 ; i++) {
                try {
                    data3.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}

class Data4{
    private int num=0;
    Lock lock=new ReentrantLock();
    Condition condition = lock.newCondition();

    public  void increment() throws InterruptedException {
        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 decrement() throws InterruptedException {
        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();
        }
    }
}

不是有序的A-》B   C-》D

指定唤醒相应线程

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

public class newConditionTest2 {
    public static void main(String[] args) {
        Data5 data5 = new Data5();
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                data5.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                data5.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                data5.printC();
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                data5.printD();
            }
        },"D").start();
    }
}

class Data5{
    private int num=0;
    Lock lock=new ReentrantLock();
    Condition conditionA = lock.newCondition();    //指定唤醒相应线程
    Condition conditionB = lock.newCondition();
    Condition conditionC = lock.newCondition();
    Condition conditionD = lock.newCondition();

    public void printA(){
        lock.lock();
        try {
            while (num!=0){
                //等待
                conditionA.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName()+">>"+num);
            //通知其他线程
            conditionB.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try {
            while (num==0){
                //等待
                conditionB.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName()+">>"+num);
            //通知其他线程
            conditionC.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
            while (num!=0){
                //等待
                conditionC.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName()+">>"+num);
            //通知其他线程
            conditionD.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printD(){
        lock.lock();
        try {
            while (num==0){
                //等待
                conditionD.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName()+">>"+num);
            //通知其他线程
            conditionA.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

 

 

 

bck1453925668
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 实现线程同步的方式有哪些
09-05
当使用多个线程来访问同一个数据时，非常容易出现线程安全问题,所以我们用同步机制来解决这些问题,本文将详细介绍，需要的朋友可以参考下
多线程-线程间通信和等待唤醒
a1303048872_的专栏
10-19 554
线程间通信： 不同的线程操作同一个资源。 等待/唤醒机制。  涉及的方法： 1，wait(): 让线程处于冻结状态，被wait的线程会被存储到线程池中。 2，notify():唤醒线程池中一个线程(任意). 3，notifyAll():唤醒线程池中的所有线程。 这些方法都必须定义在同步中。 因为这些方法是用于操作线程状态的方法。 必须要明确到底操作的是哪个
Java线程同步的几种方式
qq_39870233的博客
06-02 666
Java线程同步的几种方式
Java多线程之同步控制
搬砖刘疯狂
03-19 652
这里将介绍synchronized关键字和其他丰富多彩的多线程控制方法。 一，synchronized同步锁 synchronized关键字的作用：1. 线程同步。2. 保证线程的可见性和有序性。 synchronized关键字有三种用法分别是： 修饰非静态方法。获得的是对象锁。 修饰静态方法。获得类锁。 静态代码块。两种用法：1. synchronized（对象）对象锁。2.syn...
Java多线程四:线程间通信/等待唤醒机制
小白成长记录
08-10 917
多线程等待唤醒机制介绍线程间通信方式 1、全局变量(基于内存共享) 2、Message消息机制 备注:基于内存共享比较容易实现 如果多线程只是处理完全相同的任务时，那么事情就简单了，似乎也不需要线程之间相互协同。如果多线程处理的业务需要相互协同的话，那么线程之间就要进行协同和通信了。 最典型的例子就是生产者和消费者模型。 Java在Object对象中就定义了几个关于等待唤醒机制的方法 1、publi
java多线程之线程同步七种方式代码示例
08-28
在Java多线程编程中，线程同步是一个关键的概念，用于解决多个线程并发访问共享资源时可能出现的数据不一致问题。下面将详细讲解Java中实现线程同步的七种方式。 1. 同步方法 同步方法是通过在方法声明上使用`...
深入理解JAVA多线程之线程间的通信方式
09-02
在Java多线程编程中，线程间的通信是至关重要的，因为它确保了多个并发执行的任务能够协调工作，避免数据不一致性和死锁等问题。本文将深入探讨两种主要的线程间通信方式：同步机制和基于轮询的方式。 1. 同步机制...
深入解析Java的线程同步以及线程间通信
09-03
总之，Java的线程同步和线程间通信是多线程编程中的关键概念，通过`synchronized`关键字、同步块和监视器锁，以及`wait()`, `notify()`, `notifyAll()`等方法，可以有效地管理共享资源，避免并发问题，并实现线程间...
java基本教程之java线程等待与java唤醒线程 java多线程教程
09-04
Java线程等待与唤醒是多线程编程中的关键概念，它们允许线程间协作和同步。在Java中，这些功能是通过Object类提供的wait(), notify()和notifyAll()方法实现的，而不是在Thread类中，因为这些方法涉及到对对象监视器...
Java 线程间通信-等待唤醒机制
风中的劲草
01-13 307
在上一篇博客Java 线程通信的安全问题(同步) 遗留一个问题，当输入线程(Input)操作资源(res)完成后，失去执行权，输出线程(outPut)在一些短时间内刻获取cpu执行权，就会疯狂打印这结果。那么，我们如何解决这个问题呢？分析： 我们期望的结果是,当输入线程一次(Input)操作资源(res)后，我们希望输入线程 (Input)失去执行权，让输出线程(outPut)获取cpu执行权，当输
线程同步
qq_44702678的博客
04-13 201
线程同步 按照百度的简介： 在一般情况下，创建一个线程是不能提高程序的执行效率的，所以要创建多个线程。但是多个线程同时运行的时候可能调用线程函数，在多个线程同时对同一个内存地址进行写入，由于CPU时间调度上的问题，写入数据会被多次的覆盖，所以就要使线程同步。 同步就是协同步调，按预定的先后次序进行运行。如：你说完，我再说。 “同”字从字面上容易理解为一起动作 其实不是，“同”字应是指协同、协助、互...
Java多线程 — — lock、await 、signal 组合 替换 sync、wait、notifyAll，实现精准唤醒线程...
有人想浑水摸鱼，我必须站在清水中
12-20 229
接上篇博客我们使用老旧的多线程API实现了线程间通信， 但是为了让线程运行的更有效率， 本篇我们采用lock、await 、signal 新特性， 进行再次酿造， 旧瓶子，装点新酒 需求： 很简单，要求顺次打印1次A，2次B，3次C，循环来10遍。 废话不多说，直接上源码： package ldk.test; import java.util.concurrent.locks.Condi...
java线程同步后唤醒_java 线程同步方法执行与唤醒实例
weixin_39577908的博客
02-16 93
账号提钱、存钱实例方法public class account {private int balance;private int maxbalance;public account(int balance){this.balance=balance;}//同步方法 取钱public synchronized void transferout(int money) {//线程同步//synchro...
多线程使用Lock锁实现精准唤醒
weixin_53044548的博客
07-05 199
package demo; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class ThreadDemo { public static void main(String[] args) { Ticket ticket = new Ticket
Java 线程同步 - 7种方式
Simple 专栏
02-03 3392
为何要使用同步？       java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），      将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，      从而保证了该变量的唯一性和准确性。 1.同步方法      即有synchronized关键字修饰的方法。      由于java的每个对象都有一个内置...
java线程同步的实现方式
SlagSea
03-08 1万+
这里抛砖引玉，为何要使用同步？ 当多个线程同时操作一个可共享的资源时会出现线程安全问题，将会导致数据不一致，因此使用同步锁来防止该操作执行完之前不许被其他线程执行，从而保证了该变量的唯一性和准确性。下面总结一些java线程实现同步方式，大致有下面几种： 1.同步方法 使用 synchronized关键字，可以修饰普通方法、静态方法，以及语句块。由于java的每个对象都有一个内置锁...
java多线程同步5种方法
热门推荐
weixin_39214481的博客
05-28 4万+
一、引言前几天面试，被大师虐残了，好多基础知识必须得重新拿起来啊。闲话不多说，进入正题。二、为什么要线程同步因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常。举个例子，如果一个银行账户同时被两个线程操作，一个取100块，一个存钱100块。假设账户原本有0块，如果取钱线程和存钱线程同时发生，会出现什么结果呢？取钱不...
Java中多线程同步的6种方式和ThreadLocal
哈哈彬的博客
07-27 2194
网上有些资料将使用ThreadLocal也定义为多线程同步的一种方式，但是多线程同步的前提是变量共享。 ThreadLocal并不是为了解决多线程间共享变量的问题。举个例子，在一个电商系统中，用一个Long型变量表示某个商品的库存量，多个线程需要访问库存量进行销售，并减去销售数量，以更新库存量。在这个场景中，是不能使用ThreadLocal类的。 ...
java 同步线程方式
延成的博客
05-19 2898
Java并发编程包含三个基本概念: 原子性：一（多）个操作要么全部执行要么不执行，中途不会被打断； 可见性：一个线程对某变量的修改对其他线程来说是可见的，即能知道值进行过修改； 有序性：程序执行按照代码的顺序执行； 1.同步方法 使用synchronized关键字 public static void main(String[] args){ Increase increase = new Increase(); int count = 10; whil
Java多线程：理解并实践线程间通信与等待唤醒机制
Java多线程-线程间的通信 在Java编程中，处理线程间的通信是至关重要的，尤其是在需要多个线程协同工作的场景下，如生产者消费者模型（例如，一个线程负责生产包子，另一个线程负责消费）。线程间的通信主要通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值