Java 线程同步 synchronized 和 Lock 锁

已于 2023-02-13 20:00:16 修改
阅读量346 收藏
点赞数
文章标签： java jvm 开发语言
于 2023-02-13 16:06:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52515449/article/details/129007469
版权

线程同步 synchronized 和 Lock 锁

并发：同一个对象被多个线程同时操作

  • 处理并发问题，并且某些线程还想修改这个对象，这时候我们就需要线程同步。
  • 相乘同步就是一种等待机制，多个需要同时访问此对象的线程进入对象的等待池形成队列，等待前面线程使用完毕，下一个线程在使用

线程不安全例子

不安全的买票
package com.syn;

/*
    不安全的买票
        线程不安全，有负数
 */
public class UnsafeBuyTicket {


    public static void main (String[] args) {
        BuyTicket station = new BuyTicket ();

        new Thread (station,"苦逼的我").start ();
        new Thread (station,"牛逼的你们").start ();
        new Thread (station,"可恶的黄牛党").start ();
    }
}

class BuyTicket implements Runnable{

    //票
    private int ticketNums = 10;
    boolean flag = true;//外部停止方式
    @Override
    public void run () {
        while (flag){
            try {
                buy ();
            } catch (InterruptedException e) {
                e.printStackTrace ();
            }
        }
    }

    private void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNums<=0){
            flag = false;
            return;
        }
        //模拟延时
        Thread.sleep (100);
        //买票
        System.out.println (Thread.currentThread ().getName ()+"拿到了第 "+ticketNums--+" 张票");
    }
}

在这里插入图片描述

不安全的取钱
package com.syn;

import com.oop.demo05.A;

/*
    不安全的取钱
        两个人取钱，去银行
 */
public class UnsafeBank {
    public static void main (String[] args) {
        //账户
        Account account = new Account (100,"结婚基金");

        Drawing husband = new Drawing (account,50,"husband");
        Drawing wife = new Drawing (account,100,"wife");

        husband.start ();
        wife.start ();
    }
}

//账户
class Account{
    int money;//余额
    String name;//卡名

    public Account (int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行:模拟取款
class Drawing extends Thread{
    Account account;//账户
    int drawingMoney;//取了多少钱
    int nowMoney;//现在手里有多少钱

    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取钱
    @Override
    public void run () {
        //判断有没有钱
        if (account.money-drawingMoney<0){
            System.out.println (Thread.currentThread ().getName ()+"钱不够，取不了");
            return;
        }

        //sleep 可以放大问题的发生性
        try {
            Thread.sleep (1000);
        } catch (InterruptedException e) {
            e.printStackTrace ();
        }

        //卡内余额 = 余额 - 你取出的钱
        account.money = account.money - drawingMoney;
        //你手里的钱
        nowMoney = nowMoney + drawingMoney;

        System.out.println (account.name+"余额为："+account.money);
        //this.getName () = Thread.currentThread ().getName ()
        System.out.println (this.getName ()+"手里的钱："+nowMoney);
    }
}

在这里插入图片描述

不安全的List
package com.syn;

import java.util.ArrayList;
import java.util.List;

public class UnsafeList {
    public static void main (String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String> ();
        for (int i = 0; i < 10000; i++) {
            new Thread (()->{
                list.add (Thread.currentThread ().getName ());
            }).start ();
        }
        Thread.sleep (10);
        System.out.println (list.size ());
    }

}

在这里插入图片描述

队列 和 锁 synchronized

  • 由于同一进程的多个线程共享同一块存储空间，在带来方便的同时,也带来了访问冲突问题﹐为了保证数据在方法中被访问时的正确性﹐在访问时加入锁机制 synchronized,当一个线程获得对象的排它锁,独占资源，其他线程必须等待，使用后释放锁即可﹒存在以下问题:
    • 一个线程持有锁会导致其他所有需要此锁的线程挂起;
    • 在多线程竞争下，加锁﹐释放锁会导致比较多的上下文切换和调度延时,引起性能问题;
    • 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置,引起性能问题．
同步方法
  • 由于我们可以通过private关键字来保证数据对象只能被方法访问﹐所以我们只需要针对方法提出一套机制,这套机制就是synchronized关键字，
  • 它包括两种用法∶synchronized方法和synchronized块.
    同步方法：public synchronized void method(int args)
  • synchronized方法控制对“对象”的访问﹐每个对象对应一把锁﹐每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁,继续执行
    缺陷：若将一个大的方法申明为 synchronized 将会影响效率
    synchronized 同步方法，默认锁的是this
package com.syn;

/*
    不安全的买票
        线程不安全，有负数
 */
public class UnsafeBuyTicket {


    public static void main (String[] args) {
        BuyTicket station = new BuyTicket ();

        new Thread (station,"苦逼的我").start ();
        new Thread (station,"牛逼的你们").start ();
        new Thread (station,"可恶的黄牛党").start ();
    }
}

class BuyTicket implements Runnable{

    //票
    private int ticketNums = 10;
    boolean flag = true;//外部停止方式
    @Override
    public void run () {
        while (flag){
            try {
                buy ();
            } catch (InterruptedException e) {
                e.printStackTrace ();
            }
        }
    }

    //synchronized 同步方法，默认锁的是this
    private synchronized void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNums<=0){
            flag = false;
            return;
        }
        //模拟延时
        Thread.sleep (100);
        //买票
        System.out.println (Thread.currentThread ().getName ()+"拿到了第 "+ticketNums--+" 张票");
    }
}
同步块
synchronized (需要锁的对象){}
  • synchronized (Obj){}
    • Obj可以是任何对象﹐但是推荐使用共享资源作为同步监视器
    • 同步方法中无需指定同步监视器﹐因为同步方法的同步监视器就是this ,就是这个对象本身﹐或者是class
  • 同步监视器的执行过程
    1. 第一个线程访问，锁定同步监视器﹐执行其中代码．
    2. 第二个线程访问﹐发现同步监视器被锁定﹐无法访问．
    3. 第一个线程访问完毕,解锁同步监视器．
    4. 第二个线程访问,发现同步监视器没有锁﹐然后锁定并访问
