synchronized关键字

最新推荐文章于 2025-03-23 22:41:36 发布
最新推荐文章于 2025-03-23 22:41:36 发布
阅读量158 收藏
点赞数
分类专栏： javase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/baidu_32691373/article/details/79658106
版权

synchronized关键字

标签： 多线程

欢迎 star

目的

保证指定某类的的方法或方法块或者该类只能同时被一个类对象调用.

synchronized的基本规则

规则一

当一个线程访问 某对象 的 synchronized 方法或者代码块时,其他线程对该 该对象的 synchronize 方法或则语句块 的访问会被 阻塞.

demo1 多个线程访问同一对象的synchronized方法

//此时出现同步锁现象.
package cn.kkcoder.thread;

/**
 * Created by static-mkk on 21/3/2018.
 *
 */
public class ThreadTest_one_runnable {

    public static void main(String[] args) {

        MyRunnable myRunnable = new MyRunnable();

        Thread t1 = new Thread(myRunnable,"t1");
        Thread t2 = new Thread(myRunnable,"t2");

        t1.start();
        t2.start();

    }
}

class MyRunnable implements Runnable{


    @Override
    public void run() {
        synchronized (this){
            try {
                for (int i=0;i<=10;i++){
                    Thread.currentThread().sleep(100);
                    System.out.print(Thread.currentThread().getName() + " : " + i + "     ");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
控制台：
t1 : 0     t1 : 1     t1 : 2     t1 : 3     t1 : 4     t1 : 5     t1 : 6     t1 : 7     t1 : 8     t1 : 9     t1 : 10     t2 : 0     t2 : 1     t2 : 2     t2 : 3     t2 : 4     t2 : 5     t2 : 6     t2 : 7     t2 : 8     t2 : 9     t2 : 10

demo2 多个线程访问不同对象的synchronized方法

//此时<不会>出现同步锁现象
package cn.kkcoder.thread;
/**
 * Created by static-mkk on 21/3/2018.
 *
 *  当一个线程获取某对象的 synchronized 方法或代码块 ，其他线程再来访问是，其他线程会出现堵塞状态.
 *
 */
public class ThreadTest_one {

    public static void main(String[] args) {

        Thread t1 = new ThreadOne("t1");
        Thread t2 = new ThreadOne("t2");

        t1.start();
        t2.start();

    }

}

class  ThreadOne extends Thread{

    public ThreadOne(String name){
        super(name);
    }


    @Override
    public void run() {

        synchronized(this) {
            try {

                for (int i = 0; i <= 5; i++) {
                    Thread.sleep(100);
                    System.out.print(Thread.currentThread().getName() + " ： " + i + "   ");

                }
            }catch (InterruptedException e){

            }

        }
    }
}
控制台：
t2 ： 0   t1 ： 0   t1 ： 1   t2 ： 1   t2 ： 2   t1 ： 2   t2 ： 3   t1 ： 3   t1 ： 4   t2 ： 4   t2 ： 5   t1 ： 5

规则二

当一个线程访问某synchronized方法或则语句块，其他线程可以访问该对象的非synchronized方法或代码块

demo3

package cn.kkcoder.thread;
/**
 * 
 * @author static-mkk
 *<br/>
 *  一个线程访问某对象的synchronized的方法或语句块时，其他线程可以访问该对象的非同步方法.
 *  
 */
public class ThreadTwo {

    public static void main(String[] args) {
        ThreadNoAndHaveSynchronized a = new ThreadNoAndHaveSynchronized();

        Thread t1 = new Thread(()->{a.haveSynchronized();});
        Thread t2 = new Thread(()-> {a.noSynchronized();});

        t1.start();
        t2.start();
    }

}

/**
 * 
 * @author static-mkk
 *<br/>
 * 测试类
 */
class ThreadNoAndHaveSynchronized {

/**
 *   同步的方法
 */
    public void haveSynchronized () {
        synchronized(this) {
            for(int i=0;i<=5;i++) {
                try {
                    Thread.currentThread().sleep(100);
                } catch (InterruptedException e) {
                    new RuntimeException("sleep 失败.");
                }
                System.out.println("我是 1 de : "+ " 的 i = " + i);
            }
        }
    }

    /**
     *  非同步的方法
     */
    public void noSynchronized() {
        for(int i=0;i<=5;i++) {
            try {
                Thread.currentThread().sleep(100);
            } catch (InterruptedException e) {
                new RuntimeException("sleep 失败.");
            }
            System.out.println("我是 2 de : "+  " 的 i = " + i);
        }
    }

}
控制台：
我是 1 de :  的 i = 0
我是 2 de :  的 i = 0
我是 1 de :  的 i = 1
我是 2 de :  的 i = 1
我是 1 de :  的 i = 2
我是 2 de :  的 i = 2
我是 1 de :  的 i = 3
我是 2 de :  的 i = 3
我是 1 de :  的 i = 4
我是 2 de :  的 i = 4
我是 1 de :  的 i = 5
我是 2 de :  的 i = 5

规则三

当一个线程已经访问某对象的 synchronized方法或方法块，其他线程则无法获取该对象的 其他synchronized 方法或方法块.

package cn.kkcoder.thread;
/**
 * 
 * @author static-mkk
 * 
 * @time 2018-3-22
 * <br/>
 *  当一个线程已经获取某对象的同步锁，其他线程不能获取该对象的其他同步锁修饰的方法或者语句块.
 */
public class ThreadThree {

    public static void main(String[] args) {

        TwoSynchronizedMethod syn = new TwoSynchronizedMethod();

        Thread t1 = new Thread( ()-> {syn.synchronizedOne();} );
        Thread t2 = new Thread( ()-> {syn.synchronizedTwo();} );

        t1.start();
        t2.start();

    }

}

class TwoSynchronizedMethod{

    /**同步方法 一*/
    synchronized void synchronizedOne(){

        for(int i=0;i<=5;i++) {
            try {
                Thread.currentThread().sleep(100);
                System.out.println( "我是 one and i = " + i );
            } catch (Exception e) {
                new RuntimeException("one sleep fail");
            }
        }
    }
    /**同步方法 二*/
    synchronized void synchronizedTwo(){
        for(int i=0;i<=5;i++) {
            try {
                Thread.currentThread().sleep(100);
                System.out.println( "我是 two and i = " + i );
            } catch (Exception e) {
                new RuntimeException("two sleep fail");
            }
        }
    }
}
控制台：
我是 one and i = 0
我是 one and i = 1
我是 one and i = 2
我是 one and i = 3
我是 one and i = 4
我是 one and i = 5
我是 two and i = 0
我是 two and i = 1
我是 two and i = 2
我是 two and i = 3
我是 two and i = 4
我是 two and i = 5

实例锁 与 全局锁

实例锁: 把锁加在实例对象上的锁. 就是在，类的非静态方法，非静态语句块 的其他 的普通方法 或 普通语句块 上加锁.

全局锁： 针对类的安全锁. synchronized 关键字在 class或clossloder上，或者 静态方法 静态语句块.

demos

同一个线程 访问 同一个对象的 不同同步锁.

package cn.kkcoder.thread;

public class AllWhitOme {

    public static void main(String[] args) {

        TestClass a = new TestClass();
        TestClass b = new TestClass();

        Thread t1 = new Thread(() -> {a.s1();} );
        Thread t2 = new Thread(() -> {a.s2();});
        t1.start();
        t2.start();


    }

}

/**同步测试类*/
class TestClass{

    /**实例锁 方法 s1*/
    synchronized void s1() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s1 i = " + i );
            }
        }catch (Exception e) {
        }
    }

    /**实例锁 方法 s2*/
    synchronized void s2() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s2 i = " + i );
            }
        }catch (Exception e) {
        }
    }

    /**全局锁 方法 s3*/
    static synchronized void s3() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s3 i = " + i );
            }
        }catch (Exception e) {
        }
    }

    /**全局锁 方法 s4*/
    static synchronized void s4() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s4 i = " + i );
            }
        }catch (Exception e) {
        }
    }


}
控制台：
我是 s1 i = 1
我是 s1 i = 2
我是 s2 i = 1
我是 s2 i = 2

