第四篇文章：Synchronized

已于 2023-04-27 23:51:57 修改
阅读量237 收藏
点赞数
分类专栏： 多线程 文章标签： 多线程
于 2022-08-26 16:39:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47414034/article/details/126546225
版权

采用互斥的方式，让同一时刻最多只有一个线程能持有这把锁，其他线程再想获取这把锁就会被阻塞住，这样就可以保证拥有锁的线程可以唯一执行临界区的代码


锁住Object类对象

Object object=new Object();

synchronized(object)
{


}

 锁住普通方法

public  synchronized  void  buy()
{


}

锁住static方法：

public static synchronized  void  buy()
{


}

 Synchronized关键字使用的四种情景：

（1）锁住我们自己new出来的一个Object对象

public class test
{

  //lock是一个Object类型的对象
  Object lock=new Object();

  public void methodA()
  {
    //锁住Object对象lock，然后把代码放到这里面
    synchronized(lock)
    {
         pass;    
    }
  }

}

（2）锁住当前对象this

public class test


  public void methodA()
  {
    synchronized(this)
    {
         pass;    
    }
  }

}

下面两种加在方法前面的方式，本质还是锁住当前对象this，可以改成锁住this的等价方式

也就是说：synchronized只能锁对象，把synchronized加在方法（不管是静态方法还是非静态方法）前面，其实锁住的是this对象

（3）加在成员方法（也就是非static方法）前面

public class test
{
  public synchronized void methodA()
  {
    

  }

}


//等价于
public  class test
{

  public void methodA()
  {
     synchronized(this)
     {
         ..........
     }
  }
}

（4）加在static静态方法上

public class test
{
  public static synchronized void methodA()
  {
    

  }

}


//等价于
public class test
{
  public  static void  methodA()
  {
       synchronized(this)
       {
          ........
       }
  }
}

实际案例：

public class test
{
    static int counter=0;


    public static void main(String[] args) throws InterruptedException
    {
        Thread thread1=new Thread(()->{
                                        for(int i=0;i<5000;i++)
                                        {
                                                counter++;
                                        }
                                        } );
        Thread thread2=new Thread(()->{
                                        for(int i=0;i<5000;i++)
                                        {
                                                counter--;
                                        }
                                       } );
        thread1.start();
        thread2.start();
        Thread.sleep(10000);
        System.out.println(counter);


    }
}

方式一：将我们自己new出来的Object类对象作为锁

public class test
{
    static int counter=0;

    static  Object lock=new Object();


    public static void main(String[] args) throws InterruptedException
    {
        Thread thread1=new Thread(()->{
                                        for(int i=0;i<5000;i++)
                                        {
                                            synchronized (lock)
                                            {
                                                counter++;
                                            }
                                        }
                                        } );
        Thread thread2=new Thread(()->{
                                        for(int i=0;i<5000;i++)
                                        {
                                            synchronized(lock)
                                            {
                                                counter--;
                                            }
                                        }
                                       } );
        thread1.start();
        thread2.start();
        Thread.sleep(10000);
        System.out.println(counter);


    }
}

方式二：将当前对象this作为锁

class  Room
{
    private int counter=0;

    public  void add()
    {
        synchronized (this)
        {
            counter++;
        }
    }

    public void minus()
    {
        synchronized (this)
        {
            counter--;
        }
    }

    public int getCounter()
    {
        synchronized (this)
        {
            return counter;
        }
    }
}

public class test
{

    public static void main(String[] args) throws InterruptedException
    {
        Room  room=new Room();

        Thread thread1=new Thread(()->{
                                        for(int i=0;i<5000;i++)
                                        {
                                            room.add();
                                        }
                                        } );
        Thread thread2=new Thread(()->{
                                        for(int i=0;i<5000;i++)
                                        {
                                            room.minus();
                                        }
                                       } );
        thread1.start();
        thread2.start();
        Thread.sleep(10000);
        System.out.println(room.getCounter());

    }
}

方式三：把synchronized加在非static方法前面

class  Room
{
    private int counter=0;

    public synchronized void add()
    {
            counter++;
    }

    public synchronized void minus()
    {
            counter--;
    }

    public synchronized int getCounter()
    {
            return counter;
    }
}

public class test
{

    public static void main(String[] args) throws InterruptedException
    {
        Room  room=new Room();

        Thread thread1=new Thread(()->{
            for(int i=0;i<5000;i++)
            {
                room.add();
            }
        } );
        Thread thread2=new Thread(()->{
            for(int i=0;i<5000;i++)
            {
                room.minus();
            }
        } );
        thread1.start();
        thread2.start();
        Thread.sleep(10000);
        System.out.println(room.getCounter());

    }
}

