synchronized(this) 与 synchronized(class) 理解

1.概念

锁机制有如下两种特性：

• 互斥性：即在同一时间只允许一个线程持有某个对象锁，通过这种特性来实现多线程中的协调机制，这样在同一时间只有一个线程对需同步的代码块(复合操作)进行访问。互斥性我们也往往称为操作的原子性。
• 可见性：必须确保在锁被释放之前，对共享变量所做的修改，对于随后获得该锁的另一个线程是可见的（即在获得锁时应获得最新共享变量的值），否则另一个线程可能是在本地缓存的某个副本上继续操作从而引起不一致。

2.对象锁和类锁

• 对象锁

  在 Java 中，每个对象都会有一个 monitor 对象，这个对象其实就是 Java 对象的锁，通常会被称为“内置锁”或“对象锁”。类的对象可以有多个，所以每个对象有其独立的对象锁，互不干扰。

• 类锁

  在 Java 中，针对每个类也有一个锁，可以称为“类锁”，类锁实际上是通过对象锁实现的，即类的 Class 对象锁。每个类只有一个 Class 对象，所以每个类只有一个类锁。

3.synchronized 的用法

• 获取对象锁

//修饰非静态方法
synchronized(this|object){
}

• 获取类锁

//修饰静态方法，非静态方法
synchronized(类.class){}

4.synchronized 的作用

public class ThreadTest {
    publicvoid test3() {
        synchronized (this) {
            try {
                System.out.println(Thread.currentThread().getName() + " test3 进入");
                Thread.sleep(3000);
                System.out.println(Thread.currentThread().getName() + " test3 退出");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    publicstaticvoid test4() {
        synchronized (this) {
            try {
                System.out.println(Thread.currentThread().getName() + " test4 进入");
                Thread.sleep(3000);
                System.out.println(Thread.currentThread().getName() + " test4 退出");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Test {
    static volatile LinkedList<String> list = new LinkedList<>();

    public static void main(String[] args) throws SQLException {
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(15, 20, 2000, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());

        final ThreadTest threadTest = new ThreadTest();
        for (int i = 0; i < 5; i++)
            poolExecutor.execute(
                    new Runnable() {
                        @Override
                        public void run() {
                            threadTest.test3();
                        }
                    });

        for (int i = 0; i < 5; i++)
            poolExecutor.execute(
                    new Runnable() {
                        @Override
                        public void run() {
                            threadTest.test4();
                        }
                    });
    }
}

pool-1-thread-1 test3 进入
pool-1-thread-1 test3 退出
pool-1-thread-10 test4 进入
pool-1-thread-10 test4 退出
pool-1-thread-9 test4 进入
pool-1-thread-9 test4 退出
pool-1-thread-8 test4 进入
pool-1-thread-8 test4 退出
pool-1-thread-7 test4 进入
pool-1-thread-7 test4 退出
pool-1-thread-6 test4 进入
pool-1-thread-6 test4 退出
pool-1-thread-5 test3 进入
pool-1-thread-5 test3 退出
pool-1-thread-4 test3 进入
pool-1-thread-4 test3 退出
pool-1-thread-2 test3 进入
pool-1-thread-2 test3 退出
pool-1-thread-3 test3 进入
pool-1-thread-3 test3 退出

当执行test3()方法时，synchronized (this)获取到了此对象的锁，test4()方法就必须等待test3()方法释放对象锁才能进入，在同一时刻只能有一个线程进入同一对象中需要对象锁的方法中。

注意：下面这两个效果是一样的，synchronized修饰方法默认获取的也是对象锁

public synchronized void test3(){
...
}

public void test2() {
    synchronized (ThreadTest.class) {
          ...
    }
}

同理可验证类锁，在同一时刻只能有一个线程进入类中需要类锁的方法中。

因为对象锁和类锁是两个不同的锁，所以同一个类中的需要类锁和需要对象锁的方法之间是互不影响的。

原文地址：https://www.cnblogs.com/Alpharun/p/9402392.html