Synchronized

Synchronized

synchronized是java中的关键字，是一种同步锁。

使用方式：

1. 修饰一个代码块，被修饰的方法称为同步方法，其作用的范围是整个代码块，作用的对象是调用这个代码块的对象；
2. 修饰一个方法，被修饰的方法称为同步方法，起作用的范围是整个方法，作用的对象是调用这个方法的对象；
3. 修饰一个静态的方法，其作用的范围是整个静态方法，作用的对象是整个类的所有对象；
4. 修饰一个类，作用的范围是整个类，作用的对象是这个类所有的对象；

Synchronized修饰代码块

操作资源类:

package t0528.syncCodeBlock;

public class SyncThread implements Runnable{

    //共享资源
    private static int count;

    public SyncThread(){
        count =0;
    }

    @Override
    public void run() {
        synchronized (this){
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public int getCount(){
        return count;
    }
}

测试类：

package t0528.syncCodeBlock;


public class Test {
    public static void main(String[] args) {
        
        //方式1. 操作同一实例对象
        SyncThread thread = new SyncThread();
        Thread thread1 = new Thread(thread, "thread1");
        Thread thread2 = new Thread(thread, "thread2");
        thread1.start();
        thread2.start();


        //方式2. 创建两个新的SyncThread对象
//        Thread thread_2 = new Thread(new SyncThread(), "thread_2");
//        Thread thread_1 = new Thread(new SyncThread(), "thread_1");
//
//        thread_1.start();
//        thread_2.start();
    }

}

方式1返回结果：

thread1:0
thread1:1
thread1:2
thread1:3
thread1:4
thread2:5
thread2:6
thread2:7
thread2:8
thread2:9

方式2返回结果：

thread_1:0
thread_2:1
thread_2:2
thread_1:3
thread_2:4
thread_1:4
thread_1:5
thread_2:5
thread_1:6
thread_2:7

显然方式1返回的结果是保证了线程安全的，在thread1执行同步代码块中的代码时，thread2并没有执行，而是等待thread1执行完毕之后thread2才开始执行。方式二中，则是thread1和thread2一起同时执行了同步代码块，导致类变量count没有按照正常情况去递增。

前面讲了，sync修饰代码块，锁的是调用这个代码块的对象，然而方式二中，两个新的线程是分别创建了新的thread对象去执行的，因为synchronized只锁对象，每个对象只有一个锁（lock）与之相关联，每两把锁分别锁定thread1对象和thread2对象，而这两把锁是互不干扰的，不形成互斥，所以两个线程可以同时执行。

注：当一个线程访问对象的synchronized(this)同步代码块时，另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块，而不受到阻塞。

synchronized(Object obj)，括号中的值，可以是一个对象，表示对该对象加锁。当一个线程访问obj对象时，其他试图访问obj对象的线程将会阻塞，直到该线程访问obj对象结束。也就是说谁拿到那个锁谁就可以运行它所控制的那段代码。

Synchronized修饰方法

在某个方法前面加上synchronized，就是对该方法加锁。synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。

注：使用synchronized修饰方法，该关键字不能被继承。在定义接口方法时不能使用synchronized关键字。构造方法不能使用synchronized关键字，但可以使用synchronized代码块进行同步。

synchronized修饰静态方法

静态方法是属于这个类的，而不是属于对象的。所以synchronized修饰的静态方法锁定的是这个类的所有对象。

所以如果sync修饰一个静态方法，两个线程使用不同的thread对象去执行同步静态方法，也是会保持线程同步的。

synchronized修饰类

当synchronized作用于一个类时，是给这个类加锁，这个类的所有对象用的是同一把锁。

总结：

1. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。
2. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。

关于synchronized底层原理可以学习这篇文章：(https://blog.csdn.net/javazejian/article/details/72828483)

ReentrantLock和synchronized区别

类别	synchronized	Lock
存在层次	java关键字，在jvm层面上	类
锁的释放	1.以获取锁的线程执行完同步代码，释放锁；2. 线程执行发生异常，jvm会让线程释放锁	在finally中必须释放锁，不然容易造成死锁
锁获取	假设A线程获得锁，B线程等待，如果A线程阻塞，B线程也会一直等待	可以尝试获得锁，线程可以不用一直等待tryLock(long time, TimeUnit unit)
锁状态	无法判断	可以判断
锁类型	可重入、不可中断、非公平	可重入、可中断、可公平
性能	少量同步	大量同步