package com.syn;

import com.oop.demo05.A;

/*
    不安全的取钱
        两个人取钱，去银行
 */
public class UnsafeBank {
    public static void main (String[] args) {
        //账户
        Account account = new Account (1000,"结婚基金");

        Drawing husband = new Drawing (account,50,"husband");
        Drawing wife = new Drawing (account,100,"wife");

        husband.start ();
        wife.start ();
    }
}

//账户
class Account{
    int money;//余额
    String name;//卡名

    public Account (int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行:模拟取款
class Drawing extends Thread{
    Account account;//账户
    int drawingMoney;//取了多少钱
    int nowMoney;//现在手里有多少钱

    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取钱
    @Override
    public void run () {
        //锁 的对象就是变化的量，需要增删改的量
        synchronized (account){
            //判断有没有钱
            if (account.money-drawingMoney<0){
                System.out.println (Thread.currentThread ().getName ()+"钱不够，取不了");
                return;
            }
            //sleep 可以放大问题的发生性
            try {
                Thread.sleep (3000);
            } catch (InterruptedException e) {
                e.printStackTrace ();
            }


            //卡内余额 = 余额 - 你取出的钱
            account.money = account.money - drawingMoney;
            //你手里的钱
            nowMoney = nowMoney + drawingMoney;

            System.out.println (account.name+"余额为："+account.money);
            //this.getName () = Thread.currentThread ().getName ()
            System.out.println (this.getName ()+"手里的钱："+nowMoney);
        }

    }
}

测试JUC安全类型集合

package com.syn;

import java.util.concurrent.CopyOnWriteArrayList;

/*
    测试JUC安全类型集合
 */
public class TestJUC {
    public static void main (String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String> ();
        for (int i = 0; i < 10000; i++) {
            new Thread (()->{
                list.add (Thread.currentThread ().getName ());
            }).start ();
        }

        try {
            Thread.sleep (3*1000);
        } catch (InterruptedException e) {
            e.printStackTrace ();
        }

        System.out.println (list.size ());
    }
}

Lock（锁）

  • 从JDK5.0开始，Java提供了更强大的线程同步机制----通过显示定义同步锁对象来实现同步。
  • 同步锁还用Lock对象充当
  • java.util.concurrent.looks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
  • ReentrantLock类实现了Lock，他拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可是显示加锁、释放锁

使用方式：

class A{
    private final ReentrantLock lock = new ReentrantLock ();
    public void m(){
        lock.lock ();
        try {
            //保证线程代码安全
        }finally {
            //如果同步代码有异常，要将unlock()写入finally语句块
            lock.unlock ();
        }
    }
}

买票案例

package com.senior;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main (String[] args) {
        Lock2 lock2 = new Lock2 ();

        new Thread (lock2,"me").start ();
        new Thread (lock2,"you").start ();
        new Thread (lock2,"others").start ();
    }
}
class Lock2 implements Runnable{
    private int ticketNums = 10;

    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock ();

