笔记————synchornized

最新推荐文章于 2024-03-03 21:02:09 发布
最新推荐文章于 2024-03-03 21:02:09 发布
阅读量540 收藏 1
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44730336/article/details/123547443
版权

synchornized关键字的几种用法如下：

1、作用在方法上，锁是当前实例对象

  • 不同线程对于同一个对象的锁具有互斥性

当A线程获取到锁之后，B线程只能等A线程释放锁之后才能获取

package com.piao.thread1;

public class test_sync_method {
    public static void main(String[] args) {
        sync_method method1 = new sync_method();
        Thread thread1 = new Thread(method1);
        Thread thread2 = new Thread(method1);
        thread1.start();
        thread2.start();
    }
}
class sync_method implements Runnable{
    public synchronized void f(){
        System.out.println("f() start by: "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            System.out.println("f() end by: "+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        f();

    }
}

输出：
f() start by: Thread-0
f() end by: Thread-0
f() start by: Thread-1
f() end by: Thread-1

上面这个例子中，因为两个线程是共用一把锁，因此线程2只能等线程1执行结束之后才能运行

  • 不同线程对于不同对象相当于异步

synchornized获得的是对象锁，如果有多个对象，jvm就会创建多个锁

package com.piao.thread1;


public class test_sync_method {
    public static void main(String[] args) {
        sync_method method1 = new sync_method();
        sync_method method2 = new sync_method();
        Thread thread1 = new Thread(method2);
        Thread thread2 = new Thread(method1);
        thread1.start();
        thread2.start();
    }
}
class sync_method implements Runnable{
    public synchronized void f(){
        System.out.println("f() start by: "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            System.out.println("f() end by: "+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        f();

    }
}

输出：
f() start by: Thread-0
f() start by: Thread-1
f() end by: Thread-1
f() end by: Thread-0

上面这个例子中，因为两个线程填入的实例不一样，表示两个线程的锁是不一样的，因此说明线程2不需要等线程1执行完毕，就可以执行该实例中的同名方法

  • 所有对象都自动含有单一的锁

当对象在调用其任意synchornized方法时，此对象都会被加锁，这时该对象上的其他synchornized方法只有等到前一个方法调用完毕并释放锁之后才能被调用。

package com.piao.thread1;


public class test_sync_method {
    public static void main(String[] args) {
        sync_method method1 = new sync_method();
        Thread thread1 = new Thread(method1);
        Thread thread2 = new Thread(method1);
        thread1.start();
        thread2.start();
    }
}
class sync_method implements Runnable{
    private static int count=1;
    public synchronized void f(){
        System.out.println("f() start by: "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            System.out.println("f() end by: "+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public synchronized void g(){
        System.out.println("g() start by: "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            System.out.println("g() end by: "+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
       if (count==1){
           count=2;
           f();
       }else{
           count=1;
           g();
       }

    }
}

输出：
f() start by: Thread-0
f() end by: Thread-0
g() start by: Thread-1
g() end by: Thread-1
  • 一个任务可以多次获得对象的锁

如果一个方法在同一个对象上调用第二个方法，后者又调用了同一个对象上的另一个方法，就会发生这种情况。jvm负责跟踪对象加锁的次数。如果一个对象被解锁（即完全释放锁），计数器就会变为0；在任务第一次给对象加锁时，计数器变为1.每当这个相同的任务在这个对象上获取锁时，计数器都会递增。显然只有首先获得锁的任务才能被允许继续加锁。每当任务离开一个synchornized方法，计数器递减，当计数器为0时，释放锁，此时，别的任务就可以获得此资源。

package com.piao.thread1;


public class test_sync_method {
    public static void main(String[] args) {
        sync_method method1 = new sync_method();
        Thread thread1 = new Thread(method1);
        Thread thread2 = new Thread(method1);
        thread1.start();
        thread2.start();
    }
}
class sync_method implements Runnable{
    private static int count=1;
    public synchronized void f(){
        System.out.println("f() start by: "+Thread.currentThread().getName());
        try {
            g();
            Thread.sleep(1000);
            System.out.println("f() end by: "+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public synchronized void g(){
        System.out.println("g() start by: "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            System.out.println("g() end by: "+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
       if (count==1){
           count=2;
           f();
       }else{
           count=1;
           g();
       }

    }
}

输出：
f() start by: Thread-0
g() start by: Thread-0
g() end by: Thread-0
f() end by: Thread-0
g() start by: Thread-1
g() end by: Thread-1
  • 同步不能继承
package com.piao.thread1;


public class test_sync_method {
    public static void main(String[] args) {
        sync_method method1 = new sync_method();
        sync_method method2 = new sync_method();
        sync_method1 sync_method1 = new sync_method1();
        Thread thread1 = new Thread(sync_method1);
        Thread thread2 = new Thread(sync_method1);
        thread1.start();
        thread2.start();
    }
}
class sync_method implements Runnable{
    private static int count=1;
    public synchronized void f(){
        System.out.println("f() start by: "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            System.out.println("f() end by: "+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public synchronized void g(){
        System.out.println("g() start by: "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            System.out.println("g() end by: "+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
       if (count==1){
           count=2;
           f();
       }else{
           count=1;
           g();
       }

    }
}
class sync_method1 extends sync_method{
    public void f(){
        System.out.println("s() start by: "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            System.out.println("s() end by: "+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        super.f();
    }

    @Override
    public void run() {
        f();
    }
}

输出：
s() start by: Thread-0
s() start by: Thread-1
s() end by: Thread-0
s() end by: Thread-1
f() start by: Thread-0
f() end by: Thread-0
f() start by: Thread-1
f() end by: Thread-1

不难发现，两个线程进入子类几乎是一起进入的。

  • 父类和子类是同一个锁
package com.piao.thread1;


public class test_sync_method {
    public static void main(String[] args) {
        sync_method1 sync_method1 = new sync_method1();
        Thread thread1 = new Thread(sync_method1);
        Thread thread2 = new Thread(sync_method1);
        thread1.start();
        thread2.start();
    }
}
class sync_method implements Runnable{
    private static int count=1;
    public synchronized void f(){
        System.out.println("f() start by: "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            System.out.println("f() end by: "+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public synchronized void g(){
        System.out.println("g() start by: "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            System.out.println("g() end by: "+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
       if (count==1){
           count=2;
           f();
       }else{
           count=1;
           g();
       }

    }
}
class sync_method1 extends sync_method{
    public synchronized void f(){
        System.out.println("s() start by: "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            System.out.println("s() end by: "+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        super.f();
    }

    @Override
    public void run() {
        f();
    }
}

输出：
s() start by: Thread-0
s() end by: Thread-0
f() start by: Thread-0
f() end by: Thread-0
s() start by: Thread-1
s() end by: Thread-1
f() start by: Thread-1
f() end by: Thread-1

可以发现，只有当一个线程释放锁之后。另一个线程才能获得资源

2、作用在方法块上，锁就是括号里的对象

  • 不同线程对于不同对象，相当于异步
package com.piao.thread1;


public class test_sync_method {
    public static void main(String[] args) {
        sync_method method1 = new sync_method();
        sync_method method = new sync_method();
        Thread thread1 = new Thread(method);
        Thread thread2 = new Thread(method1);
        thread1.start();
        thread2.start();
    }
}
class sync_method implements Runnable{
    private static int count=1;
    private  sync_method1 method1=new sync_method1();
    @Override
    public void run() {
       method1.f();

    }
}
class sync_method1{
    public void f(){
        synchronized (this){
            System.out.println("s() start by: "+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
                System.out.println("s() end by: "+Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


}

输出：
s() start by: Thread-0
s() start by: Thread-1
s() end by: Thread-0
s() end by: Thread-1
  • 当锁是类对象时
package com.piao.thread1;


public class test_sync_method {
    public static void main(String[] args) {
        sync_method method1 = new sync_method();
        sync_method method = new sync_method();
        Thread thread1 = new Thread(method);
        Thread thread2 = new Thread(method1);
        thread1.start();
        thread2.start();
    }
}
class sync_method implements Runnable{
    private static int count=1;
    private  sync_method1 method1=new sync_method1();
    @Override
    public void run() {
       method1.f();

    }
}
class sync_method1{
    public void f(){
        synchronized (sync_method1.class){
            System.out.println("s() start by: "+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
                System.out.println("s() end by: "+Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


}

s() start by: Thread-0
s() end by: Thread-0
s() start by: Thread-1
s() end by: Thread-1
骑驴那小子
关注
syncronized的实现原理
joy_pan的博客
11-11 919
相关概念 线程安全的主要诱因 存在共享数据（临界资源）。 多个线程共同操作共享数据。 解决问题的根本方法： 同一时刻只有一个线程操作共享数据，其他线程必须等待该线程操作完数据后再对共享资源进行操作。 互斥锁 特性 互斥性：同一时刻只有一个线程持有某个对象锁。也称操作原子性。 可见性：锁释放之前，对共享数据的修改，对于后一个获取该锁的线程是可见的。即后一个线程获取该锁时应获得共享数据的最新值。...
Java并发编程(四)——synchronized关键字实现加锁
程序员资料站
05-08 515
案例介绍 来看下面一段代码： public class Counter { private int count=0; public void add(){ count++; } public void des(){ count--; } public int get(){ return count; } public static void main(String[]
synchornized的使用
qq_41571459的博客
02-22 191
synchornized的使用场景 1、两个线程同时访问同一个对象的同步方法 安全 2、两个线程同时访问两个对象的同步方法 不安全 test1.func1() test2.func1() 3、两个线程同时访问(一个或两个)对象的静态同步方法 安全 4、两个线程分别同时访问(一个或两个)对象的同步方法和非同步方法 不安全 5、两个线程访问同一个对象中的同步方法，同步方法又调用另外一个非同步方法 不安全 6、两个线程同时访问同一个对象的不同的同步方法 安全 7、两个线程同时访问静态s
synchronized用法详解
最新发布
qq_43842093的博客
03-03 4655
synchronized 是 Java 中的关键字，是一种同步锁。主要应用于多线程环境下保证线程的安全性。A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
synchronized关键字
weixin_47285644的博客
02-25 107
1. synchronized的三种应用方式 Java中每一个对象都可以作为锁，这是synchronized实现同步的基础： 普通同步方法（实例方法），锁是当前实例对象 ，进入同步代码前要获得当前实例的锁 静态同步方法，锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁 同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。 ①多个线程访问同一个对象的同一个方法 public class SynchronizedTest implements Runnable
Synchornized使用及原理
qianwenhong
06-04 3206
同步，可见，synchornized，volatile
《Java并发编程的艺术》学习 ——synchornized
qq_33673359的博客
11-30 160
一、synchornized 的实现原理和应用 1.1 Java的对象头 在上面介绍的线程要访问同步方法、代码块的时候，那首先是要获取到锁。那锁到底是什么有存储在什么地方呢?这个和java对象的组成有关。java对象分成3块区域： 对象头 储存对象的运行时数据（Mark Word） 哈希码、锁的状态、持有的锁、GC分代年纪，对象分代年纪、偏向线程ID、偏向时间戳。Mark Word的结构不...
Java中的同步与互斥机制–synchornized学习
12-22
Java中的同步与互斥机制是多线程编程中至关重要的概念，主要用来解决并发访问共享资源时可能出现的数据不一致问题。`synchronized` 关键字是Java提供的一个内置锁机制，用于实现线程间的同步和互斥。...
性能优化——Synchronized同步锁的优化方法
qq_36589864的博客
08-20 685
在并发编程中，多个线程访问同一个共享资源时，我们必须考虑如何维护数据的原子性。在 JDK1.5 之前，Java 是依靠 Synchronized 关键字实现锁功能来做到这点的。 Synchronized 是 JVM 实现的一种内置锁，锁的获取和释放是由 JVM 隐式实现。 到了 JDK1.5 版本，并发包中新增了 Lock 接口来实现锁功能，它提供了与 Synchronized 关键字类似的同步功能，只是在使用时需要显示获取和释放锁。 Lock 同步锁是基于 Java 实现的，而 Syn..
Synchronized与锁升级——轻量级锁
小白的博客
08-28 908
轻量级锁是为了在线程近乎交替执行同步块时提高性能。 主要目的：在没有多线程竞争的前提下，通过CAS减少重量级锁使用操作系统互斥量产生的性能消耗．说白了先自旋，不行才升级阻寨。
Java多线程之Synchornized定义，底层实现原理，以及锁对象
weixin_45804960的博客
05-31 608
synchornized关键字 首先我们先了解一下什么是synchornized，及synchornized的作用 我们先看一个示例 ，假如两个线程同时都对n进行自加操作 package Synchornized; public class TestSynchornized1 { int n = 0; public void func(){ n++; } public static void main(String[] args) throws Interr
java:多线程同步synchornized
weixin_42346551的博客
06-15 368
1：该关键字修饰的方法为同步方法2：java中每个对象都有一个锁(lock)或者说是监视器(monitor),当访问某个对象的synchornized方法时，表示给该对象上锁，其他任何线程都无法再访问该对象的synchornized方法了，直到该方法执行完毕后或者抛出异常后其他线程方可访问public class ClientThread2 { /** * @param args */ pub...
synchronized 的简单总结
Du_ZiLin的博客
03-28 409
比如有一个Class MyClass MyClass A = new MyClass(); MyClass B = new MyClass(); 实例化了两个对象A和B 1.修饰方法，同步方法： MyClass类中有如下方法： private synchronized void say(){} 若多个线程中，某一个线程正在执行A.say()时，另一个线程也执行到了A.say(
Synchornized底层实现
阿甘的博客
03-26 270
start
java ReentrantLock与synchronized
小炫风技术旅行
05-04 510
synchronized 对象锁    当多个线程在更新共享状态时避免相互冲突，要保证数据的原子性与可见性,我们通常用synchronized上锁,，一个线程访问synchornied代码库或者方法时，其他线程都将暂时不能访问，知道上一个线程调用的这个synchronized执行完成,才能被另外线程调用，synchronized将自动释放锁,此后另外线程等待到这时才能执行    例1:并发线程...
高效并发：Synchornized的锁优化详解
qq_53578500的博客
07-30 624
高效并发是从JDK 5升级到JDK 6后一项重要的改进项，HotSpot虚拟机开发团队在这个版本上花费了大量的资源去实现各种锁优化技术，如适应性自旋（Adaptive Spinning）、锁消除（LockElimination）、锁膨胀（Lock Coarsening）、轻量级锁（Lightweight Locking）、偏向锁（BiasedLocking）等，这些技术都是为了在线程之间更高效地共享数据及解决竞争问题，从而提高程的执行效率......
synchronized的四种用法
诚的博客
05-07 9189
同步锁 synchronized顾名思义，就是用来进行一些同步工作的，我们常常在多线程的环境中使用到它，实现互斥的效果。 每一个java对象都可以当做一个同步锁，线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得锁的唯一途径就是进入这个锁的保护的同步代码块或方法。这里的同步代码块和同步方法，就是使用synchronized关键字标记的代码块和方法。比如： synchronized (object) { //doSomething... .
单例设计模式
热门推荐
qq_40077167的博客
02-27 1万+
代码 public class Single { private volatile Single single;//唯一实例 //私有化构造方法 private Single(){ if(single!=null){//防止通过反射实例化 throw new RuntimeException("实例已经存在,不能再实例化"); ...
synchoronize原理
疯一样的女子
11-13 923
并发编程中用到最多的关键字毫无疑问是synchronized。这篇文章就来探究下synchronized： synchronized如何使用？ synchronized是实现同步加锁的原理？ synchronized解决了并发编程的哪些问题？ 1. synchronized使用 1.1线程安全问题 并发编程中，当多个线程同时访问同一个资源的时候，就会存在线程安全问题。 由于每...
synchornized实现原理
05-25
Java 中的 `synchronized` 关键字可以用于实现多线程的同步，防止出现竞争条件（race condition）和响应过度（over-response）等问题。它的实现原理是通过对象监视器（monitor）实现的。 当一个线程执行到 `...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值