构造方法不能使用 synchronized 关键字修饰。

构造方法本身就属于线程安全的，不存在同步的构造方法一说

一个实例：三个线程来模拟三个窗口卖票


public class Test
{
    public static void main(String[] args) throws InterruptedException
    {
        Ticket ticket=new Ticket();
        Thread t1= new Thread(ticket,"t1");
        Thread t2=new Thread(ticket,"t2");
        Thread t3=new Thread(ticket,"t3");
        t1.start();
        t2.start();
        t3.start();
    }
    static class Ticket implements Runnable
    {
        int ticket=100;

        @Override
        public void run()
        {
            while(true)
            {
                if(ticket>0)
                {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName()+" is selling ticket"+ticket--);
                }

            }
        }
    }
}

 出现了-1

方法一，new一个Object类对象，然后对这个对象上锁，synchronized锁住一个对象

public class Foo
{
    public static void main(String[] args) throws InterruptedException
    {
        Ticket ticket=new Ticket();
        Thread t1= new Thread(ticket,"t1");
        Thread t2=new Thread(ticket,"t2");
        Thread t3=new Thread(ticket,"t3");
        t1.start();
        t2.start();
        t3.start();
    }
    static class Ticket implements Runnable
    {
        int ticket=100;
        Object object=new Object();

        @Override
        public void run()
        {
            synchronized(object)
            {
                while(true)
                {
                    if(ticket>0)
                    {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        System.out.println(Thread.currentThread().getName()+" is selling ticket"+ticket--);
                    }

                }
            }
        }
    }
}

 但这样只有1个线程可以卖票

方法二： synchronized锁住一个方法：

public class Test
{
    public static void main(String[] args) throws InterruptedException
    {
        Ticket ticket=new Ticket();
        Thread t1= new Thread(ticket,"t1");
        Thread t2=new Thread(ticket,"t2");
        Thread t3=new Thread(ticket,"t3");
        t1.start();
        t2.start();
        t3.start();
    }
    static class Ticket implements Runnable
    {
        int ticket=100;
        
        @Override
        public void run()
        {
            buy();
        }

        public synchronized void buy()
        {
            while(true)
            {
                if(ticket>0)
                {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName()+" is selling ticket"+ticket--);
                }

            }
        }
    }
}

 这样也只有1个线程可以卖票

方法三：使用Reentrantlock进行加锁

public class Test
{
    public static void main(String[] args) throws InterruptedException
    {
        Ticket ticket=new Ticket();
        Thread t1= new Thread(ticket,"t1");
        Thread t2=new Thread(ticket,"t2");
        Thread t3=new Thread(ticket,"t3");
        t1.start();
        t2.start();
        t3.start();
    }
    static class Ticket implements Runnable
    {
        int ticket=100;
        Reentrantlock lock=new Reentrantlock();

        @Override
        public void run()
        {
            while(true)
            {
                lock.lock()
            
                if(ticket>0)
                {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName()+" is selling ticket"+ticket--);
                }
                
                lock.unlock();
            }
        }
    }
}

sychronized的两个特性：可重入性和不可中断性

可重入性：

可以重复拿到一把锁（一把锁拿两次）

Object  obj=new Obj();


synchronized(obj)
{

   synchronized(obj)
   {
      .......
   }
}

可重入特性可以避免死锁

如果没有可重入性，第一次拿到锁之后就会被阻塞住，无法第二次拿到锁

被锁住的对象内部有一个计数器记录线程获取几次锁了

synchronized经常会和单例模式（加锁双重校验懒汉模式）结合起来考察

synchronized原理

   synchronized(obj)
   {
      .......
   }

 被锁住的Object类对象会关联（引用）一个monitor对象(monitor对象也会引用这个Object类对象),这个才是真正的锁，不是java对象，而是一个c++对象，这个对象不是我们主动创建的，而是由jvm创建的

这个monitor对象里面有两个重要的成员变量：owner  拥有锁的线程，recursions  记录一个线程拿了几次锁（可重入的话，recursion可能为2）

假设t1线程来执行，那monitor对象的owner就会变成t1

如果此时t2线程来，发现monitor对象的owner是t1，不是自己，那t2就会进入阻塞状态