    @Override
    public void run () {
        while (true){
            try {
                lock.lock ();//加锁
            if (ticketNums<=0){
                break;
            }else {
                System.out.println (Thread.currentThread ().getName ()+"获得了第 "+ticketNums--+" 票");
            }
            } finally {
                //解锁
                lock.unlock ();
                try {
                    Thread.sleep (10);
                } catch (InterruptedException e) {
                    e.printStackTrace ();
                }
            }

        }
    }
    
}

synchronized 与 Lock 对比

  • lock是显示锁（手动开启和关闭锁，别忘记关闭锁）synchronized 是隐士锁，出了作用域自动释放
  • Lock 只有代码块锁，synchronized 有代码块锁和方法锁
  • 使用Lock锁，JVM将花费更少的时间调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
  • 优先使用顺序：
    • Lock > 同步代码快（已经进入了方法体，分配了相应资源）> 同步方法（在方法体之外）
一只理智汪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java SYN Scan (Jpcap)
03-28
NULL 博文链接：https://steven2011.iteye.com/blog/1204454
Java多线程之synchronized
qq_35716085的博客
07-20 6146
synchronized具有同步功能，是一种互斥锁，锁的是对象。如果既想保证共享变量的可见性和有序性，又想保证原子性，那么synchronized关键字是一个不错的选择。synchronized的缺点：1.synchronized底层是由jvm实现，因此不能手动控制锁的释放，不如lock锁灵活，synchronized修饰的方法一旦出现异常，jvm保证锁会被释放（lock锁需要在finally中释放）。2.synchronized是非公平锁，不保证公平性。
java中的锁(一)(Synchronized)
vividcycle的博客
11-08 1936
Synchronized
java线程锁 synchronized
weixin_33918357的博客
05-21 57
//java锁是对同一个对象或者同一个对象中的方法加锁；关键是同一个 错误的加锁方式 public class MyWaitNotify {public static void main(String[] args) {MyT m1=new MyT("A");MyT m2=new MyT("B");m1.start();m2.start();} } ...
java线程---线程锁synchronized和Lock
weixin_43145539的博客
05-15 243
什么是线程锁 多线程可以同时执行多个任务，但是当多个线程同时访问同一个数据时，可能导致数据不同步，甚至错误！ 打个比方，你在银行里面存了一百万，这个时候你需要从里面取走九十万，你女朋友也要从里面取五十万，如果没有用线程锁，那么你们两个人同时取钱，就有可能导致线程错误，你们总共从银行取走一百四十万元，那么银行就会亏本，所以要用线程锁。 synchronized和Lock的区别 线程锁分synchronized和Lock，那么他们之间有什么区别呢？ 区别 synchronized Lock 锁的
Java线程同步synchronized,Lock,Condition
u014412719的博客
04-19 235
参考 http://www.infoq.com/cn/articles/java-memory-model-5 深入理解Java内存模型（五）——锁 http://www.ibm.com/developerworks/cn/java/j-jtp10264/ Java 理论与实践: JDK 5.0 中更灵活、更具可伸缩性的锁定机制 http://blog.csdn.net/ghsau/ar
java线程锁之synchronized
weixin_30836759的博客
12-13 42
声明：该博客参考https://www.cnblogs.com/kaituorensheng/p/10079916.html，感谢哥们。 1、Sync.java package com.cn.commodity.config; public class Sync { public synchronized void test() { System.out....
lock锁，lock锁和synchronized的对比
11-19
JDK5.0后Java提供了一种更加强大的线程同步机制。一种显式定义同步锁对象来实现锁，提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock锁。 # synchronized锁与...
线程同步Synchronized，监视器monitor和锁lock的关系3---马克-to-win java视频
06-10
线程同步Synchronized，监视器monitor和锁lock的关系2---马克-to-win java视频
深入解析Java并发程序中线程的同步与线程锁的使用
09-02
主要介绍了深入解析Java并发编程中线程的同步与线程锁的使用,synchronized和lock是Java中最常见的控制线程的方法,需要的朋友可以参考下
线程同步Synchronized，监视器monitor和锁lock的关系1---马克-to-win java视频
06-10
线程同步Synchronized，监视器monitor和锁lock的关系1---马克-to-win java视频
线程同步Synchronized，监视器monitor和锁lock的关系2---马克-to-win java视频
06-10
线程同步Synchronized，监视器monitor和锁lock的关系2---马克-to-win java视频
Java线程锁Synchronized
qq_33411202的博客
10-24 229
什么是线程锁？ 在并发编程中，经常遇到多个线程访问同一个 共享资源 ，这时候作为开发者必须考虑如何维护数据一致性，在java中synchronized关键字被常用于维护数据一致性。synchronized机制是给共享资源上锁，只有拿到锁的线程才可以访问共享资源，这样就可以强制使得对共享资源的访问都是顺序的。 java中的锁 一般在java中所说的锁就是指的内置锁，每个java对象都可以作为一个实现...
java 线程锁synchronized_Java多线程4：synchronized锁机制
weixin_31001069的博客
02-13 207
脏读一个常见的概念。在多线程中，难免会出现在多个线程中对同一个对象的实例变量进行并发访问的情况，如果不做正确的同步处理，那么产生的后果就是"脏读"，也就是取到的数据其实是被更改过的。按照正常来看应该打印"a num = 100"和"b num = 200"才对，现在却打印了"b num = 200"和"a num = 200"，这就是线程安全问题。我们可以想一下是怎么会有线程安全的问题的：1、mt...
Java多线程锁---synchronized
qq940051592的博客
08-04 149
Java中常用的线程操作方法 取得当前JVM中正在执行的线程对象 public static native THread currentThread(); 线程名称的命名和取得 public Thread(Runnable target, String name) public final synchronized void setName(String name) S...
java多线程（三）——线程锁synchronized
weixin_30505225的博客
07-16 75
synchronized有两种方式： 1.写在方法前（相当于锁定当前对象） 2.synchronized（object）{} 注意： 1.被锁住的对象在锁外面是可以被修改的，所以要注意synchronized的位置。 2.当两个不同的锁锁住相同的对象时，只能有一个线程在执行其中一个锁。（实际上就是一把锁，这样也可以解释死锁的问题） 3.死锁至少有4把锁： synchronized...
java 多线程锁synchronized
莫等闲
03-02 391
对代码加锁： 1.在方法前加锁。public synchronized void add(String name) {} 2.在方法里面加锁。synchronized (this) {} --未加锁 package com.lhj.java; public class Test extends Thread{ Timer timer=new Timer(); publ
java 多线程锁机制Synchronized
tim_szchina的博客
06-24 154
http://www.sunxin.org/forum/thread/19757.html java 多线程锁机制Synchronized &lt;script type="text/javascript"&gt;&lt;/script&gt;       [关键字： Synchronized ] 打个比方：一个object就像一个大房子，大门永远打开。房子里有很多房间（也就是方法）。这些...
java jar包如何运行或调用
最新发布
NLP与推荐算法
05-08 351
java服务启动
java线程同步synchronized
07-27
Java中的线程同步是通过关键字synchronized来实现的。synchronized关键字可以应用在方法或代码块上，用于实现线程安全。当一个线程获取了某个对象的锁，其他试图获取该对象锁的线程将被阻塞，直到该线程释放锁。 在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一只理智汪

你的鼓励就是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值