三、synchronized锁机制

最新推荐文章于 2023-01-31 13:01:54 发布
最新推荐文章于 2023-01-31 13:01:54 发布
阅读量271 收藏
点赞数
分类专栏： java基础 多线程 文章标签： 多线程 Java基础 锁机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MR_ChenT/article/details/84823255
版权
一、synchronized锁机制
1、同步锁

脏读：一个常见的概念。在多线程中，难免会出现在多个线程中对同一个对象的实例变量进行并发访问的情况，如果不做正确的同步处理，那么产生的后果就是"脏读"，也就是取到的数据其实是被更改过的。

示例：

public class Lock_JobRun extends Thread{
    private String str;
    private Lock_RunFuncion lockRunFuncion;
    public Lock_JobRun(String str,Lock_RunFuncion lockRunFuncion) {
        this.str=str;
        this.lockRunFuncion=lockRunFuncion;
    }
    public void run(){
        try {
            lockRunFuncion.addNumber(str);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public  class Lock_RunFuncion{
    private int num=0;
    public void addNumber(String str) throws InterruptedException {
        if(str.equals("a")){
            num=100;
            System.out.println(Thread.currentThread().getName()+"    str:   "+str+"  执行完毕睡觉去了..");
            Thread.sleep(1000);
        }else{
            num=200;
            System.out.println(Thread.currentThread().getName()+"    str:   "+str+"  执行完毕");
        }
        System.out.println(Thread.currentThread().getName()+"   执行结果:"+num);
    }
}
public class RunThread {
    public static void main(String[] args) throws InterruptedException {
     Lock_RunFuncion lockRunFuncion=new Lock_RunFuncion();
     Lock_JobRun lockJobRunA=new Lock_JobRun("a",lockRunFuncion);
     Lock_JobRun lockJobRunB=new Lock_JobRun("b",lockRunFuncion);
     lockJobRunA.start();
     lockJobRunB.start();
    }
}

结果：
Thread-0 str: a 执行完毕睡觉去了…
Thread-1 str: b 执行完毕
Thread-1 执行结果:200
Thread-0 执行结果:200

结论：一个对象分别让两个线程去执行,都是异步的,Thread-0调用完后休眠1S,过程中被Thread-1给修改了,因此最后Thread-0打印到的是被Thread-1修改后的
这样数据就不正确了啊，这时可以使用同步锁 synchronized

加上synchronized 时呢？
代码示例：

public  class Lock_RunFuncion{
    private int num=0;
    public synchronized void addNumber(String str) throws InterruptedException {
        if(str.equals("a")){
            num=100;
            System.out.println(Thread.currentThread().getName()+"    str:   "+str+"  执行完毕睡觉去了..");
            Thread.sleep(1000);
        }else{
            num=200;
            System.out.println(Thread.currentThread().getName()+"    str:   "+str+"  执行完毕");
        }
        System.out.println(Thread.currentThread().getName()+"   执行结果:"+num);
    }
}

执行结果:
Thread-0 str: a 执行完毕睡觉去了…
Thread-0 执行结果:100
Thread-1 str: b 执行完毕
Thread-1 执行结果:200

总结：Thread-1 必须等Thread-0执行完后才去执行

2、多个对象多个锁

代码示例：

Lock_RunFuncion lockRunFuncionA=new Lock_RunFuncion();
Lock_RunFuncion lockRunFuncionB=new Lock_RunFuncion();
Lock_JobRun lockJobRunA=new Lock_JobRun("a",lockRunFuncionA);
Lock_JobRun lockJobRunB=new Lock_JobRun("b",lockRunFuncionB);
lockJobRunA.start();
lockJobRunB.start();

结果：
Thread-1 str: b 执行完毕
Thread-0 str: a 执行完毕睡觉去了…
Thread-1 执行结果:200
Thread-0 执行结果:100

总结：看到没有，同步锁没有同步执行了我。
之前实例的同步锁,应该是对象执行完后到下一个对象。其实这只是针对同一个对象才会有等待的情况。对象都不同了都不互相干扰。

3、synchronized方法与锁对象
(1)对象内方法锁与非方法锁

代码示例：

public  class Lock_RunFuncion_1 {
    public synchronized void synchrMethod() throws InterruptedException {
        System.out.println("synchrMethod  "+Thread.currentThread().getName()+"   start");
        Thread.sleep(3000);
        System.out.println("synchrMethod  "+Thread.currentThread().getName()+"   end");
    }
    public  void method() throws InterruptedException {
        System.out.println("method  "+Thread.currentThread().getName()+"   start");
        System.out.println("method  "+Thread.currentThread().getName()+"   end");
    }
}
public class Lock_JobRun_2 extends Thread{
    private Lock_RunFuncion_1 lockRunFuncion1;
    public Lock_JobRun_2(Lock_RunFuncion_1 lockRunFuncion1) {
        this.lockRunFuncion1 = lockRunFuncion1;
    }
    public void run(){
        try {
            lockRunFuncion1.synchrMethod();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class Lock_JobRun_1 extends Thread{
    private Lock_RunFuncion_1 lockRunFuncion1;
    public Lock_JobRun_1(Lock_RunFuncion_1 lockRunFuncion1) {
        this.lockRunFuncion1 = lockRunFuncion1;
    }
    public void run(){
        try {
            lockRunFuncion1.method();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public static void main(String[] args) throws InterruptedException {
Lock_RunFuncion_1 lockRunFuncion1=new Lock_RunFuncion_1();
Lock_JobRun_1 lockJobRun1=new Lock_JobRun_1(lockRunFuncion1);
Lock_JobRun_2 lockJobRun2=new Lock_JobRun_2(lockRunFuncion1);
lockJobRun1.start();
lockJobRun2.start();
}

结果：
method Thread-0 start
synchrMethod Thread-1 start
method Thread-0 end
synchrMethod Thread-1 end

总结：一个对象中可以存在 异步和同步方法,异步方法当然也不需要等待同步执行完了,如果两个方法都是同步的,会依次执行

验证一个对象里都加方法锁：
代码示例：

public  synchronized void method() throws InterruptedException {
        System.out.println("method  "+Thread.currentThread().getName()+"   start");
        System.out.println("method  "+Thread.currentThread().getName()+"   end");
    }

结果：
method Thread-0 start
method Thread-0 end
synchrMethod Thread-1 start
synchrMethod Thread-1 end

(2)synchronized锁重入

代码示例：

public  class Lock_RunFuncion_2 {
    public synchronized void method1()  {
        System.out.println("m1");
        method2();
    }
    public synchronized void method2()  {
        System.out.println("m2");
        method3();
    }
    public synchronized void method3()  {
        System.out.println("m3");
    }
}

public class Lock_JobRun_3 extends Thread{

    public void run(){
        Lock_RunFuncion_2 lock_runFuncion_2=new Lock_RunFuncion_2();
        lock_runFuncion_2.method1();
    }
}

public static void main(String[] args) {
Lock_JobRun_3 lockJobRun3=new Lock_JobRun_3();
lockJobRun3.start();
}

结果：
m1
m2
m3

总结：可以看到依次打印了。这证明了对象可以再次获取自己的内部锁。这种锁重入的机制，也支持在父子类继承的环境中。

注意： 发生异常是自动释放锁

(3)synchronized同步代码块

有没有想过用synchroized同对象执行的方法都要进行等待,那么方法里含有不需要等待的代码吗？

代码示例：

public class sync_RunFuncion {
    int count=1000000000;
    public void  method() throws InterruptedException {
        System.out.println("not synchronized start  ---  "+Thread.currentThread().getName());
        for (int i=0;i<count;i+=2) {
            i--;
        }
        System.out.println("not synchronized find  ---  "+Thread.currentThread().getName());
        synchronized (this){
            System.out.println("synchronized start  ---  "+Thread.currentThread().getName());
            for (int i=0;i<count;i+=2) {
                i--;
            }
            System.out.println("synchronized find  ---  "+Thread.currentThread().getName());
        }
    }
}
public class Sync_JobRun extends  Thread {
    private sync_RunFuncion syncRunFuncion;
    public Sync_JobRun(sync_RunFuncion syncRunFuncion) {
        this.syncRunFuncion=syncRunFuncion;
    }
    @Override
    public void run(){
        syncRunFuncion.method();
    }
}

public static void main(String[] args) throws InterruptedException {
        sync_RunFuncion syncRunFuncion=new sync_RunFuncion();
        Sync_JobRun syncJobRun=new Sync_JobRun(syncRunFuncion);
        syncJobRun.start();
        Sync_JobRun syncJobRun2=new Sync_JobRun(syncRunFuncion);
        syncJobRun2.start();
    }

结果：
not synchronized start — Thread-1
not synchronized start — Thread-0
not synchronized find — Thread-1
synchronized start — Thread-1
not synchronized find — Thread-0
synchronized find — Thread-1
synchronized start — Thread-0
synchronized find — Thread-0

总结：可以看到线程1还没调用完not synchronized find的方法,线程0就开始调用not synchronized start方法了。
而synchronized 方法却老老实实地执行完start-find…。
可以得出在synchronized内当某个线程在访问时,会被阻塞。而之外的却不会。
这样做大大地提高了效率,异步方法也不需要等待同步方法释放锁了
。

（4）两个synchronized块之间具有互斥性

代码示例:

public class sync_RunFuncion {
    public void opposite_Tom(){
        synchronized (this){
            try {
                System.out.println("opposite_Tom start..  ---  "+Thread.currentThread().getName());
                Thread.sleep(1000);
                System.out.println("opposite_Tom end..  ---  "+Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
    public   void  opposite_Jones(){
        synchronized (this) {
            try {
                System.out.println("opposite_Jones start..  ---  "+Thread.currentThread().getName());
                Thread.sleep(1000);
                System.out.println("opposite_Jones end..  ---  "+Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


public class Sync_Op_Tom_JobRun  extends Thread{
    private sync_RunFuncion syncRunFuncion;
    public Sync_Op_Tom_JobRun(sync_RunFuncion syncRunFuncion) {
        this.syncRunFuncion=syncRunFuncion;
    }
    @Override
    public void run(){
        syncRunFuncion.opposite_Jones();
    }
}

public class Sync_Op_Jones_JobRun extends Thread{
    private sync_RunFuncion syncRunFuncion;
    public Sync_Op_Jones_JobRun(sync_RunFuncion syncRunFuncion) {
        this.syncRunFuncion=syncRunFuncion;
    }
    @Override
    public void run(){
        syncRunFuncion.opposite_Tom();
    }
}


public static void main(String[] args) {
        sync_RunFuncion syncRunFuncion=new sync_RunFuncion();
        for(int i=0;i<2;i++) {
            Sync_Op_Jones_JobRun syncOpJonesJobRun = new Sync_Op_Jones_JobRun(syncRunFuncion);
            Sync_Op_Tom_JobRun syncOpTomJobRun = new Sync_Op_Tom_JobRun(syncRunFuncion);
            syncOpJonesJobRun.start();
            syncOpTomJobRun.start();
        }
    }

结果：
opposite_Tom start… — Thread-2
opposite_Tom end… — Thread-2
opposite_Jones start… — Thread-3
opposite_Jones end… — Thread-3
opposite_Jones start… — Thread-1
opposite_Jones end… — Thread-1
opposite_Tom start… — Thread-0
opposite_Tom end… — Thread-0

总结：这里看得不是很仔细,到sleep会暂停一会,依次执行，synchronized 块的是获取对象锁,锁的是整个对象,要么是opposite_Tom执行要么opposite_Jones执行,看哪个线程先获取锁,谁先执行,执行期间会将对象阻塞。

(5)synchronized块和synchronized方法

代码示例：


public class sync_RunFuncion {
    public void sync_Block(){
        synchronized (this){
            try {
                System.out.println("opposite_Tom start..  ---  "+Thread.currentThread().getName());
                Thread.sleep(2000);
                System.out.println("opposite_Tom end..  ---  "+Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public synchronized  void  sync_Function(){
            System.out.println("opposite_Jones start..  ---  "+Thread.currentThread().getName());
            System.out.println("opposite_Jones end..  ---  "+Thread.currentThread().getName());
    }
}
public class Sync_Op_Jones_JobRun extends Thread{
    private sync_RunFuncion syncRunFuncion;
    public Sync_Op_Jones_JobRun(sync_RunFuncion syncRunFuncion) {
        this.syncRunFuncion=syncRunFuncion;
    }
    @Override
    public void run(){
        //---调用sync码块与sync方法特性
        syncRunFuncion.sync_Block();
    }
}
public class Sync_Op_Tom_JobRun  extends Thread{
    private sync_RunFuncion syncRunFuncion;
    public Sync_Op_Tom_JobRun(sync_RunFuncion syncRunFuncion) {
        this.syncRunFuncion=syncRunFuncion;
    }
    @Override
    public void run(){
        //---调用sync码块与sync方法特性
        syncRunFuncion.sync_Function();
    }
}
 public static void main(String[] args) {
        sync_RunFuncion syncRunFuncion=new sync_RunFuncion();
        for(int i=0;i<3;i++) {
            Sync_Op_Jones_JobRun syncOpJonesJobRun = new Sync_Op_Jones_JobRun(syncRunFuncion);
            Sync_Op_Tom_JobRun syncOpTomJobRun = new Sync_Op_Tom_JobRun(syncRunFuncion);
            syncOpJonesJobRun.start();
            syncOpTomJobRun.start();
        }
    }
}

结果：
opposite_Jones start… — Thread-1
opposite_Jones end… — Thread-1
opposite_Tom start… — Thread-0
…等待2S 自己加的忽略就好
opposite_Tom end… — Thread-0
opposite_Jones start… — Thread-5
opposite_Jones end… — Thread-5
opposite_Tom start… — Thread-4
…等待2S 自己加的忽略就好
opposite_Tom end… — Thread-4
opposite_Tom start… — Thread-2
…等待2S 自己加的忽略就好
opposite_Tom end… — Thread-2
opposite_Jones start… — Thread-3
opposite_Jones end… — Thread-3

结论：synchronized方法和synchronized代码块都是调用同一个对象锁的。

(6)将任意对象作为对象监视器

前面都使用synchronized(this)的格式来同步代码块，其实Java还支持对"任意对象"作为对象监视器来实现同步的功能。
这个"任意对象"大多数是实例变量及方法的参数，使用格式为synchronized(非this对象)。看一下将任意对象作为对象监视器的使用例子：
代码示例:


public class Sync_Object_JobRun extends  Thread {
    private sync_Object_RunFuncion syncRunFuncion;
    public Sync_Object_JobRun(sync_Object_RunFuncion syncRunFuncion) {
        this.syncRunFuncion=syncRunFuncion;
    }
    @Override
    public void run(){
        try {
            syncRunFuncion.method();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class RunThread {
    public static void main(String[] args) {
        sync_Object_RunFuncion syncRunFuncion=new sync_Object_RunFuncion();
        for(int i=0;i<4;i++){
            Sync_Object_JobRun syncObjectJobRun=new Sync_Object_JobRun(syncRunFuncion);
            syncObjectJobRun.start();
        }
    }
}
public class sync_Object_RunFuncion {
    private String str=new String();
    public void  method() throws InterruptedException {
        int count=1000000000;
        synchronized (str){
            System.out.println("synchronized start  ---  "+Thread.currentThread().getName());
            for (int i=0;i<count;i+=2) {
                i--;
            }
            Thread.sleep(1000);
            System.out.println("synchronized find  ---  "+ Thread.currentThread().getName());
       }
    }
}

結果：
synchronized start — Thread-1
synchronized find — Thread-1
synchronized start — Thread-2
synchronized find — Thread-2
synchronized start — Thread-3
synchronized find — Thread-3
synchronized start — Thread-0
synchronized find — Thread-0

总结：synchronized放非this的对象也实现了同步的效果,实际上在new的时候就已经实例化了对象,调用的都是同一个。
只要对象的引用不变，即使改变了对象的属性，运行结果依然是同步的。

MR_ChenT
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
技术分享-java synchronized锁机制.pptx
06-11
由浅入深解析synchronized锁的机制，各种锁的概念的介绍，膨胀过程，基于redis的分布式锁demo。
Synchronized膨胀为重量级锁之后的抢锁过程
weixin_41335352的博客
08-05 385
当我们了解到synchronized的重量级锁之后，是不是会有疑问：当一个线程释放锁之后，阻塞的线程是如何去获取到锁呢？是否还存在自旋等待锁呢？？？ 这里依旧推荐两篇，我觉得不错的文章： monitor对象结构底层实现 Synchronized底层实现 看完这两篇文章，相信你心里的疑惑可能已经解开了。下面开始我的表演了。 在我们使用synchronize的后，我们都是在对应的字节码看到两个字节码指令： 对应的字节码具体逻辑可以在推荐文章到有展示，也可以自己搜下完整实现。 我们再看下object Monit
面试官：说一下 synchronized 锁机制原理 与 Lock 锁机制
m0_71777195的博客
08-23 302
因此为了解决这个问题，我们可能需要这样一个方案，当存在多个线程操作共享数据时，需要保证同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再进行，这种方式叫互斥锁，即能达到互斥访问目的的锁，也就是说当一个共享数据被当前正在访问的线程加上互斥锁后，在同一个时刻，其他线程只能处于等待的状态，直到当前线程处理完毕释放该锁。“可重入锁”概念是：自己可以再次获取自己的内部锁。随着锁的竞争，锁可以从偏向锁升级到轻量级锁，再升级的重量级锁，但是锁的升级是单向的，只能从低到高升级，不会出现锁的降级。
synchronized原理及锁优化过程（简单，直白）
qq_40271222的博客
11-14 661
1.对象的组成：对象头，实例变量，填充对齐 2，对象头的组成：Mark Word，类型指针（指向元数据区对象所属的clss对象）。Mark Word为节省存储空间，在不同场景下存储的内容不同，结构为： 3，锁的升级过程为： 偏向锁（同步代码一直只被同一线程执行，没有其他线程竞争）----------升级----》 轻量级锁（有多个线程会执行代码，但没有冲突过） -------------------------升级----》 重量级锁（多线程同时想执行一块代码，发生冲突，等待锁的线程先自旋尝试获取锁
synchronized的锁策略及优化过程
Green_756的博客
10-30 546
synchronized的锁策略，优化过程
[JavaEE系列] 多线程常见的锁策略及synchronized底层工作过程
蔡欣致的个人博客
08-03 229
爆肝5k字! 一篇文章让你彻底理解多线程中的锁策略以及synchronized的底层工作原理~ 再也不拍被面试官问到synchronized的底层实现原理了!
java锁机制Synchronized.pdf
09-30
java锁机制Synchronized.pdf
java锁机制Synchronizedjava锁机制Synchronized
05-04
java锁机制Synchronized java锁机制Synchronized java锁机制Synchronized java锁机制Synchronized
Java 多线程同步 锁机制与synchronized深入解析
09-05
从尺寸上讲，同步代码块比同步方法小。你可以把同步代码块看成是没上锁房间里的一块用带锁的屏风隔开的空间
【Java进阶】 深入理解Synchronized
weixin_43918614的博客
03-29 842
在实际应用过程中使用多线程，可以给我们的程序带来性能上非常大的提升，但是同时，如果我们的线程使用不合理，也会带来非常多不可控的问题，最常见的问题就是线程安全问题了。 也就是说当多个线程同时访问某个方法的时候，这个方法无法按照我们的预期行为来执行，那么这个方法就是认为是线程不安全的。 其实导致我们线程不安全的原因主要有三个：原子性，有序性，可见性。当谈到Synchronized同步锁的时候无疑就是与原子性相关的了 多线程环境的原子性问题 什么是原子性呢？ 在数据库事务...
Synchronized锁机制
m0_54202121的博客
04-21 440
文章目录2.1 Synchronized2.1.1 Synchronized 关键字回顾synchronized关键字的底层实现synchronized修饰代码块synchronized修饰普通方法synchronized修饰静态方法2.1.2 售票案例 2.1 Synchronized 2.1.1 Synchronized 关键字回顾 synchronized 关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 另外，在
常见的锁策略和synchronized的锁机制
trong_ 的烂笔头
01-31 1600
介绍常见的锁策略, synchronized关键字的锁升级过程和锁优化.
深入分析 Synchronized 原理
养歌的博客
02-07 1645
Synchronized 简介 Synchronized 是 Java 中的关键字，是一种同步锁。在多线程编程中，有可能会出现多个线程同时争抢同一个共享资源的情况，这个资源一般被称为临界资源。这种共享资源可以被多个线程同时访问，且又可以同时被多个线程修改，然而线程的执行是需要 CPU 的资源调度，其过程是不可控的，所以需要采用一种同步机制来控制对共享资源的访问，于是线程同步锁—— Synchronized 就应运而生了。 Synchronized 用法 Synchronized 关键字主要有以下 3 种使用
Java中的锁机制 synchronized & 偏向锁 & 轻量级锁 & 重量级锁 & 各自优缺点及场景 & AtomicReference 侵立删
心神沫沫的收藏
08-25 1365
转自：https://www.cnblogs.com/charlesblc/p/5994162.html   参考文章： http://blog.csdn.net/chen77716/article/details/6618779 目前在Java中存在两种锁机制：synchronized和Lock，Lock接口及其实现类是JDK5增加的内容，其作者是大名鼎鼎的并发专家Doug Lea。本文并...
synchronized锁原理详解
java521666的博客
07-21 871
在理解锁实现原理之前先了解一下Java的对象头和Monitor，在JVM中，对象是分成三部分对象头实例数据对其填充实例数据和对其填充与synchronized无关,对象头是我们需要关注的重点，它是synchronized实现锁的基础，因为synchronized申请锁、上锁、释放锁都与对象头有关。......
Synchronized锁机制详解
java_ying的博客
05-13 402
锁是一种怎样的存在 一个简单的日常的生活的例子：如果有人问你怎样保证自行车不被偷走,肯定回答上锁就行了呗。类比如果有人又问你多线程情况下怎样保证数据安全性，上锁就行了呗。所以程序世界中的锁到底是什么样子呢 Synchronized ...
多线程 -锁机制 - Synchronized
scanklm的专栏
09-11 525
如果对代码加了 synchronized，则在加锁代码逻辑前后会加入 monitorenter 和 monitorexit 指令 JDK1.6版本之前没有锁分级的概念，synchronized是重量级锁，monitorenter 和 monitorexit 指令处理逻辑复杂，性能比较差； 但在JDK1.6版本之后引入了 无锁、偏向锁、轻量级锁、重量级锁 的锁分级概念，根据锁竞争情况的不同，锁状态逐渐升级，性能逐渐递减，但在大部分情况下业务并发情况不高，偏向锁 和 轻量级锁 就能满足我们的要求，只有在严重
了解线程同步机制---Synchronized锁
Vinjcent
03-07 788
Java浅谈同步机制的sleep方法线程的同步机制（队列和锁）解决安全性同步监视器的执行过程sleep()方法放在同步方法中sleep()方法放在run()中功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 线程的同步机制（队列和锁
浅谈 synchronized 锁机制原理 与 Lock 锁机制
m0_72885838的博客
08-23 1145
线程安全是并发编程中的重要关注点，造成线程安全问题的主要原因有两点，一是存在共享数据(也称临界资源)，二是存在多条线程共同操作共享数据。因此为了解决这个问题，我们可能需要这样一个方案，当存在多个线程操作共享数据时，需要保证同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再进行，这种方式叫互斥锁，即能达到互斥访问目的的锁，也就是说当一个共享数据被当前正在访问的线程加上互斥锁后，在同一个时刻，其他线程只能处于等待的状态，直到当前线程处理完毕释放该锁。
synchronized锁机制
最新发布
04-05
synchronized锁机制是Java提供的一种线程同步机制，它能够保证在同一时刻只有一个线程能够访问被锁定的代码块。在使用synchronized锁机制时，当一个线程进入synchronized代码块时，它会尝试获取锁，如果锁已被其他...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值