JavaNote 2.8synchronized-优快云博客

本文链接：https://blog.youkuaiyun.com/LetsStudy/article/details/80021385

本文详细介绍了Java中的synchronized锁机制，包括其四种使用方式：修饰代码块、方法、静态方法及类。并通过具体实例展示了不同情况下锁的行为表现，如线程间的等待与执行情况等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、synchronized是Java中是一种同步锁。
1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；

4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

二、测试实例

1、修饰代码块时，没有被修饰的代码，可以执行吗？

例

public class Test27 {
    public static void main(String args[]){
        Thread thread = new Thread(new Test26(),"线程1");
        thread.start();
        Thread thread1 = new Thread(new Test26(),"线程2");
        thread1.start();
    }
}

public class Test26 implements Runnable {
    int a = 1;

    public void f() {
        synchronized (this) {
            try {
                Thread.sleep(5000);
            } catch (Exception e) {
                e.getMessage();
            }
            switch (a) {
                case 1:
                    System.out.println("执行了被synchronized修饰的代码块" + Thread.currentThread().getName());
                    break;
            }
        }
        try {
            Thread.sleep(3000);
        } catch (Exception e) {
            e.getMessage();
        }
        System.out.println("没有执行被synchronized修饰的代码块" + Thread.currentThread().getName());
    }

    @Override
    public void run() {
        this.f();
    }
}
结果：没有被synchronized修饰的代码，不会被锁。

2、两个线程同时执行被修饰的代码块，另一个线程的状态？

例

public class Test27 {
    public static void main(String args[]){
        Thread thread = new Thread(new Test26(),"线程1");
        thread.start();
        Thread thread1 = new Thread(new Test26(),"线程2");
        thread1.start();
        System.out.println(thread1.getState());
        System.out.println(thread.getState());
    }
}

public class Test26 implements Runnable {
    int a = 1;

    public synchronized void f() {

        try {
            Thread.sleep(6000);
        } catch (Exception e) {
            e.getMessage();
        }
        switch (a) {
            case 1:
                System.out.println("执行了被synchronized修饰的代码块" + Thread.currentThread().getName());
                break;
        }
    }
    @Override
    public void run() {
        this.f();
    }
}
结果：当一个线程处于RUNNABLE状态时，另一个线程则会TIMED_WAITING状态

3、修饰静态方法时，非静态方法是否能正常执行？

例

public class Test27 {
    public static void main(String args[]){
        Thread thread = new Thread(new Test26(),"线程1");
        thread.start();
//        Thread thread1 = new Thread(new Test26(),"线程2");
//        thread1.start();
        System.out.println(thread.getState());
        try {
            Thread.sleep(1000);
            System.out.println("准备执行没有被synchronized的方法");
        }
        catch (Exception e){
            e.getMessage();
        }
        Test26 test26 = new Test26();
        test26.f();
    }
}

public class Test26 implements Runnable {
    int a = 1;

    public  void f() {
        switch (a) {
            case 1:
                System.out.println( "我是f方法"+Thread.currentThread().getName());
                break;
        }
    }
    public synchronized static void f1(){

        System.out.println("我是静态方法"+Thread.currentThread().getName());
        try {
            Thread.sleep(10000);
        } catch (Exception e) {
            e.getMessage();
        }
        System.out.println("静态方法执行完成");
    }
    @Override
    public void run() {
        this.f1();
       // this.f();
    }
}
结果：对静态方法上锁，不影响非静态方法的执行。
注：Thread.holdLock(Test26.class),对类上锁与修饰静态方法结果相同。