彻底理解synchronized(一)

---

一、synchronized关键字三大特性？

1.1 原子性

一个或多个操作要么全部执行成功，要么全部执行失败。synchronized关键字可以保证只有一个线程拿到锁，访问共享资源。

1.2 可见性

当一个线程对共享变量进行修改后，其他线程可以立刻看到。执行synchronized时，会对应执行 lock、unlock原子操作，保证可见性。

1.3 有序性

CPU为了优化我们的代码，会对我们程序进行重排序,执行synchronized时，程序的执行顺序会按照代码的先后顺序执行。

二 、synchronized关键字实现什么类型的锁？

2.1 悲观锁

synchronized实现的是悲观锁，每次访问共享资源时都会上锁。

2.2 非公平锁

synchronized关实现的是非公平锁，即线程获取锁的顺序并不一定是按照线程阻塞的顺序

2.3 可重入锁

synchronized关键字实现的是可重入锁，即已经获取锁的线程可以再次获取锁。

2.4 独占锁或者排他锁

synchronized关键字实现的是独占锁，即该锁只能被一个线程所持有，其他线程均被阻塞。

三、synchronized的使用场景

3.1 synchronized的使用场景介绍

在java代码中使用synchronized可是使用在代码块和方法中，根据Synchronized用的位置可以有这些使用场景

3.2 synchronized的使用场景入门

3.2.1 synchronized修饰实例方法

修饰实例方法，对当前实例对象this加锁，进入同步代码前要获得当前实例的锁，下面看一段代码，大家可以猜想下输出结果

public class SynchronizedDemo  implements  Runnable{

    //创建共享变量
    static  int i = 0;
    public static void main(String[] args) throws InterruptedException {
        SynchronizedDemo s1 = new SynchronizedDemo();
        Thread t1 = new Thread(s1);
        Thread t2 = new Thread(s1);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
    //synchronized修饰实例方法
    public  synchronized  void m1(){
        System.out.println("当前线程名称:"
               +Thread.currentThread()+",i="+i++);
    }
    @Override
    public void run() {
        for (int i = 0;i<1000;i++){
            m1();
        }
    }
}

根据下图结果，结果输出了1999。
原因是因为我们创建了一个实例对象s1，并且对实例对象s1中的m1方法使用synchronized关键字进行修饰。通俗的说，当一个线程正在访问一个对象的 synchronized 实例方法，那么其他线程不能访问该对象的其他 synchronized 方法，毕竟一个对象只有一把锁，当一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，所以无法访问该对象的的其他synchronized实例方法。

举个粒子:当你家只有一个厕所，你正在上厕所(就如你获得了一把synchronized对象锁)，此时其他人是无法占用厕所的(获得锁的)。只有等你上完厕所，其他人才能进去上厕所。

3.2.2 synchronized修饰实例方法变形

大家可以再看看这段代码，猜一猜它的运行结果

public class SynchronizedDemo  implements  Runnable{

    //创建共享变量
    static  int i = 0;
    public static void main(String[] args) throws InterruptedException {
        SynchronizedDemo s1 = new SynchronizedDemo();
        //新建一个对象s2
        SynchronizedDemo s2 = new SynchronizedDemo();
        Thread t1 = new Thread(s1);
        Thread t2 = new Thread(s2);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
    //synchronized修饰实例方法
    public  synchronized  void m1(){
        System.out.println("当前线程名称:"
        +Thread.currentThread()+",i="+i++);
    }
    @Override
    public void run() {
        for (int i = 0;i<1000;i++){
            m1();
        }
    }
}

结果为1998

第二个示例中的m1()方法虽然也使用synchronized关键字修饰了，但是因为两次new SynchronizedDemo()操作建立的是两个不同的对象，也就是说存在两个不同的对象锁，线程t1和t2使用的是不同的对象锁，所以不能保证线程安全。

举个粒子:当你家有两个厕所，你正在上其中一个厕所(就如你获得了一把synchronized对象锁)，此时其他人还是可以上另一个厕所的(获得另一把对象锁),而不需要等你上完才能上。

3.2.3 synchronized修饰静态方法

针对1.2.2的情况应该如何解决呢？因为每次创建的实例对象都是不同的，而类对象却只有一个，如果synchronized关键字作用于类对象，即用synchronized修饰静态方法，问题则迎刃而解。

public class SynchronizedDemo  implements  Runnable{

    //创建共享变量
    static  int i = 0;
    public static void main(String[] args) throws InterruptedException {
        SynchronizedDemo s1 = new SynchronizedDemo();
        //新建一个对象s2
        SynchronizedDemo s2 = new SynchronizedDemo();
        Thread t1 = new Thread(s1);
        Thread t2 = new Thread(s2);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
    //synchronized修饰实例方法
    public    synchronized  void m1(){
        System.out.println("当前线程名称:"
        +Thread.currentThread()+",i="+i++);
    }
    //ynchronized修饰静态方法
    public  static   synchronized  void m2(){
        System.out.println("当前线程static:"
        +Thread.currentThread()+",i="+i++);
    }

    @Override
    public void run() {
        for (int i = 0;i<1000;i++){
            m2();
        }
    }
}

结果为1999

synchronized 修饰静态方法就是 synchronized 和 static 关键字一起使用，当synchronized作用于静态方法，锁就是当前的class对象。因此可以通过 class 对象控制并发访问。

举个粒子:当你家有两个厕所，但是其中一个被人用锁锁住了并且钥匙丢了，你正在上其中一个厕所(就如你获得了一把synchronized对象锁)，此时其他人还是只能等你这个厕所，只有你上完了(释放锁)，其他人才能上。

3.2.4 synchronized修饰同步代码块

在某些情况下，整个方法体比较大，需要同步的代码只是一小部分，如果直接对整个方法体进行同步，会使得代码性能变差，这时只需要对一小部分代码进行同步即可。

public class SynchronizedDemo  implements  Runnable{

    //创建共享变量
    static  int i = 0;
    public static void main(String[] args) throws InterruptedException {
        SynchronizedDemo s1 = new SynchronizedDemo();
        //新建一个对象s2
        SynchronizedDemo s2 = new SynchronizedDemo();
        Thread t1 = new Thread(s1);
        Thread t2 = new Thread(s2);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
    //synchronized修饰实例方法
    public    synchronized  void m1(){
        System.out.println("当前线程名称:"
        +Thread.currentThread()+",i="+i++);
    }
    //synchronized修饰静态方法
    public  static   synchronized  void m2(){
        System.out.println("当前线程名称static:"
        +Thread.currentThread()+",i="+i++);
    }
    //synchronized  this表示当前对象实例，
    //这里还可以使用SynchronizedDemo.class，表示class对象锁
    public    void m3(){
        synchronized (this){
            System.out.println("当前线程名称，锁代码块:"
            +Thread.currentThread()+",i="+i++);
        }
    }

    @Override
    public void run() {
        for (int i = 0;i<1000;i++){
//            m1();
//            m2();
            m3();
        }
    }
}

输出结果 1999

上面代码中将 this （当前对象实例）作为锁对象对其加锁，每次当线程进入 synchronized 修饰的代码块时就会要求当前线程持有obj 实例对象锁，如果当前有其他线程正持有该对象锁，那么新到的线程就必须等待。
synchronized 修饰的代码块，除了可以锁定对象之外，也可以对当前实例对象锁、class 对象锁进行锁定。

码字不易，如果你觉得我写的还行，请收藏文章并且给我点个赞呗，你的支持是我的最大动力