1. synchronized的作用

锁住代码块，保证同一段代码在某一时刻只能有一个线程执行，该线程执行完毕后，其他线程再执行。目的是防止多线程并发操作导致的异常。

例如：当前有个变量count=0，线程A和线程B同时执行如下代码：

if (count == 0){
	count = count + 10;
}

存在这种情况，A执行了if (count == 0) 符合条件，此时B也执行了if语句同样符合条件，然后两个线程都执行 count = count + 10 。最终count=20

2. synchronized几种使用方式

• 锁住普通对象：锁的实例是对象，不同线程lock同一个对象需要互相等待，lock不同对象则不影响

• 锁住静态对象：由于是静态对象，所以对象永远是同一个，多个线程操作一定会互相等待

• 锁住普通方法：效果等同于锁住普通对象，举个例子说明

    public synchronized void lockMethod() {
    	//此处等待3秒，如果被锁住了，则其他线程的等待时间是叠加的
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "：" + new Date());
    }
    
    public static void main(String[] args) {
    	//用同一个对象操作
        SynchronizedTest obj = new SynchronizedTest();
        new Thread(() -> {
            obj.lockMethod();
        }, "Thread-1").start();

        new Thread(() -> {
            obj.lockMethod();
        }, "Thread-2").start();
    }

输出结果如下，时间是叠加的，说明synchronized起效果：

Thread-1：Sat Feb 06 10:10:13 CST 2021
Thread-2：Sat Feb 06 10:10:16 CST 2021

main 方法改一下，调用不同对象的方法：

    public static void main(String[] args) {
        new Thread(() -> {
            new SynchronizedTest().lockMethod();
        }, "Thread-1").start();

        new Thread(() -> {
            new SynchronizedTest().lockMethod();
        }, "Thread-2").start();
    }

输出结果如下，两个时间基本一致，说明synchronized并没有互相阻塞，因为lock的不同对象：

Thread-2：Sat Feb 06 10:11:38 CST 2021
Thread-1：Sat Feb 06 10:11:38 CST 2021

• 锁住静态方法：效果等同于锁住静态变量，也等同于锁住当前类的class

    public synchronized static void lockStaticMethod() {
    	//此处同样等待3秒
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "：" + new Date());
    }
    
    public static void main(String[] args) {
        new Thread(() -> {
            SynchronizedTest.lockStaticMethod();
        }, "Thread-1").start();

        new Thread(() -> {
            SynchronizedTest.lockStaticMethod();
        }, "Thread-2").start();
    }

输出结果如下：

Thread-1：Sat Feb 06 10:14:01 CST 2021
Thread-2：Sat Feb 06 10:14:04 CST 2021

还有另一种写法，锁住class，效果也是一样的：

    public void lockClass() {
        synchronized (SynchronizedTest.class){
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "：" + new Date());
        }
    }
    
    public static void main(String[] args) {
        new Thread(() -> {
            new SynchronizedTest().lockClass();
        }, "Thread-1").start();

        new Thread(() -> {
            new SynchronizedTest().lockClass();
        }, "Thread-2").start();
    }

标签：10,SynchronizedTest,Java,进阶,synchronized,Thread,锁住,线程,new
来源： https://blog.csdn.net/qq_28834355/article/details/113705918