Java synchronized 方法解析

Java synchronized 方法解析

参考https://www.cnblogs.com/hapjin/p/4678773.htmlhttps://www.cnblogs.com/hapjin/p/4678773.html

package test01;

class MethodSync {

    /*
     * @Task : 测试 synchronized 修饰方法时锁定的是调用该方法的对象
     * @param name  线程的标记名称
     */
    public synchronized void method(String name){
        System.out.println(name + " Start a sync method");
        try{
            Thread.sleep(300);
        }catch(InterruptedException e){}
        System.out.println(name + " End the sync method");
    }
}

public class Main implements Runnable{
    private String name;

    private MethodSync methodSync = new MethodSync();//不同实例,达不到互斥运行的效果
//    private static MethodSync methodSync = new MethodSync();//同一个实例,可以达到互斥运行的效果

    public Main(String name){
        this.name = name;
    }

    @Override
    public void run() {
        methodSync.method(name);
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new Main("test 1"));
        Thread t2 = new Thread(new Main("test 2"));
        t1.start();
        t2.start();
    }
}

输出:

test 1 Start a sync method
test 2 Start a sync method
test 1 End the sync method
test 2 End the sync method

可以看出method方法并没有同步进行,同步进行就是一个线程的method方法在执行时,另一个线程method方法不能执行,不会出现交叉执行的状况

将这一行注释取消// private static MethodSync methodSync = new MethodSync();//同一个实例,可以达到互斥运行的效果

注释掉private MethodSync methodSync = new MethodSync();//不同实例,达不到互斥运行的效果

package test01;

class MethodSync {

    /*
     * @Task : 测试 synchronized 修饰方法时锁定的是调用该方法的对象
     * @param name  线程的标记名称
     */
    public synchronized void method(String name){
        System.out.println(name + " Start a sync method");
        try{
            Thread.sleep(300);
        }catch(InterruptedException e){}
        System.out.println(name + " End the sync method");
    }
}

public class Main implements Runnable{
    private String name;

//    private MethodSync methodSync = new MethodSync();//不同实例,达不到互斥运行的效果
    private static MethodSync methodSync = new MethodSync();//同一个实例,可以达到互斥运行的效果

    public Main(String name){
        this.name = name;
    }

    @Override
    public void run() {
        methodSync.method(name);
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new Main("test 1"));
        Thread t2 = new Thread(new Main("test 2"));
        t1.start();
        t2.start();
    }
}

输出:

test 1 Start a sync method
test 1 End the sync method
test 2 Start a sync method
test 2 End the sync method

此时实现了method方法同步执行,static修饰的成员变量是所有该类创建的对象共享的,即new Main("test 1")和new Main("test 2")俩对象共享同一个methodSync实例,由此可知,在同一个实例中运行synchronized方法,可以实现该方法互斥运行

根据上面原理,更改代码,仍可以实现method()互斥运行

package test01;

class MethodSync {
    
    public synchronized void method() {
        System.out.println(Thread.currentThread().getName() + " Start a sync method");
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
        }
        System.out.println(Thread.currentThread().getName() + " End the sync method");
    }
}

public class Main implements Runnable {
    private String name;

    private MethodSync methodSync = new MethodSync();//此时仍可以达到互斥效果
//    private static MethodSync methodSync = new MethodSync();


    @Override
    public void run() {
        methodSync.method();
    }

    public static void main(String[] args) {
        Main main = new Main();//这里只有一个Main实例,所以也只有一个main.methodSync,不管有没有static修饰methodSync
        Thread t1 = new Thread(main, "thread1");
        Thread t2 = new Thread(main, "thread2");
        t1.start();
        t2.start();
    }
}

输出:

thread1 Start a sync method
thread1 End the sync method
thread2 Start a sync method
thread2 End the sync method