当同步锁释放后才能继续访问.

不同线程 访问 不同对象 的同一个 实例锁

package cn.kkcoder.thread;

public class AllWhitOme {

    public static void main(String[] args) {

        TestClass a = new TestClass();
        TestClass b = new TestClass();

        Thread t3 = new Thread(() -> {a.s1();});
        Thread t4 = new Thread(() -> {b.s1();});
        t3.start();
        t4.start();
    }

}

/**同步测试类*/
class TestClass{

    /**实例锁 方法 s1*/
    synchronized void s1() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s1 i = " + i );
            }
        }catch (Exception e) {
        }
    }

    /**实例锁 方法 s2*/
    synchronized void s2() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s2 i = " + i );
            }
        }catch (Exception e) {
        }
    }

    /**全局锁 方法 s3*/
    static synchronized void s3() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s3 i = " + i );
            }
        }catch (Exception e) {
        }
    }

    /**全局锁 方法 s4*/
    static synchronized void s4() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s4 i = " + i );
            }
        }catch (Exception e) {
        }
    }
}
控制台：
我是 s1 i = 1
我是 s1 i = 1
我是 s1 i = 2
我是 s1 i = 2

会 同时访问.

不同线程 访问不同对象 的 全局锁

package cn.kkcoder.thread;

public class AllWhitOme {