多个线程竞争锁，没有竞争到锁的线程会进入EntryList阻塞队列，进入blocked状态，拿到锁的线程调用wait()方法后，进入WaitSet等待队列，进入waiting等待状态，有其他线程调用notify()方法唤醒处于waiting的线程，被唤醒的线程就会进入EntryList阻塞队列进入阻塞状态共同竞争锁

sunchronized锁升级：

 jdk1.6之前，synchronized使用的就是重量级锁

1.6之后就有个锁升级（也叫锁膨胀）的过程：

（1）任何对象都能充当锁，你刚把对象创建出来的时候，对象处于无锁的状态

（2）当有一个线程(只有一个线程)过来想要获取锁的时候，这个充当锁的对象就要升级成偏向锁

偏向锁认为：大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得这把锁，当这个线程再次请求锁的时候，直接将锁给它

（3）当有多个线程竞争锁的时候，升级成轻量级锁(也叫自旋锁)，没拿到锁的线程进行自旋（忙循环），自旋完再尝试去拿锁，如果此时发现所还是被占用不可获得，继续自旋

没有抢到锁的线程不会进入到阻塞态(因为线程切换到阻塞态的开销很大，所以尽量避免进入阻塞状态)，自旋锁认为锁只会被拿走很短的时间，过了这个很短的时间拿到锁，访问完共享数据的线程就会归还锁

（4）自旋超过阈值（默认是10次），就会升级成重量级锁

面试题：synchronized  异常会释放锁吗？会，会执行monitorexit释放锁对象

