java synchronized详解--synchronized方法

最新推荐文章于 2024-06-15 16:22:13 发布
最新推荐文章于 2024-06-15 16:22:13 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： java基础 文章标签： java synchroniz java同步锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mingliangniwo/article/details/55517853
版权

上一章讲了synchronized代码块,这章说一下synchronize方法，及synchronized代码块与synchronized方法的联系

上一章说的synchronized代码块，主要说了synchronized锁(类似现实中的锁)的重要性和注意项
这章说一下synchronized修饰的方法的关键点和注意项
如果你拜读了java官方文档，你会知道synchronized方法也有锁(类似现实中的锁)，那么它的锁(类似现实中的锁)是什么呢，下面通过代码和运行结果来找出答案

结构简述：

定义了一个资源PrintDemo3，一个线程类ThreadDemo3，一个测试类TestThread，在测试类中创建两个线程对象，两个线程对象都通过run方法访问资源PrintDemo.printCount方法

第一种场景：资源加锁在synchronized方法上
第一幕：
package com.yy.test;

/**
 * Created by skyler on 2017/2/17.
 */
class PrintDemo3 {
    public synchronized void printCount() {
        try {
            for(int i = 10; i > 0; i--) {
                System.out.println("Counter   ---   "  + i );
            }
        }catch (Exception e) {
            System.out.println("Thread  interrupted.");
        }
    }
}

class ThreadDemo3 extends Thread {
    private Thread t;
    private String threadName;
    PrintDemo3  PD;

    ThreadDemo3( String name,  PrintDemo3 pd) {
        threadName = name;
        PD = pd;
    }

    public void run() {
        try {
            Thread.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        PD.printCount();
        System.out.println("Thread " +  threadName + " exiting.");
    }

    public void start () {
        System.out.println("Starting " +  threadName );
        if (t == null) {
            t = new Thread (this, threadName);
            t.start ();
        }
    }
}

public class TestThread {
    public static void main(String args[]) {
        TestThread tt = new TestThread();
        tt.test1();
    }

    public void test1() {
        PrintDemo3 PD = new PrintDemo3();
        PrintDemo3 PD3 = new PrintDemo3();

        ThreadDemo3 T1 = new ThreadDemo3( "Thread - 1 ", PD );
        ThreadDemo3 T2 = new ThreadDemo3( "Thread - 2 ", PD3 );

        T1.start();
        T2.start();

        // wait for threads to end
        try {
            T1.join();
            T2.join();
        }catch( Exception e) {
            System.out.println("Interrupted");
        }
    }
}

上面代码在PrintDemo3.printCount()上加了synchronized修饰符，表示这个方法是加锁了的。之后定义了两个PrintDemo3对象PD、PD3和两个ThreadDemo3线程对象T1、T2，并把PD、PD3分别传给T1、T2，见test1方法

运行后查看结果：

Starting Thread - 1 
Starting Thread - 2 
Counter   ---   10
Counter   ---   9
Counter   ---   8
Counter   ---   7
Counter   ---   6
Counter   ---   10
Counter   ---   9
Counter   ---   8
Counter   ---   7
Counter   ---   6
Counter   ---   5
Counter   ---   4
Counter   ---   3
Counter   ---   2
Counter   ---   1
Thread Thread - 2  exiting.
Counter   ---   5
Counter   ---   4
Counter   ---   3
Counter   ---   2
Counter   ---   1
Thread Thread - 1  exiting.

从结果得出，资源被两个线程同时访问了，synchronized方法的锁没有起作用。原因我们稍后再说，稍稍改一下代码

第二幕：

改一下代码：ThreadDemo3 T2 = new ThreadDemo3( “Thread - 2 “, PD3 ) 中的PD3改为PD

修改代码后运行，查看结果

Starting Thread - 1 
Starting Thread - 2 
Counter   ---   10
Counter   ---   9
Counter   ---   8
Counter   ---   7
Counter   ---   6
Counter   ---   5
Counter   ---   4
Counter   ---   3
Counter   ---   2
Counter   ---   1
Thread Thread - 1  exiting.
Counter   ---   10
Counter   ---   9
Counter   ---   8
Counter   ---   7
Counter   ---   6
Counter   ---   5
Counter   ---   4
Counter   ---   3
Counter   ---   2
Counter   ---   1
Thread Thread - 2  exiting.

从结果得出，实现了资源被线程独享
第一幕和第二幕代码的不同处只有传给两个线程的PrintDemo3对象不同。第一幕中两个线程T1、T2分别传递了PD、PD3。而第二幕中两个线程T1、T2都传递了PD。所以可以猜想，造成结果不同的原因也是由于锁(类似现实中的锁)的不同引起的。而修饰方法的synchronized的锁(类似现实中的锁)是synchronized方法所在类的对象实例，相当于synchronized方法等于方法里的synchronized(this)代码块，这里的this就是synchronized方法所在类的对象实例。

为了验证这个猜想，看第二种场景

第二种场景：资源加锁在方法内的synchronized(this)代码块上
package com.yy.test;

/**
 * Created by yaoliang on 2017/2/17.
 */
class PrintDemo3 {
    public void printCount() {
        synchronized(this) {
            try {
                for(int i = 10; i > 0; i--) {
                    System.out.println("Counter   ---   "  + i );
                }
            }catch (Exception e) {
                System.out.println("Thread  interrupted.");
            }
        }
    }
}

class ThreadDemo3 extends Thread {
    private Thread t;
    private String threadName;
    PrintDemo3  PD;