    public static void main(String[] args) {

        TestClass a = new TestClass();
        TestClass b = new TestClass();
        Thread t5 = new Thread(() -> {a.s1();});
        Thread t6 = new Thread(() -> {b.s2();});
        t5.start();
        t6.start();
    }

}

/**同步测试类*/
class TestClass{

    /**实例锁 方法 s1*/
    synchronized void s1() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s1 i = " + i );
            }
        }catch (Exception e) {
        }
    }

    /**实例锁 方法 s2*/
    synchronized void s2() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s2 i = " + i );
            }
        }catch (Exception e) {
        }
    }

    /**全局锁 方法 s3*/
    static synchronized void s3() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s3 i = " + i );
            }
        }catch (Exception e) {
        }
    }

    /**全局锁 方法 s4*/
    static synchronized void s4() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s4 i = " + i );
            }
        }catch (Exception e) {
        }
    }
}
控制台：
我是 s3 i = 1
我是 s3 i = 2
我是 s4 i = 1
我是 s4 i = 2

不能同时访问

不同线程 同时访问 不同对象的 实例锁 和 全局锁

package cn.kkcoder.thread;

public class AllWhitOme {

    public static void main(String[] args) {

        TestClass a = new TestClass();
        TestClass b = new TestClass();
        Thread t7 = new Thread(() -> {a.s1();});
        Thread t8 = new Thread(() -> {b.s3();});
        t7.start();
        t8.start();
    }

}

/**同步测试类*/
class TestClass{

    /**实例锁 方法 s1*/
    synchronized void s1() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s1 i = " + i );
            }
        }catch (Exception e) {
        }
    }

    /**实例锁 方法 s2*/
    synchronized void s2() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s2 i = " + i );
            }
        }catch (Exception e) {
        }
    }

    /**全局锁 方法 s3*/
    static synchronized void s3() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s3 i = " + i );
            }
        }catch (Exception e) {
        }
    }

    /**全局锁 方法 s4*/
    static synchronized void s4() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s4 i = " + i );
            }
        }catch (Exception e) {
        }
    }
}
控制台：
我是 s1 i = 1
我是 s3 i = 1
我是 s1 i = 2
我是 s3 i = 2

可以同时访问

不同线程 同时访问 不同对象的 全局锁

package cn.kkcoder.thread;

public class AllWhitOme {

    public static void main(String[] args) {

        TestClass a = new TestClass();
        TestClass b = new TestClass();

        Thread t9 = new Thread(() -> {a.s3();});
        Thread t0 = new Thread(() -> {b.s4();});
        t9.start();
        t0.start();

    }

}

/**同步测试类*/
class TestClass{