（面经总结）一篇文章带你深入剖析 synchronized 的底层原理
南淮北安的博客
05-08 227
文章目录一、synchronized 的基本用法二、synchronized 的底层实现原理1. 同步块的底层原理分析2. 同步方法的底层原理分析四、总结 一、synchronized 的基本用法 可参考：一篇文章带你搞定 Java 中同步概念 可参考：一篇文章带你深入了解多线程中的线程组，守护线程，线程优先级，synchronize synchronized 与 volatile 的最大区别在于原子性，volatile 不具备原子性 可参考：一篇文章带你深入了解 volatile 与 Java 内存模
synchronized(object)
woshicuizhenxing的博客
12-01 729
使用synchronized(object) { 代码块.... } 能对代码块进行加锁，不允许其他线程访问，其的作用原理是：在object内有一个变量，当有线程进入时，判断是否为0，如果为0，表示可进入执行该段代码，同时将该变量设置为1，这时其他线程就不能进入；当执行完这段代码时，再将变量设置为0。 想保证代码块在任务情况下都同步，即代码块在程序的中同一时刻只被一个线程调用，即需要使用
java synchronized 关键字（1）对象监视器为Object
两亩半地
11-24 2233
在java多线程中 synchronized 是非常重要的，也是经常用到的对于synchronized关键字要注意两点synchronized对象监视器为Object的时候 synchronized对象监视器为Class的时候对象监视器为Object也就是
java synchronized(syncObject) 和 synchronized(this)
weixin_30835923的博客
10-23 161
用synchronized(syncObject)看起来比较好如下： public class test_sync extends Thread { Integer x = 0; public test_sync() { } public void run() { try { Thread.sleep(1000); } catch (InterruptedExcept...
synchronized(this)和synchronized(obj)
最新发布
weixin_43887870的博客
02-05 2118
首先synchronized(this)和synchronized(obj)区别
重学OC第二十一篇：@synchronized分析
Rain and Tears
11-07 1344
文章目录一、clang分析@synchronized二、objc_sync_enter()源码解析2.1 id2data()函数分析三、objc_sync_exit源码总结 一、clang分析@synchronized int main(int argc, const char * argv[]) { NSObject *obj = [[NSObject alloc] init]; @synchronized (obj) { } return 0; } 通过clang -re
面试题深入解析：Synchronized底层实现面试题深入解析：Synchronized底层实现
不喝枸杞的程序员
08-06 183
本文为synchronized系列第二篇。主要内容为分析偏向锁的实现。 偏向锁的诞生背景和基本原理在上文中已经讲过了，强烈建议在有看过上篇文章的基础下阅读本文。 本文将分为几块内容： 1.偏向锁的入口 2.偏向锁的获取流程 3.偏向锁的撤销流程 4.偏向锁的释放流程 5.偏向锁的批量重偏向和批量撤销 本文分析的JVM版本是JVM8，具体版本号以及代码可以在这里看到。 ...
面试100%必考题：synchronized原理必杀技，看我我是怎么回答的
m0_55580425的博客
08-05 518
前言 前面我们已经学习了并发编程的很多章节，如果你还没用看过，墙裂建议看一下哦，目录已经准备好了： 并发编程系列 上篇在synchronized精讲中，我们讲解了synchronized的用法、注意项等知识点，但知道用法只是基础，如果想要拿到更高的工资、更好的岗位，了解它的实现原理也是很重要的加分项，本章学习的意义非常重要。 本节主要讲解以下几个内容： synchronized有哪些特性？ synchronized的实现原理？ synchronized的作用？ synchronized的缺陷？ 正文
Java多线程：synchronized和volatile
spawpaw的博客
08-01 434
一、什么是锁 1.1 为什么需要锁: CPU的内存模型 大家都知道，计算机在执行程序时，每条指令都是在CPU中执行的，而数据首先会被从主存取到CPU的cache中，但是当变量在cache中被改变时，是不会立马写回主存的，那么问题就来了，在多核心CPU中，如果执行下面一段代码：i = i + 1;在多线程环境中就会出问题，如果这里不明白可以参考下图或者百度内存模型，这里不再赘述 1...
关于 @synchronized(object)的使用注意的地方
diewenman9982的博客
12-30 88
@import url(http://i.cnblogs.com/Load.ashx?type=style&file=SyntaxHighlighter.css);@import url(/css/cuteeditor.css); @import url(http://i.cnblogs.com/Load.ashx?type=style&file=SyntaxHighlighter.c...
synchronized 关键字可修饰 object和方法
wangliwei4321的专栏
02-15 1341
 原文转自： http://www.cnblogs.com/GnagWang/archive/2011/02/27/1966606.html Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。      一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一
理解synchronized(Object)锁
Jim Yang
03-16 3227
package test;public class Test2 {    static class Inner1 {        public void m1() {            synchronized("aaaa") {                for (char c = a; c                     System.out.println(Thread
synchronized(this)和synchronized(object)的理解
atarik@163.com
08-14 6434
如果有一块代码(或方法)可能被多个线程同时访问，然后里面操作的数据修改操作可能因为不同线程的操作而不一致的时候，使用synchronized锁定这块代码，确保同时只有一个线程访问这个代码块。也就是说，关键字synchronized可以用在任何类的方法里面，即使该类没有实现Runnable接口或者继承Thread类。 使用this和object的区别:this是对当前类做控制, 即保证当前类是线程...
Synchronized的理解
u013696062的专栏
01-03 413
互斥锁，锁住一块代码区。 提问：什么叫互斥锁？ 互斥锁又叫排他锁，它作用于一块代码区，则同一个时刻，只允许有一个线程访问，不管是读还是写。 两种用法： 作用于方法内的一块代码区。 Synchronized(object){} 含义：object是Object类的一个实例（即除非基本类型外的任意对象实例），每个实例有一个对象锁。这句语法的含义就是：只有获得了object的对象锁，才能执行{}内的
@synchronized (object)使用详解
06-02 368
synchronized关键字代表这个方法加锁,相当于不管哪一个线 程A每次运行到这个法时,都要检查有没有其它正在用这个方法的线程B（或者C D等）,有的话要等正在使用这个方法的线程B（或者C D）运行完这个方法后再运行此线程A,没有的话,直接运行 它包括两种用法：synchronized 方法和 synchronized 块。 1. synchronized 方法： 通过在方...
Synchronized原理
som9ming9的博客
05-20 460
Synchronized的底层理解 1，monitor是一个计数器 2，为什么会有Synchronized关键字: 当程序出现并发的时候,访问修改一个共享变量的时候就会出现线程安全问题，Synchronized的出现就是为了解决线程安全问题 3，锁机制的两种特性: 互斥性:同一个时间点只允许某一个线程持有某个对象锁，如果其他线程需要获...
多线程——@synchronized(object)
05-04 1021
@synchronized 的作用是创建一个互斥锁，保证此时没有其它线程对self对象进行修改。这个是objective-c的一个锁定令牌，防止self对象在同一时间内被其它线程访问，起到线程的保护作用。 一般在公用变量的时候使用，如单例模式或者操作类的static变量中使用。 @synchronized(object)｛｝，每一个object对应一把锁，要执行｛｝中的代码，首先必须要拿到o
synchronized(object) 的作用
HeatDeath的博客
03-18 930
class Test { private int x=0; private Object lockObject = new Object(); public void incBlock() { synchronized(lockObject) { x++; } System.out.println("x="+x); } public vo...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值