目录
synchronized的特性
互斥性
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();
}
}
由结果我们可以知道，线程一释放锁后，由操作系统唤醒线程二才能获取到锁。
synchronized的底层是使用操作系统的mutex lock实现的。
可见性
内存可见性是指当一个线程修改了共享变量的值后，其他线程能够立即看到修改的值。在多线程环境中，由于多个线程同时访问共享变量，每个线程都有自己的工作内存，而工作内存中保存了主内存中的部分数据副本。因此，当一个线程修改了共享变量的值，但这个修改尚未被刷新到主内存时，其他线程可能无法立即看到这个修改，而继续使用自己工作内存中的旧值，造成了内存不可见性。
synchronized 既能保证原子性，也能保证内存可见性，一个线程对共享变量的修改对于其他线程是可见的。
class Counter {
public static int flag = 0;
}
public class test3 {
public static void main(String[] args) {
Object object = new Object();
Thread t1 = new Thread(() -> {
while (true) {
synchronized (object) {
if (Counter.flag != 0) {
break;
}
}
}
System.out.println("线程一知道了共享变量改为" + Counter.flag);
});
Thread t2 = new Thread(() -> {
Scanner scanner = new Scanner(System.in);
System.out.println("输入一个整数:");
Counter.flag = scanner.nextInt();
});
t1.start();
t2.start();
}
}
如果线程一不加synchronized，那么共享变量的改变它就感知不到，以至于程序一直在运行中。
可重入性
synchronized 同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题。
可以理解为一个线程没有释放锁，然后又尝试再次加锁。
按照之前对锁的理解就是，锁没有释放，进行再次加锁就会进行阻塞，直到第一次的锁被释放，才能获取到第二个锁，但释放第一个锁也由该线程来进行，结果现在这个线程啥都干不了，也就只能形成死锁了。
这样的锁称其为不可重入锁。
我们的synchronized是可重入锁。
在重入锁的内部有两个信息，分别为“程序计数器”和“线程持有者”
- 如果某个线程加锁的时候，发现锁已经被人占用，但是恰好占用的正是自己， 那么仍然可以继续获取到锁，并让计数器自增。
- 解锁的时候计数器递减为 0 的时候，才真正释放锁。
synchronized的使用方法
- 直接修饰普通方法: 锁的 SynchronizedDemo 对象
public synchronized void methond() {
}
- 修饰静态方法: 锁的 SynchronizedDemo 类的对象
public synchronized static void method() {
}
- 修饰代码块: 明确指定锁哪个对象
- 锁当前对象
public void method() {
synchronized (this) {
}
}
- 锁类对象
public void method() {
synchronized (SynchronizedDemo.class) {
}
}
synchronized的锁机制
-
对象锁：可以将synchronized关键字直接应用于实例方法或实例代码块上。当一个线程进入被synchronized修饰的实例方法或实例代码块时，它会自动获取该对象的内置锁。只有当线程释放锁之后，其他线程才能进入同步块。
-
类锁：可以将synchronized关键字应用于静态方法或类代码块上。当一个线程进入被synchronized修饰的静态方法或类代码块时，它会自动获取该类的Class对象的内置锁。类锁是属于整个类的，对于同一个类的不同实例，他们共享同一个类锁。
-
锁对象：可以使用synchronized关键字加锁指定的对象。通过指定一个对象作为锁，多个线程可以根据这个对象来实现同步。当一个线程进入synchronized代码块时，它会尝试获取指定对象的内置锁，只有当线程释放锁之后，其他线程才能获得锁并执行同步代码。
常见锁策略
乐观锁与悲观锁
悲观锁是在数据被使用前加锁，防止数据被其他线程修改。
乐观锁则是在更新数据时检查数据是否被其他线程修改过，如果没有则更新成功，否则返回失败。
Synchronized 初始使用乐观锁策略，当发现锁竞争比较频繁的时候, 就会自动切换成悲观锁策略。
重量级锁与轻量级锁
轻量级锁是一种优化的锁，它在CAS操作时使用CPU的自旋机制，如果自旋成功则获取到锁，否则进入睡眠状态。
重量级锁是一种传统的锁，它依赖于操作系统的MutexLock(互斥锁)来实现，当有多个线程竞争同一个锁时，会阻塞其他线程等待释放。
公平锁与非公平锁
假设有A，B，C三个线程依次进行同一把锁的获取，线程A获取成功了，线程B与C获取失败。
等待线程A释放锁后，线程B与C，如何获取锁
公平锁策略： 遵守 “先来后到”。B 比 C 先来的。当 A 释放锁的之后，B 就能先于 C 获取到锁。
非公平锁策略：不遵守 “先来后到”。B 和 C 都有可能获取到锁。
synchronized 是非公平锁
可重入锁与不可重入锁
可重入锁的意思就是允许同一个线程多次获取同一把锁。
Java里只要以Reentrant开头命名的锁都是可重入锁，而且JDK提供的所有现成的Lock实现类，包括synchronized关键字锁都是可重入的。
可以理解为一个线程没有释放锁，然后又尝试再次加锁。
按照之前对锁的理解就是，锁没有释放，进行再次加锁就会进行阻塞，直到第一次的锁被释放，才能获取到第二个锁，但释放第一个锁也由该线程来进行，结果现在这个线程啥都干不了，也就只能形成死锁了。
这样的锁称其为不可重入锁。
synchronized 是可重入锁
自旋锁
为防止线程在抢锁失败后进入阻塞状态，经过很久才能再次被调度的情况。
while (!locked.compareAndSet(false, true)) {
// 不断循环直到获取到锁
}
如果获取锁失败，立即再尝试获取锁， 无限循环，直到获取到锁为止。 第一次获取锁失败, 第二次的尝试会在极短的时间内到来。
缺点：如果锁被其他线程持有的时间比较久， 那么就会持续的消耗 CPU 资源。
synchronized 中的轻量级锁策略大概率就是通过自旋锁的方式实现的
读写锁
一个线程对于数据的访问, 主要存在两种操作: 读数据 和 写数据.
-
两个线程都只是读一个数据, 此时并没有线程安全问题. 直接并发的读取即可.
-
两个线程都要写一个数据, 有线程安全问题.
-
一个线程读另外一个线程写, 也有线程安全问题.
读写锁就是把读操作和写操作区分对待。 Java 标准库提供了ReentrantReadWriteLock 类，实现了读写锁。
-
ReentrantReadWriteLock.ReadLock 类表示一个读锁。这个对象提供了 lock / unlock 方法进行加锁解锁。
-
ReentrantReadWriteLock.WriteLock 类表示一个写锁。 这个对象也提供了 lock / unlock 方法进行加锁解锁
读加锁和读加锁之间, 不互斥.
写加锁和写加锁之间, 互斥.
读加锁和写加锁之间, 互斥
Synchronized 不是读写锁
