Java多线程4：synchronized锁机制

最新推荐文章于 2024-09-28 20:57:59 发布
最新推荐文章于 2024-09-28 20:57:59 发布
阅读量114 收藏
点赞数
分类专栏： java技术 底层 多线程 文章标签： 多线程
java技术 同时被 3 个专栏收录
294 篇文章 3 订阅
订阅专栏
底层
118 篇文章 0 订阅
订阅专栏
多线程
58 篇文章 0 订阅
订阅专栏

脏读

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

 

多线程线程安全问题示例

看一段代码：

复制代码

public class ThreadDomain13
{
    private int num = 0;
    
    public void addNum(String userName)
    {
        try
        {
            if ("a".equals(userName))
            {
                num = 100;
                System.out.println("a set over!");
                Thread.sleep(2000);
            }
            else
            {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(userName + " num = " + num);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

复制代码

写两个线程分别去add字符串"a"和字符串"b"：

复制代码

public class MyThread13_0 extends Thread
{
    private ThreadDomain13 td;
    
    public MyThread13_0(ThreadDomain13 td)
    {
        this.td = td;
    }
    
    public void run()
    {
        td.addNum("a");
    }
}

复制代码

复制代码

public class MyThread13_1 extends Thread
{
    private ThreadDomain13 td;
    
    public MyThread13_1(ThreadDomain13 td)
    {
        this.td = td;
    }
    
    public void run()
    {
        td.addNum("b");
    }
}

复制代码

写一个主函数分别运行这两个线程：

复制代码

public static void main(String[] args)
{
    ThreadDomain13 td = new ThreadDomain13();
    MyThread13_0 mt0 = new MyThread13_0(td);
    MyThread13_1 mt1 = new MyThread13_1(td);
    mt0.start();
    mt1.start();
}

复制代码

看一下运行结果：

a set over!
b set over!
b num = 200
a num = 200

按照正常来看应该打印"a num = 100"和"b num = 200"才对，现在却打印了"b num = 200"和"a num = 200"，这就是线程安全问题。我们可以想一下是怎么会有线程安全的问题的：

1、mt0先运行，给num赋值100，然后打印出"a set over!"，开始睡觉

2、mt0在睡觉的时候，mt1运行了，给num赋值200，然后打印出"b set over!"，然后打印"b num = 200"

3、mt1睡完觉了，由于mt0的num和mt1的num是同一个num，所以mt1把num改为了200了，mt0也没办法，对于它来说，num只能是100，mt0继续运行代码，打印出"a num = 200"

分析了产生问题的原因，解决就很简单了，给addNum(String userName)方法加同步即可：

复制代码

public class ThreadDomain13
{
    private int num = 0;
    
    public synchronized void addNum(String userName)
    {
        try
        {
            if ("a".equals(userName))
            {
                num = 100;
                System.out.println("a set over!");
                Thread.sleep(2000);
            }
            else
            {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(userName + " num = " + num);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

复制代码

看一下运行结果：

a set over!
a num = 100
b set over!
b num = 200

 

多个对象多个锁

在同步的情况下，把main函数内的代码改一下：

复制代码

public static void main(String[] args)
{
    ThreadDomain13 td0 = new ThreadDomain13();
    ThreadDomain13 td1 = new ThreadDomain13();
    MyThread13_0 mt0 = new MyThread13_0(td0);
    MyThread13_1 mt1 = new MyThread13_1(td1);
    mt0.start();
    mt1.start();
}

复制代码

看一下运行结果：

a set over!
b set over!
b num = 200
a num = 100

打印结果的方式变了，打印的顺序是交叉的，这又是为什么呢？

这里有一个重要的概念。关键字synchronized取得的锁都是对象锁，而不是把一段代码或方法（函数）当作锁，哪个线程先执行带synchronized关键字的方法，哪个线程就持有该方法所属对象的锁，其他线程都只能呈等待状态。但是这有个前提：既然锁叫做对象锁，那么势必和对象相关，所以多个线程访问的必须是同一个对象。

如果多个线程访问的是多个对象，那么Java虚拟机就会创建多个锁，就像上面的例子一样，创建了两个ThreadDomain13对象，就产生了2个锁。既然两个线程持有的是不同的锁，自然不会受到"等待释放锁"这一行为的制约，可以分别运行addNum(String userName)中的代码。

 

synchronized方法与锁对象

上面我们认识了对象锁，对象锁这个概念，比较抽象，确实不太好理解，看一个例子，在一个实体类中定义一个同步方法和一个非同步方法：

复制代码

public class ThreadDomain14_0
{
    public synchronized void methodA()
    {
        try
        {
            System.out.println("Begin methodA, threadName = " + 
                    Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("End methodA, threadName = " + 
                    Thread.currentThread().getName() + ", end Time = " + 
                    System.currentTimeMillis());
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
    
    public void methodB()
    {
        try
        {
            System.out.println("Begin methodB, threadName = " + 
                    Thread.currentThread().getName() + ", begin time = " + 
                    System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("End methodB, threadName = " + 
                    Thread.currentThread().getName());
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

复制代码

一个线程调用其同步方法，一个线程调用其非同步方法：

复制代码

public class MyThread14_0 extends Thread
{
    private ThreadDomain14_0 td;
    
    public MyThread14_0(ThreadDomain14_0 td)
    {
        this.td = td;
    }
    
    public void run()
    {
        td.methodA();
    }
}

复制代码

复制代码

public class MyThread14_1 extends Thread
{
    private ThreadDomain14_0 td;
    
    public MyThread14_1(ThreadDomain14_0 td)
    {
        this.td = td;
    }
    
    public void run()
    {
        td.methodB();
    }
}

复制代码

写一个main函数去调用这两个线程：

复制代码

public static void main(String[] args)
{
    ThreadDomain14_0 td = new ThreadDomain14_0();
    MyThread14_0 mt0 = new MyThread14_0(td);
    mt0.setName("A");
    MyThread14_1 mt1 = new MyThread14_1(td);
    mt1.setName("B");
    mt0.start();
    mt1.start();
}

复制代码

看一下运行效果：

Begin methodA, threadName = A
Begin methodB, threadName = B, begin time = 1443697780869
End methodB, threadName = B
End methodA, threadName = A, end Time = 1443697785871

从结果看到，第一个线程调用了实体类的methodA()方法，第二个线程完全可以调用实体类的methodB()方法。但是我们把methodB()方法改为同步就不一样了，就不列修改之后的代码了，看一下运行结果：

Begin methodA, threadName = A
End methodA, threadName = A, end Time = 1443697913156
Begin methodB, threadName = B, begin time = 1443697913156
End methodB, threadName = B

从这个例子我们得出两个重要结论：

1、A线程持有Object对象的Lock锁，B线程可以以异步方式调用Object对象中的非synchronized类型的方法

2、A线程持有Object对象的Lock锁，B线程如果在这时调用Object对象中的synchronized类型的方法则需要等待，也就是同步

 

synchronized锁重入

关键字synchronized拥有锁重入的功能。所谓锁重入的意思就是：当一个线程得到一个对象锁后，再次请求此对象锁时时可以再次得到该对象的锁的。看一个例子：

复制代码

public class ThreadDomain16
{
    public synchronized void print1()
    {
        System.out.println("ThreadDomain16.print1()");
        print2();
    }
    
    public synchronized void print2()
    {
        System.out.println("ThreadDomain16.print2()");
        print3();
    }
    
    public synchronized void print3()
    {
        System.out.println("ThreadDomain16.print3()");
    }
}

复制代码

复制代码

public class MyThread16 extends Thread
{
    public void run()
    {
        ThreadDomain16 td = new ThreadDomain16();
        td.print1();
    }
}

复制代码

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

看一下运行结果：

ThreadDomain16.print1()
ThreadDomain16.print2()
ThreadDomain16.print3()

看到可以直接调用ThreadDomain16中的打印语句，这证明了对象可以再次获取自己的内部锁。这种锁重入的机制，也支持在父子类继承的环境中。

 

异常自动释放锁

最后一个知识点是异常。当一个线程执行的代码出现异常时，其所持有的锁会自动释放。模拟的是把一个long型数作为除数，从MAX_VALUE开始递减，直至减为0，从而产生ArithmeticException。看一下例子：

复制代码

public class ThreadDomain17
{
    public synchronized void testMethod()
    {
        try
        {
            System.out.println("Enter ThreadDomain17.testMethod, currentThread = " + 
                    Thread.currentThread().getName());
            long l = Integer.MAX_VALUE;
            while (true)
            {
                long lo = 2 / l;
                l--;
            }
        } 
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

复制代码

复制代码

public class MyThread17 extends Thread
{
    private ThreadDomain17 td;
    
    public MyThread17(ThreadDomain17 td)
    {
        this.td = td;
    }
    
    public void run()
    {
        td.testMethod();
    }
}

复制代码

复制代码

public static void main(String[] args)
{
    ThreadDomain17 td = new ThreadDomain17();
    MyThread17 mt0 = new MyThread17(td);
    MyThread17 mt1 = new MyThread17(td);
    mt0.start();
    mt1.start();
}

复制代码

看一下运行结果：

复制代码

Enter ThreadDomain17.testMethod, currentThread = Thread-0
Enter ThreadDomain17.testMethod, currentThread = Thread-1
java.lang.ArithmeticException: / by zero
    at com.xrq.example.e17.ThreadDomain17.testMethod(ThreadDomain17.java:14)
    at com.xrq.example.e17.MyThread17.run(MyThread17.java:14)
java.lang.ArithmeticException: / by zero
    at com.xrq.example.e17.ThreadDomain17.testMethod(ThreadDomain17.java:14)
    at com.xrq.example.e17.MyThread17.run(MyThread17.java:14)

复制代码

因为打印结果是静态的，所以不是很明显。在l--前一句加上Thread.sleep(1)结论会更明显，第一句打出来之后，整个程序都停住了，直到Thread-0抛出异常后，Thread-1才可以运行，这也证明了我们的结论。

 

后记

文章里面的这些个结论，记一下都是很快的，但是是否记一下就好了？我认为记住这些结论一点都不重要，重要的应该是学习如何通过代码去验证这些结论。因为只有知道了如何通过代码去验证结论，才可以说真正对于synchronized关键字的各种细节有了感性、有了深入的理解，以后碰到其他synchronized的场景就可以以自己的理解去正确分析问题。

jacljh
关注
专栏目录
Synchronized与三种锁态
惟愿无事
12-17 8216
介绍Sychronized的锁实现原理以及三种锁态（偏向锁、轻量级锁和重量级锁）的关系
多线程中的锁 —— synchronized
AlinaQ05的博客
08-20 617
在 JVM 层面，synchronized 同步锁是依靠==监视器 monitor== 实现的。 synchronized 同步代码块的实现是通过 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。当 jvm执行到 monitorenter 指令时，当前线程试图获取monitor 对象的所有权，如果未加锁或者已经被当前线程所持有
synchronized 的特性与机制
最新发布
weixin_72779762的博客
09-28 1388
自旋锁虽然可以在第一时间拿到锁,但是消耗大量的cpu资源,如果七八个自选,会大量占用cpu的资源,所以会转化成重量级锁,在内核进行阻塞等待。概括 : 刚开始加锁是偏向锁状态,遇到了锁竞争,就变成自旋锁,竞争愈演愈烈(七八个争一个锁)直接变成重量级锁(交给内核阻塞等待)一旦遇到了别的线程来竞争这个锁,这个偏向锁立马升级成轻量级锁,别的线程只能等待(jvm会通知先到的线程,让他把锁进行升级一下)挂起等待锁是如果锁被释放了,不能第一时间拿到锁,可能过很久才有可能拿到锁。乐观锁做的工作会少一下,效率会更高。
java 多线程锁机制Synchronized
tim_szchina的博客
06-24 203
http://www.sunxin.org/forum/thread/19757.html java 多线程锁机制Synchronized <script type="text/javascript"></script>       [关键字： Synchronized ] 打个比方：一个object就像一个大房子，大门永远打开。房子里有很多房间（也就是方法）。这些...
Java多线程：锁机制Synchronized与Lock
hacjy
10-16 345
synchronized： 是一个关键字，作用在类或者对象上。一旦线程A获取到锁，B就需要一直等待直到A释放了锁，所以它是不可中断的，这样子影响效率。使用该关键字，不知道是否获取成功获取到锁。是可重入锁，意思是：假如两个方法method1和method2，都用synchronized修饰，然后在method1中调用method2。调用method1，获取到当前对象锁，执行method2的话不需要再...
Java 多线程同步 锁机制与synchronized深入解析
09-05
总结来说，Java的synchronized关键字提供了锁机制，用于实现多线程环境下的同步。同步方法和同步代码块是两种不同级别的同步控制，同步代码块提供了更灵活的控制和更高的效率。理解并合理使用这些机制对于编写高效、...
Java多线程中使用synchronized说明
12-22
在Java多线程编程中，`synchronized`有多种用法，包括修饰实例方法、静态方法以及作为代码块来锁定特定的对象引用。 1. **修饰实例方法**： 当`synchronized`关键字用于实例方法时，它会对该实例对象加锁。这意味...
Java多线程通信:交替打印ABAB实例
09-07
总结起来，Java多线程通信的关键在于正确使用`synchronized`关键字、`wait()`、`notify()`和`notifyAll()`方法来协调线程的执行。在设计多线程程序时，应确保线程间的同步和通信机制正确无误，以保证程序的正确性和...
java多线程编程之Synchronized块同步方法
09-03
在Java多线程编程中，`synchronized`关键字是一个至关重要的概念，用于实现线程间的同步，以确保共享资源的安全访问。本篇文章将深入探讨`synchronized`块同步方法及其应用，通过实例来阐述其工作原理。 首先，我们...
Java多线程并发编程 Synchronized关键字
08-30
Java中的`synchronized`关键字是多线程编程中用于实现线程同步的重要机制，它确保了在多线程环境下对共享资源的访问具有互斥性和可见性。这些特性使得`synchronized`成为解决并发问题的关键工具。 1. **同步锁机制*...
JAVA多线程之synchronized锁
ifhuke的博客
03-20 1162
对synchronized的使用、偏向锁、Monitor、锁膨胀等进行介绍，同时将synchronized的锁优化进行了一些讲解
Synchronized锁机制
m0_54202121的博客
04-21 477
文章目录2.1 Synchronized2.1.1 Synchronized 关键字回顾synchronized关键字的底层实现synchronized修饰代码块synchronized修饰普通方法synchronized修饰静态方法2.1.2 售票案例 2.1 Synchronized 2.1.1 Synchronized 关键字回顾 synchronized 关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 另外，在
Java 多线程同步 锁机制与synchronized
人生就是一种修行
10-21 112
打个比方：一个object就像一个大房子，大门永远打开。房子里有很多房间（也就是方法）。这些房间有上锁的（synchronized方法）， 和不上锁之分（普通方法）。房门口放着一把钥匙（key），这把钥匙可以打开所有上锁的房间。 另外我把所有想调用该对象方法的线程比喻成想进入这房子某个 房间的人。所有的东西就这么多了，下面我们看看这些东西之间如何作用的。 在此我们先来明确一下我们的前提...
多线程锁（synchronized 锁的执行顺序、公平锁和非公平锁）
qq_51985869的博客
06-06 628
非公平锁：效率高，但是线程容易饿死（所有的工作，有一个线程完成）公平锁：效率相对低 ，但是cpu 的利用高了。可以有多把同步锁，但只能有一把静态同步锁。多线程 多对象 多把对象锁，之间互不干扰。一个线程即一个对象，所以只有一把对象锁。同步锁间互不干扰，静态同步锁按顺序执行。一个线程即一个类，所以只有一把类锁。只能有一把同步锁，一把静态同步锁。多线程属于同个类，只有一把类锁。一个线程就一个对象，一个类。多线程即多个对象，同个类；对象级别，一个对象一把锁。两把锁，之间互不干扰。类级别，一个类一把锁。
java 线程锁synchronized_Java多线程4：synchronized锁机制
weixin_31001069的博客
02-13 261
脏读一个常见的概念。在多线程中，难免会出现在多个线程中对同一个对象的实例变量进行并发访问的情况，如果不做正确的同步处理，那么产生的后果就是"脏读"，也就是取到的数据其实是被更改过的。按照正常来看应该打印"a num = 100"和"b num = 200"才对，现在却打印了"b num = 200"和"a num = 200"，这就是线程安全问题。我们可以想一下是怎么会有线程安全的问题的：1、mt...
Synchronized 锁机制
BASK2311的博客
01-16 390
为了避免临界区的竞态条件发生，可以用非阻塞式的原子变量，也可以用阻塞式的锁。Java 多线程的锁都是，采用互斥的方式让同一时刻只有一个线程能够持有对象锁，从而进入临界区，而其它线程只能阻塞等待，因此不用担心线程上下文切换造成共享资源错乱。
多线程--锁机制+synchronized的用法
qq_27886997的博客
10-15 344
一、什么是锁机制，有啥作用？ 锁机制是java虚拟机内部提供的，每个对象都有各自的对象锁，一个类的不同实例，它们的对象锁也不同，每个类也有自己的类锁，类在虚拟机中只加载一份，所以每个类只有一个类锁，类锁的实质还是类加载时产生的字节码对象的对象锁。synchronized是一种标志，用来标记一个区域或者某个方法。一个线程获取了某个对象的对象锁，这时候只有该线程才能访问该对象中被synchroniz
Java多线程详解：Synchronized机制与线程创建
通过理解Synchronized机制和Java多线程的原理，开发者可以更好地设计和实现并发安全的程序，避免数据竞争和死锁等问题，提高程序的可靠性和性能。在实际编程中，合理地使用线程和锁，可以极大地优化程序的执行效率和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值