    ThreadDemo3( String name,  PrintDemo3 pd) {
        threadName = name;
        PD = pd;
    }

    public void run() {
        try {
            Thread.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        PD.printCount();
        System.out.println("Thread " +  threadName + " exiting.");
    }

    public void start () {
        System.out.println("Starting " +  threadName );
        if (t == null) {
            t = new Thread (this, threadName);
            t.start ();
        }
    }
}

public class TestThread {
    public static void main(String args[]) {
        TestThread tt = new TestThread();
        tt.test1();
    }

    public void test1() {
        PrintDemo3 PD = new PrintDemo3();
        PrintDemo3 PD3 = new PrintDemo3();

        ThreadDemo3 T1 = new ThreadDemo3( "Thread - 1 ", PD );
        ThreadDemo3 T2 = new ThreadDemo3( "Thread - 2 ", PD3 );

        T1.start();
        T2.start();

        // wait for threads to end
        try {
            T1.join();
            T2.join();
        }catch( Exception e) {
            System.out.println("Interrupted");
        }
    }
}

场景二的代码与场景一99%是一样的，不同之处在PrintDemo3.printCount()方法上，把方法修饰符synchronized移到了此方法内，并把this作为synchronized的锁(类似现实中的锁)

第三幕：

两个线程T1、T2分别传递了PD、PD3

运行test1()方法并查看结果：

Starting Thread - 1 
Starting Thread - 2 
Counter   ---   10
Counter   ---   9
Counter   ---   8
Counter   ---   7
Counter   ---   10
Counter   ---   6
Counter   ---   9
Counter   ---   8
Counter   ---   7
Counter   ---   6
Counter   ---   5
Counter   ---   4
Counter   ---   3
Counter   ---   2
Counter   ---   1
Thread Thread - 2  exiting.
Counter   ---   5
Counter   ---   4
Counter   ---   3
Counter   ---   2
Counter   ---   1
Thread Thread - 1  exiting.
第四幕：

修改test1()方法代码为：

ThreadDemo3 T1 = new ThreadDemo3( "Thread - 1 ", PD );
ThreadDemo3 T2 = new ThreadDemo3( "Thread - 2 ", PD );

也就是两个线程T1、T2都传递了PD

运行test1()方法并查看结果：

Starting Thread - 1 
Starting Thread - 2 
Counter   ---   10
Counter   ---   9
Counter   ---   8
Counter   ---   7
Counter   ---   6
Counter   ---   5
Counter   ---   4
Counter   ---   3
Counter   ---   2
Counter   ---   1
Thread Thread - 1  exiting.
Counter   ---   10
Counter   ---   9
Counter   ---   8
Counter   ---   7
Counter   ---   6
Counter   ---   5
Counter   ---   4
Counter   ---   3
Counter   ---   2
Counter   ---   1
Thread Thread - 2  exiting.

从结果得出，实现了资源被线程独享

比较第一幕和第三幕，第二幕和第四幕，可以发现如下

结论：

synchronized方法等于方法中加入synchronized(this)代码块，也就是synchronized修饰方法时，synchronized的锁(类似现实中的锁)是调用这个方法的类的对象实例，如PD.printCount()，此时synchronized锁就是PD;而PD3.printCount()，此时synchronized锁就是PD3

以上说了synchronized应用级的用法，关于内部原理实现，我的水平还有待提高，请看下面关于原理的讲解：

http://www.importnew.com/23511.html
https://www.quora.com/How-does-synchronize-work-in-Java
http://blog.takipi.com/5-things-you-didnt-know-about-synchronization-in-java-and-scala/
http://gee.cs.oswego.edu/dl/cpj/jmm.html

初露寒秋
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java synchronized用法详解
fanc的博客
06-13 646
参考链接：https://blog.csdn.net/evankaka/article/details/44153709 线程运行状态图： synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 修饰一个方法，被修饰的方法称为同步方法，其作用的范...
java-synchronized 嵌套使用代码详解
08-29
java-synchronized 嵌套使用代码详解 java-synchronized 嵌套使用是 Java 编程语言中的一种同步机制，用于解决多线程并发执行时的线程安全问题。通过使用 synchronized 关键字，可以将某个对象或代码块锁定，使得...
java-synchronized方法
Ysh-uestc
04-05 199
  在java中，为了避免多个线程对同一资源访问操作时候的干扰脏读，可以用synchronized来同步方法class MyObject{ public synchronized void methodA(){ try{ System.out.println("begin methodA threadName=" + Thread.currentThread().getName...
深入理解Java中的synchronized关键字
最新发布
weixin_74268571的博客
06-15 1339
synchronized的详细讲解和底层实现，以及synchronized的同步机制，synchronized的重入和synchronized的异常演示
synchronized 方法
Simba's
02-22 754
因为之前对syncronized方法的错误理解，最近犯了一个很严重的错误，以此文记。 错误理解：synchronized 方法仅对此同步方法加锁，只是这个方法不能被多个线程同步执行。 正确理解：synchronized 方法对整个实例内所有synchronized 方法加锁，一个实例内所有的synchronized 方法不能被同步执行。 ---------- 参考：1、笔试：当一个
Synchronized 有几种用法？
KHOST的博客
12-13 734
我们都知道 Synchronized 是线程安全同步用的，大部分程序可能只会用到同步方法上面。其实 Synchronized 可以用到更多的场合，栈长列举了以下几个用法。 1、同步普通方法 这个也是我们用得最多的，只要涉及线程安全，上来就给方法来个同步锁。这种方法使用虽然最简单，但是只能作用在单例上面，如果不是单例，同步方法锁将失效。 /**  * 用在普通方法  */ private s...
Synchronized 详解
ant的博客
04-12 2699
语法 synchronized(锁对象) // 线程1， 线程2(blocked) { 临界区 } 注意 如果 t1 synchronized(obj1) 而 t2 synchronized(obj2) 会怎样？ 此种方式相当于多个线程持有不同的锁，不会起到保证临界区代码是原子性操作，达不到预期 如果 t1 synchronized(obj) 而 t2 没有加会怎么样？ 此种方式相当于一个线程持有锁一个线程没有锁，不会起到保证临界区代码是原子性操作，达不到预期 方法上的synchronized形式
java-synchronized详解.doc
05-09
Java中的`synchronized`关键字是多线程编程中的一个重要概念，用于控制并发访问共享资源，以保证数据的一致性和完整性。本文将深入解析`synchronized`在Java中的应用和工作原理。 一、`synchronized`的基本用法 `...
Java-synchronized详解.docx
11-20
Java synchronized 详解 Java 中的同步机制是多线程编程中最重要的概念之一。它允许开发者控制多个线程对共享资源的访问，以避免数据不一致和race condition。这篇文章将详细介绍 Java 中的 synchronized 机制，...
Java中的关键字synchronized 详解
08-26
Java中的关键字synchronized 详解 Java中的关键字synchronized是Java语言中用于线程同步的关键字。它可以修饰方法或代码块，以便在多线程环境中保护共享资源的安全。 1、修饰普通方法 synchronized关键字可以修饰...
Java多线程synchronized同步方法详解
08-24
本文将深入探讨`synchronized`同步方法在Java多线程环境中的应用。 1. **synchronized 方法与锁对象** `synchronized`关键字可以应用于方法或代码块，以实现线程同步。对于同步方法，锁对象是该方法所在类的实例...
「java」 synchronized 方法
qq_36098284的博客
04-16 871
synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。 本文阐述synchronized 方法的使用，synchronized 块的内容请参考我的另一篇文章：「java」synchronized（this） 区块 1. synchronized 方法： 通过在方法声明中加入 synchronized关键字来声明 synch...
JAVA系列---synchronized的用法
lipviolet的博客
04-28 4698
1. 背景 1.1 多线程操作同一个对象 1.1.1 不加锁 public class HandleThread { public static void main(String[] args) { SyncThread s1 = new SyncThread(); SyncThread s2 = new SyncThread(); Thread t1 = new Thread(s1); // Thread t2 = new Threa
Java中synchronized的几种使用方法
justlpf的专栏
04-21 306
使用 synchronized 无需手动执行加锁和释放锁的操作，我们只需要声明 synchronized 关键字就可以了，JVM 层面会帮我们自动的进行加锁和释放锁的操作。synchronized 可用于修饰普通方法、静态方法和代码块，接下来我们分别来看。用 3 种用法，用它可以来修饰普通方法静态方法和代码块，其中最常用的是修饰代码块，而修饰代码块时需要指定一个加锁对象，这个加锁对象通常使用this或xxx.class来表示，当使用this时，表示使用当前对象来加锁，而使用。
java多线程（四）synchronized关键字修饰方法
热门推荐
xingjiarong的专栏
08-24 1万+
在之前的博客中我们介绍了条件对象和锁对象，两者结合使用才能起到比较好的互斥与同步效果，大家可能觉得有些麻烦，有没有将两者结合起来的工具呢，有！java提供了synchronized关键字来实现线程的互斥和同步，其达到的效果相当于条件对象和锁对象结合起来的效果。synchronized关键字有两类用法，一类是修饰方法，一类是修饰代码块，这篇博客主要介绍一下synchronized关键字修饰方法时的用
Synchronized详解
Hyutao的博客
02-12 126
Synchronized详解 1、修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； synchronized (this){ ............ //修饰代码块，使用this关键字 } Object lock1 = new Object(); Object lock2 = new Object()...
synchronized用法详解
05-13 104
1、介绍 Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍可以访问该obje...
"Java synchronized详解：保证线程安全的关键
本文档主要讲述的是java synchronized详解。Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。 第一篇：Java 语言的关键字，当它用来修饰一个方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值