    /**实例锁 方法 s1*/
    synchronized void s1() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s1 i = " + i );
            }
        }catch (Exception e) {
        }
    }

    /**实例锁 方法 s2*/
    synchronized void s2() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s2 i = " + i );
            }
        }catch (Exception e) {
        }
    }

    /**全局锁 方法 s3*/
    static synchronized void s3() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s3 i = " + i );
            }
        }catch (Exception e) {
        }
    }

    /**全局锁 方法 s4*/
    static synchronized void s4() {
        try {
            for(int i=1;i<3;i++) {
                Thread.currentThread().sleep(100);
                System.out.println("我是 s4 i = " + i );
            }
        }catch (Exception e) {
        }
    }
}
控制台：
我是 s3 i = 1
我是 s3 i = 2
我是 s4 i = 1
我是 s4 i = 2

不能同时访问.

synchronized 关键字的底层实现解析
一碗黄焖鸡三碗米饭的博客
04-08 952
是 Java 中最基础的同步机制，能够保证多线程环境下的线程安全。它通过对象的监视器锁来实现线程互斥，通过对象头和 Mark Word 来记录锁的信息。随着 JVM 版本的迭代，锁的实现机制也得到了优化，包括偏向锁、轻量级锁和重量级锁的升级和降级。特性锁Lock锁锁粒度方法/代码块级别更加灵活，可以精细控制锁死锁检测无法检测tryLock()可以避免死锁性能优化自动优化需要手动控制锁获取/释放方式自动获取释放锁手动获取和释放锁尽管Lock提供了更细粒度的控制，但。
Java并发编程(四)—synchronized关键字的应用
echola_mendes的博客
08-05 1725
synchronized 关键字是 Java 中用来确保线程安全的基本机制，特别是在需要保证多个变量之间的一致性时。通过使用 synchronized，可以锁定一个对象，从而确保同一时刻只有一个线程可以访问该对象可以将 synchronized 用于方法级别和代码块级别，要注意锁定的对象应该是一个合适的对象，不能是一个常量，使用 synchronized 可以简化并发控制逻辑，但需要注意其性能开销和潜在的死锁风险。
synchronized关键字详解
努力分享一些干货
07-13 814
Java内存模型规定了所有的变量都存储在主内存中，每条线程还有自己的工作内存，线程的工作内存中保存了该线程中是用到的变量的主内存副本拷贝，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存。也就是说，仅仅是发生在STW的时候，只有垃圾回收线程能够观测到它，在我们正常使用的过程中是不会发生锁降级的，只有在GC的时候才会降级。修饰的代码，在开始执行时会加锁，执行完成后会进行解锁。所以，在JDK1.6中出现对锁进行了很多的优化，进而出现轻量级锁，偏向锁，锁消除，适应性自旋锁，锁粗化。
synchronized 关键字详解
最新发布
weixin_41140099的博客
03-23 783
是 Java 并发编程的基石，通过内置锁机制保障原子性、可见性和有序性。其锁升级优化（偏向锁 → 轻量级锁 → 重量级锁）在多数场景下平衡了性能与安全性。是 Java 中实现线程同步的。
Java 中的 synchronized 关键字详解
云扬的博客
11-27 1405
在 Java 中，`synchronized` 关键字是一个非常重要的同步机制，用于确保在多线程环境下，同一时刻只有一个线程可以执行某个方法或代码块。本文将详细介绍 `synchronized` 关键字的三种应用方式、其作用以及注意事项。
synchronized关键字详解（全面分析）
落日的博客
07-11 1575
synchronized 直译为 同步，它的作用是实现线程同步， synchronized 能够确保同一时刻只有一个线程可以执行某个代码块或方法，我们可以把共享变量的修改放在synchronized 修饰的代码块中或者方法中，从而避免多个线程同时访问共享资源时引发的线程安全问题。①、synchronized关键字用在代码块上，锁是synchonized括号里配置的对象，可以实现类级别的同步(使用类的Class对象作为锁，或者使用静态实例变量作为锁)。也可以实现对象级别的同步(使用类的实例变量作为锁)。
synchronized关键字的使用
qq_44286009的博客
05-21 524
synchronized 是 Java 中的一个关键字，用于实现多线程之间的同步访问。它用于确保在多线程环境中，同一时间只有一个线程可以执行某个方法或代码块。这是通过锁定一个对象或类来实现的，以防止多个线程同时访问共享资源，从而导致数据不一致或其他并发问题。在方法声明中使用synchronized，将其放在范围操作符（如public）后，返回类型声明（如void）之前。这样，当一个线程进入该方法时，其他线程将被阻塞，直到该线程退出该方法。例如：// 方法体。
synchronized 关键字用法
梁靓凉的博客
03-10 898
synchronized 关键字最主要的三种使用方式： 1.修饰实例⽅法: 作⽤于当前对象实例加锁，进⼊同步代码前要获得当前对象实例的锁。 synchronized void method() { //业务代码 } 2.修饰静态⽅法: 也就是给当前类加锁，会作⽤于类的所有对象实例 ，进⼊同步代码前要获得当 前 class 的锁。因为静态成员不属于任何⼀个实例对象，是类成员（ static 表明这是该类的⼀个 静态资源，不管 new 了多少个对象，只有⼀份）。所以，如果⼀个线程 A 调⽤⼀个实例对象的 ⾮
Synchronized关键字详解
H_xxxxd的博客
04-06 5236
文章目录一、Synchronized的使用1.1对象锁1.2类锁二、Synchronized原理分析2.1加锁和释放锁的原理 引入背景 线程安全是并发编程中的重要关注点，应该注意到的是，造成线程安全问题的主要诱因有两点 一是存在共享数据(也称临界资源) 二是存在多条线程共同操作共享数据。 因此为了解决这个问题，我们可能需要这样一个方案，当存在多个线程操作共享数据时，需要保证同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再进行，这种方式有个高尚的名称叫互斥锁，即能达到互斥访
Synchronized 关键字原理
qxf865618770的博客
04-20 951
Synchronized关键字解决的是多个线程之间访问资源的同步性， synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。使用Java的小伙伴都知道synchronized关键字是解决并发问题常用解决方案，常用的有以下三种使用方式： 修饰代码块，即同步语句块，其作用的范围是大括号{}括起来的代码， 作用的...
深入理解Java中的synchronized关键字
weixin_74268571的博客
06-15 1641
synchronized的详细讲解和底层实现，以及synchronized的同步机制，synchronized的重入和synchronized的异常演示
git_shell简单使用
伍马
03-21 5863
Git shell 基本操作 标签： Gitshell 简单了解一下 首先看一下图. 1.Remote : 远程仓库.就是github主页上显示的仓库. 2.Repository : 本地仓库.先把文件放到本地仓库，再可以放到远程仓库. 3.workspace : 工作区.就是本地的文件夹.(.git文件夹同级目录的地方，就是工作区.) 下面开始具体的提交文件到...
java_Logger简单使用
伍马
04-01 3800
java原生Logger使用 标签： java demo package cn.kkcoder.demos; import java.io.File; import java.io.IOException; import java.util.logging.ConsoleHandler; import java.util.logging.FileHandler; import ...
java8源码详解--BufferInputStream_BufferOutputStream
伍马
03-18 1593
BufferInputStream_BufferOutputStream 标签： java8源码 欢迎 star 思路 主要是从输入或输出流中一次读取 8192(默认) 个字节加载到内存中，用作缓存. 目的 提高数据输入或输出的速度. BufferInputStream详解 BufferInputStream 类签名 public cl...
java8源码详解--ByteArrayOutputStream详解
伍马
03-13 1079
ByteArrayOutputStream详解 标签： java8源码 欢迎star 思路： 通过ByteArrayOutputStream 的内部 成员变量 byte buf[];来储存数据. 最大值 MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8 目的： 向ByteArrayOutputStream 流中输出数据. ...
java8源码详解--ByteArrayInputStream详解
伍马
03-13 1047
ByteArrayInputStream详解 标签： java8源码 欢迎star 思路 ByteArrayInputStream 必须在构造函数中传入byte[]，用于初始化其内部成员变量 byte[] buf，然后利用其 read() 方法，把该流里的数据(buf)输出到指定数组中. 目的 从该ByteArrayInputStream流中获取数据....
线程等待与唤醒
伍马
03-23 910
线程等待与唤醒 标签： 多线程 基本方法简介 所有的等待和唤醒线程，都是针对某个具体对象实例的. API接口 说明 wait() 让当前线程进入等待（阻塞）状态，直到其他线程调用此对象的notify()或notifyAll()来唤醒，之后该线程进入就绪状态. wait(long timeout) 让当前线程进入阻塞状态，直到其他线程唤...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值