synchronized总结

1.synchronized的特性

1.1 互斥性

synchronized确保同一时间只有一个线程可以进入同步块或同步方法，避免了多线程并发访问共享资源的冲突问题。
synchronized 会起到互斥效果，某个线程执行到某个对象的 synchronized 中时， 其他线程如果也执行到同一个对象 synchronized 就会阻塞等待。
下面我们来看一个例子，两个线程获取同一个锁，锁被占用后，剩下的那个线程就会进行阻塞等待。

public class test2 {
    public static void main(String[] args) {
        Object object = new Object();
        Thread t1 =  new Thread(()->{
        //进入 synchronized 修饰的代码块, 相当于 加锁
          synchronized (object) {
              for (int i = 0; i < 5; i++) {
                  System.out.println("线程t1获取锁");
                  try {
                      Thread.sleep(1000);
                  } catch (InterruptedException e) {
                      throw new RuntimeException(e);
                  }
              }
          }
        //退出 synchronized 修饰的代码块, 相当于 解锁  
        });
        Thread t2 = new Thread(()->{
            synchronized (object) {
                for (int i = 0; i < 5; i++) {
                    System.out.println("线程特t2获取锁");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        t1.start();
        t2.start();
    }
}

由结果我们可以知道，线程一释放锁后，由操作系统唤醒线程二才能获取到锁。

1.2 可见性

什么是可见性？内存可见性（ Memory Visibility ）是指当某个线程正在使用对象状态而另一个线程在同时修改该状态，需要确保当一个线程修改了对象状态后，其他线程能够看到发生的状态变化。

synchronized 既能保证原子性，也能保证内存可见性，一个线程对共享变量的修改对于其他线程是可见的。

1.3 原子性 有序性

原子性：代码块在被一个线程执行时，其他线程不能进入该代码块。 

有序性：在一个线程中，代码块的执行是有序的。

1.4 可重入性

我们的synchronized是可重入锁。
在重入锁的内部有两个信息，分别为“程序计数器”和“线程持有者”

• 如果某个线程加锁的时候，发现锁已经被人占用，但是恰好占用的正是自己， 那么仍然可以继续获取到锁，并让计数器自增。
• 解锁的时候计数器递减为 0 的时候，才真正释放锁。

2.synchronized的使用

加锁解锁本身就是操作系统提供的api，很多编程语言都是对于这样的api进行封装了，大多数的封装风格都是采取两个函数。在java中使用synchronized这样的关键字搭配代码块来实现效果。

 

加锁代码的实现：

public class Demo1 {
    public static int count;
    public static void main(String[] args) throws InterruptedException {

        Object object = new Object();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                synchronized (object) {
                    synchronized (object) {
                        count++;
                    }
                }
            }
            System.out.println("t1线程结束");
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                synchronized (object) {
                    count++;
                }
        }
            System.out.println("t2线程结束");
       });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);

        }

    }

 关于加锁我们需要注意的是：

1.两个线程针对同一个对象加锁才能产生互斥效果（一个线程加锁之后另一个线程就得阻塞等待，等待第一个线程释放锁才有机会），如果是不同的对象，此时不会产生互斥效果，线程安全问题没有得到改变。

2.线程安全问题不是你写了synchronized就可以，而是要正确的使用锁。synchronized（）代码块要合适，synchronized（）指定锁对象也得合适。。

3.synchronized的锁机制

 无锁 -> 偏向锁 -> 自旋锁(轻量级锁) -> 重量级锁

        概括 : 刚开始加锁是偏向锁状态,遇到了锁竞争,就变成自旋锁,竞争愈演愈烈(七八个争一个锁)直接变成重量级锁(交给内核阻塞等待)

偏向锁 ：
        先让线程对这个锁相当于打个标记(做标记非常快,切非常轻量) ，如果代码执行过程中都没有遇到其他线程与我争夺这个锁,此时就不需要加锁了，一旦遇到了别的线程来竞争这个锁,这个偏向锁立马升级成轻量级锁（自旋锁）,别的线程只能等待(jvm会通知先到的线程,让他把锁进行升级一下，既可以保证效率,也可以保证线程安全

重量级锁：
        自旋锁虽然可以在第一时间拿到锁,但是消耗大量的cpu资源,如果七八个自选,会大量占用cpu的资源,所以会转化成重量级锁,在内核进行阻塞等待