Synchronized 关键字中的类锁、对象锁

最新推荐文章于 2021-11-28 14:18:50 发布
最新推荐文章于 2021-11-28 14:18:50 发布
阅读量238 收藏
点赞数
分类专栏： Java基础
本文为博主原创文章，未经博主允许不得转载。哈哈哈
本文链接：https://blog.csdn.net/heatdeath/article/details/79603829
版权

1 未加 Synchronized 关键字

package com.didi.sec.synchronized_learn;

/**
 * Author:  heatdeath
 * Date:    2018/3/18
 * Desc:
 */
public class SynchronizedMethod {
    public static void main(String[] args) {
        final TestClass_1 case_1 = new TestClass_1();
        new Thread() {
            @Override
            public void run() {
                case_1.method_1();
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                case_1.method_1();
            }
        }.start();
    }
}

class TestClass_1 {
    public void method_1() {
        try {
            System.out.println(Thread.currentThread().getName() + " begin:");
            System.out.println("begin time= " + System.currentTimeMillis());
            Thread.sleep(2000);
            System.out.println("end    end= " + System.currentTimeMillis());
            System.out.println(Thread.currentThread().getName() + " end.");
            System.out.println("------------");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

这里写图片描述

两线程以并行方式执行

2 在非 static 方法上加 Synchronized 关键字

package com.didi.sec.synchronized_learn;

/**
 * Author:  heatdeath
 * Date:    2018/3/18
 * Desc:
 */
public class SynchronizedMethod {
    public static void main(String[] args) {
        final TestClass_1 case_1 = new TestClass_1();
        new Thread() {
            @Override
            public void run() {
                case_1.method_1();
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                case_1.method_1();
            }
        }.start();
    }
}

class TestClass_1 {
    public synchronized void method_1() {
        try {
            System.out.println(Thread.currentThread().getName() + " begin:");
            System.out.println("begin time= " + System.currentTimeMillis());
            Thread.sleep(2000);
            System.out.println("end    end= " + System.currentTimeMillis());
            System.out.println(Thread.currentThread().getName() + " end.");
            System.out.println("------------");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

这里写图片描述

两线程以串行方式执行

3 在非 static 方法的内部代码块加上 synchronized(this) 

public class SynchronizedMethod {
    public static void main(String[] args) {
        final TestClass_1 case_1 = new TestClass_1();
        new Thread() {
            @Override
            public void run() {
                case_1.method_1();
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                case_1.method_1();
            }
        }.start();
    }
}

class TestClass_1 {
    public void method_1() {
        try {
            synchronized (this) {
                System.out.println(Thread.currentThread().getName() + " begin:");
                System.out.println("begin time= " + System.currentTimeMillis());
                Thread.sleep(2000);
                System.out.println("end    end= " + System.currentTimeMillis());
                System.out.println(Thread.currentThread().getName() + " end.");
                System.out.println("------------");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

这里写图片描述

4 在 static 方法前加上 synchronized 关键字

public class SynchronizedMethod {
    public static void main(String[] args) {
//        final TestClass_1 case_1 = new TestClass_1();
        new Thread() {
            @Override
            public void run() {
                TestClass_1.method_1();
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                TestClass_1.method_1();
            }
        }.start();
    }
}

class TestClass_1 {
    public synchronized static void method_1() {
        try {
            System.out.println(Thread.currentThread().getName() + " begin:");
            System.out.println("begin time= " + System.currentTimeMillis());
            Thread.sleep(2000);
            System.out.println("end    end= " + System.currentTimeMillis());
            System.out.println(Thread.currentThread().getName() + " end.");
            System.out.println("------------");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

这里写图片描述

5 synchronized (TestClass_1.class) static 方法

public class SynchronizedMethod {
    public static void main(String[] args) {
//        final TestClass_1 case_1 = new TestClass_1();
        new Thread() {
            @Override
            public void run() {
                TestClass_1.method_1();
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                TestClass_1.method_1();
            }
        }.start();
    }
}

class TestClass_1 {
    public static void method_1() {
        try {
            synchronized (TestClass_1.class) {
                System.out.println(Thread.currentThread().getName() + " begin:");
                System.out.println("begin time= " + System.currentTimeMillis());
                Thread.sleep(2000);
                System.out.println("end    end= " + System.currentTimeMillis());
                System.out.println(Thread.currentThread().getName() + " end.");
                System.out.println("------------");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

这里写图片描述

6 synchronized (TestClass_1.class) 非 static 方法

public class SynchronizedMethod {
    public static void main(String[] args) {
        final TestClass_1 case_1 = new TestClass_1();
        new Thread() {
            @Override
            public void run() {
                case_1.method_1();
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                case_1.method_1();
            }
        }.start();
    }
}

class TestClass_1 {
    public void method_1() {
        try {
            synchronized (TestClass_1.class) {
                System.out.println(Thread.currentThread().getName() + " begin:");
                System.out.println("begin time= " + System.currentTimeMillis());
                Thread.sleep(2000);
                System.out.println("end    end= " + System.currentTimeMillis());
                System.out.println(Thread.currentThread().getName() + " end.");
                System.out.println("------------");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

这里写图片描述

7 

public class SynchronizedMethod {
    public static void main(String[] args) {
        final TestClass_1 case_1 = new TestClass_1();
        new Thread() {
            @Override
            public void run() {
                case_1.method_1();
            }
        }.start();

        final TestClass_1 case_2 = new TestClass_1();

        new Thread() {
            @Override
            public void run() {
                case_2.method_1();
            }
        }.start();
    }
}

class TestClass_1 {
    public void method_1() {
//        System.out.println("hahahaha");
        try {
            synchronized (this) {
                System.out.println(Thread.currentThread().getName() + " begin:");
                System.out.println("begin time= " + System.currentTimeMillis());
                Thread.sleep(2000);
                System.out.println("end    end= " + System.currentTimeMillis());
                System.out.println(Thread.currentThread().getName() + " end.");
                System.out.println("------------");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
//        System.out.println("wwwwwwww");
    }
}

这里写图片描述

8 

public class SynchronizedMethod {
    public static void main(String[] args) {
        final TestClass_1 case_1 = new TestClass_1();
        new Thread() {
            @Override
            public void run() {
                case_1.method_1();
            }
        }.start();
        final TestClass_1 case_2 = new TestClass_1();
        new Thread() {
            @Override
            public void run() {
                case_1.method_1();
            }
        }.start();
    }
}

class TestClass_1 {
    private static Integer val = 0;
    public void method_1() {
        try {
            synchronized (val) {
                System.out.println(Thread.currentThread().getName() + " begin:");
                System.out.println("begin time= " + System.currentTimeMillis());
                Thread.sleep(2000);
                System.out.println("end    end= " + System.currentTimeMillis());
                System.out.println(Thread.currentThread().getName() + " end.");
                System.out.println("------------");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

这里写图片描述

HeatDeath
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础Synchronized关键字之对象锁
weixin_33860553的博客
11-04 442
java中Synchronized关键字之对象锁 　 当有多个线程对一个共享数据进行操作时，需要注意多线程的安全问题。 　　多线程的同步机制对资源进行加锁，使得在同一个时间，只有一个线程可以进行操作，同步用以解决多个线程同时访问时可能出现的问题。而用的最多的就是synchronized关键字。 　　语法：Synchronized(对象锁){} 　　被synchronized关键字修饰的...
java多线程编程之Synchronized关键字详解
09-02
主要为大家详细介绍了java多线程编程之Synchronized关键字，感兴趣的朋友可以参考一下
Java多线程初学者指南（10）：使用Synchronized关键字同步
死牛胖子的技术随笔
11-16 245
要想解决“脏数据”的问题，最简单的方法就是使用synchronized关键字来使run方法同步，代码如下： [code="java"]public synchronized void run() { } [/code] 从上面的代码可以看出，只要在void和public之间加上synchronized关键字，就可以使run方法同步，也就是说，对于同一个Java...
Java 学习笔记之 Synchronized锁对象
baguashenp74070的博客
10-22 94
Synchronized锁对象： Synchronized取得的锁都是对象锁，而不是把一段代码或方法当作锁，哪个线程执行带synchronized关键字的方法，哪个线程就持有该方法所属对象的锁，那么其他线程只能等待，前提是多个线程访问的是同一个对象。 实验得出以下结论： A线程先持有object对象的Lock锁，B线程可以以异步的方式调用object对象中的非synchr...
java中关于锁的关键字
秦超的学习笔记
09-05 3420
java中关于锁的关键字有2个 ， synchronized 和volatile。 synchronized 可以对方法和语句块进行修饰。从而实现同一时刻只有一个线程能够执行。 volatile可以对变量进行修饰。保证线程在每次使用变量的时候，都会读取变量修改后的最的值。 很多人都将volatile理解为和synchronized差不多的功能。然而，实际情况并不是这样。 volatile只能
java锁关键字_Java中synchronized关键字引出的多种锁 问题
weixin_39874795的博客
02-16 199
前言Java 中的 synchronized关键字可以在多线程环境下用来作为线程安全的同步锁。本文不讨论 synchronized 的具体使用，而是研究下synchronized底层的锁机制，以及这些锁分别的优缺点。一 synchronized机制synchronized关键字是JAVA中常用的同步功能，提供了简单易用的锁功能。synchronized有三种用法，分别为:用在普通方法上，能够锁住当...
深入讲解java线程与synchronized关键字
08-31
Java 中多线程的同步依靠的是对象锁机制,synchronized关键字就是利用了封装对象锁来实现对共享资源的互斥访问。下面这篇文章主要介绍了java线程与synchronized关键字的相关资料，需要的朋友可以参考下。
synchronized锁原理分析（一、从Java对象头看synchronized锁的状态）
12-21
synchronized关键字”锁”的实现本质 synchronized关键字实现的锁是依赖于JVM的，底层调用的是操作系统的指令集实现。 Lock接口实现的锁不一样，例如ReentrantLock锁是基于JDK实现的，有Java原生代码来实现的。 ...
Lock接口与synchronized关键字
最新发布
04-19
Lock接口与synchronized关键字在Java并发编程中都是用于实现同步机制的重要工具，但它们在使用方式、功能特性以及灵活性等方面存在一些显著的差异。 首先，从使用方式上来看，synchronized是Java语言内置的关键字，...
实例解析Java中的synchronized关键字与线程安全问题
01-03
synchronized代码块，被修饰的代码成为同步语句块，其作用的范围是调用这个代码块的对象，我们在用synchronized关键字的时候，能缩小代码段的范围就尽量缩小，能在代码段上加同步就不要再整个方法上加同步。...
锁 & synchronized 关键字
一朵花花
11-28 1163
本篇接着上篇 线程安全，可以先看一下上篇~~ 锁锁 是什么？锁的特点：锁的基本操作：锁的使用synchronized 关键字 — 监视器锁理解 synchronized 的具体使用：synchronized 的几种常见用法：举例： 两个线程尝试获取同一把锁????若两个线程分别加自己的锁(即：不是同一把锁) 锁 是什么？ 举例理解： 锁的特点： 锁的特点是互斥的，同一时刻只有一个线程能获取到锁，其他的线程若也尝试获取锁，就会发生阻塞等待，一旦发生等待，需一直等到刚才的线程释放锁，此时剩下的线程再重新竞争锁
mysql数据库锁关键字_mysql锁机制
weixin_35538148的博客
01-19 242
通常锁分为悲观锁和乐观锁，所谓悲观锁就是处处提防着其人操作，生怕别人和自己抢资源，所以一上来就加锁了；而乐观锁就是老是乐天派觉得没人会和自己抢资源，只要按照规则来就没事，是自己通过数据库设定一个数据库字段来模拟锁机制，是一个君子协议，乐观的认为大家都是君子都会遵守。悲观锁分读锁和写锁，无论是读锁还是写锁，都不影响查询，查询大家都可以执行而且获取到结果，两把锁的区别就是读锁可以共享锁可以同时多人持有...
synchronized关键字实现同步
拈花的专栏
04-16 4542
synchronized关键字的使用 Java语言提供了synchronized关键字，可以给方法或代码块进行加锁，从而实现同步。 synchronized关键字取的锁都是对象锁，而不是把代码块或方法当做锁。主要有以下几种场景： 同步化类的非静态方法，取的调用该方法的对象上的对象锁； 同步化类的静态方法，取的是类的Class对象上的对象锁； 同步化代码块，synchronized(obj...
关键字锁的一些概念
XLJavaHome的专栏
12-05 182
无锁->偏向锁-轻量级锁-重量级锁 随着竞争情况升级 锁可以升级但是不能降级 比如在单线程下StringBuffer 就是无锁 偏向锁：总是由单线程访问同步代码块，会在对象头和栈针的锁记录存储锁偏向的线程id JDK6、7默认启用 但是启动后几秒才激活 关闭延迟立即启用，启用加上 -xx: ？？=0 （字母太多懒得打字） 偏向锁： 优点：加锁和解锁不需要额外的开销，和执行非同步方法相比仅...
java对程序加锁关键字,java中关于锁的关键字
weixin_33158887的博客
03-13 665
java中关于锁的关键字有2个 ， synchronized 和volatile。synchronized 可以对方法和语句块进行修饰。从而实现同一时刻只有一个线程能够执行。volatile可以对变量进行修饰。保证线程在每次使用变量的时候，都会读取变量修改后的最的值。很多人都将volatile理解为和synchronized差不多的功能。然而，实际情况并不是这样。volatile只能保证从公共内存...
锁的概念和synchronized关键字
weixin_42065915的博客
12-06 117
锁 同步关键字 — 自旋锁: 为了不放弃cpu执行时间,循环使用cas技术对数据尝试更新,直至成功. — 悲观锁: 假定会发生并发冲突,同步所有数据的相关操作,从读数据就开始上锁. — 乐观锁: 假定没有冲突,在修改数据是如果发现数据和之前获取的不一致,则读取最新的数据,修改后重试修改. — 独享锁: 给资源加上写锁,线程可以修改资源,其他线程不能再加锁.(单写) — 共享...
Java线程锁synchronized关键字
楊帥
06-20 544
作用于代码块，锁为对象。 作用于静态函数，锁为静态函数所在的类。 作用于非静态函数，锁为该函数所在的对象。 谁先拿到锁，谁可暂时独享锁中逻辑。 1. 作用于方法 public class Test { public static void main(String[] args){ Test test = new Test(); new Thread(()...
验证synchronized加在方法上，锁住的对象类别。
qq_21364629的博客
08-06 1993
最近看偶然看了别人的面经问到了synchronized的相关问题，想起了以前看过的：synchronized加在方法上，锁住的是类实例，然后还记得有个锁住的是类的.class对象。 但那时候只是看了看，记忆并不深，现在突然看到，便想着自己写一份demo去验证一下，synchronized加载方法上时，究竟锁住了写什么，验证Demo如下： public class Lock { //验证sy...
Java中Synchronied的用法
weixin_44693635的博客
07-31 541
简单介绍 synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 　　1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 　　2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 　　3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 　　4. 修改一个类，其作用的范围是synchronized后面括号括起来的...
synchronized 关键字 锁 java
06-13
在synchronized关键字的实现中，当一个线程尝试获取锁对象时，如果该锁对象已经被其他线程获取，那么该线程就会进入等待队列中等待，直到该锁对象被释放为止。在Java 5之前，synchronized关键字的实现是基于操作系统...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值