Java多线程-synchronized(非this对象)

Posted Alan Lau

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java多线程-synchronized(非this对象)相关的知识,希望对你有一定的参考价值。

3个结论

synchronized(非this对象 x) 是将 x 对象本身作为“对象监视器”,因此有如下三个结论:

1)当多个线程同时执行 synchronized(x){}同步代码块时呈同步效果

2)当其他线程执行 x 对象中 synchronized 同步方法时呈同步效果

3)当其他线程执行 x 对象方法里的 synchronized(this) 代码块时也呈现同步效果。

 

静态同步方法 与 synchronized(class)代码块

关键字 synchronized 还可以应用在 static 静态方法上,如果这样写,则是对当前“类对象”进行持锁

注意区别:

  synchronized 作用在非 static 方法上时,是“对象锁”,作用到 static 方法上时,是“Class锁”

示例:

public class SyncNotThis {
    public static void main(String[] args) {
        Service service = new Service();

        Thread t1 = new Thread(() -> {
            Service.printA();
        });
        Thread t2 = new Thread(() -> {
            Service.printB();
        });
        Thread t3 = new Thread(() -> {
            service.printC();
        });
        t1.start();
        t2.start();
        t3.start();
    }

    static class Service {
        /**
         * 静态方法 A
         */
        synchronized public static void printA() {
            try {
                System.out.println("线程名称为:" + Thread.currentThread().getName() + "开始执行 A 方法");
                Thread.sleep(1000);
                System.out.println("线程名称为:" + Thread.currentThread().getName() + "结束执行 A 方法");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        /**
         * 静态方法B
         */
        synchronized public static void printB() {
            try {
                System.out.println("线程名称为:" + Thread.currentThread().getName() + "开始执行 B 方法");
                Thread.sleep(1000);
                System.out.println("线程名称为:" + Thread.currentThread().getName() + "结束执行 B 方法");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        /**
         * 非静态方法C
         */
        synchronized public void printC() {
            try {
                System.out.println("线程名称为:" + Thread.currentThread().getName() + "开始执行 C 方法");
                Thread.sleep(500);
                System.out.println("线程名称为:" + Thread.currentThread().getName() + "结束执行 C 方法");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果如图:

 

 可以发现 方法 A、B的运行呈现同步效果,方法C与 A、B呈现异步效果,异步的原因是方法 C与 方法 A、B持有的是不同的锁

 

synchronized(String对象)的特殊情况

因为JVM中String常量池的存在,会导致 synchronized锁到同一对象

例:

public class SyncString {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            String aa = "AA";
            print(aa);
        });
        Thread t2 = new Thread(() -> {
            String aa = "AA";
            print(aa);
        });
        t1.start();
        t2.start();
    }

    public static void print(String stringParam) {
        synchronized (stringParam) {
            try {
                System.out.println(Thread.currentThread().getName() + "begin");
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName() + "end");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果如下:

 

 因为String 常量池导致了锁的是同一 String 对象,所以两个线程是同步执行的

 

锁对象的改变

示例:

public class LockChange {
    public static void main(String[] args) {
        MyService service = new MyService();
        MyThread t1 = new MyThread(service, "A");
        MyThread t2 = new MyThread(service, "B");
        t1.start();
        t2.start();
    }

    static class MyThread extends Thread {
        private MyService service;

        public MyThread(MyService service, String name) {
            super(name);
            this.service = service;
        }

        @Override
        public void run() {
            service.testMethod();
        }
    }

    static class MyService {
        private String lock = "123";
        public void testMethod() {
            try {
                synchronized (lock) {
                    System.out.println(Thread.currentThread().getName() + " begin " + System.currentTimeMillis());
                    lock = "456";
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getName() + " end " + System.currentTimeMillis());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果如下:

 

 分析:

线程A 和 线程 B持有的锁都是 “123”,虽然 lock 的引用从 "123" 变成了 "456",但是 A 和 B 争抢的锁还是 “123” ,所以尽管线程 A中间改变了 lock 的引用,但是结果还是同步的(或者换一种理解:synchronized 锁的是引用指向的对象,而非引用本身)

以上是关于Java多线程-synchronized(非this对象)的主要内容,如果未能解决你的问题,请参考以下文章

java多线程核心技术——synchronized同步方法与synchronized同步快

Java多线程synchronized

java多线程编程核心技术——第二章总结

多线程--synchronized同步语句块

Java多线程

Java多线程-同步:synchronized 和线程通信:生产者消费者模式