目录
1.最常见的是synchronized 修饰代码块，并指定锁对象。
2.当 synchronized 修饰实例方法时，锁对象是当前实例（this）
3.当 synchronized 修饰静态方法时，锁对象是当前类的 Class类对象。对于一个类来说，只有一个唯一的calss类对象。
上节课的时候我们讨论了多线程安全问题，讲到了关键字——synchronized,我们讲了其中的一种synchronized的使用方法，这节课我们先来学习它的其他用法
synchronized的使用方法
1.最常见的是synchronized 修饰代码块，并指定锁对象。
package thread;
import java.util.Vector;
class Counter {
public int count = 0;
public void add() {
count++;
}
}
public class Demo16 {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 50000; i++) {
synchronized (counter) {
counter.add();
}
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 50000; i++) {
synchronized (counter) {
counter.add();
}
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("counter=" + counter.count);
}
}
2.当 synchronized 修饰实例方法时，锁对象是当前实例（this）
public class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}//该代码约等于如下代码
public void increment() {
synchronized（this）{
count++;
}
}
public int getCount() {
return count;
}
}
多个线程调用同一个
Counter实例的increment()方法时，同一时间只有一个线程能够执行该方法。锁对象是当前实例（
this）。
3.当 synchronized 修饰静态方法时，锁对象是当前类的 Class类对象。对于一个类来说，只有一个唯一的calss类对象。
public class Counter {
private int count = 0;
public static synchronized void increment() {
count++;
}//该代码约等于如下代码
public static void increment() {
synchronized（Counter.class）{
count++;
}
}
public int getCount() {
return count;
}
}synchronized 的特性
互斥性
synchronized确保同一时间只有一个线程能够执行被保护的代码块或方法。其他线程必须等待当前线程释放锁后才能获取锁并执行代码。
锁的可重入性
static class Counter { public int count = 0; synchronized void increase() { count++; } synchronized void increase2() { increase(); } }如果用该代码，按照之前对于锁的设定, 第二次加锁的时候, 该线程就会阻塞等待. 直到第一次的锁被释放, 才能获取到第二个锁. 但是释放第一个锁也是由该线程来完成, 结果这个线程已经堵塞了, 也就无法进行解锁操作. 这时候就会 死锁.
这样的锁称为 不可重入锁.
那么可重入锁就是
• 一个对象可以多次在同一个线程内连续加锁，而不会导致死锁。
• 在同一个线程连续加锁时，每次加锁，锁的计数器加 1；每次释放锁时，计数器减 1。只有当计数器为 0 时，锁才会被完全释放。
死锁的情况
虽然在synchronized中连续加锁不会出现死锁，但还有其他很多情况会出现死锁，
比如嵌套锁导致的死锁
package thread;
public class Demo17 {
private static Object locker1 = new Object();
private static Object locker2 = new Object();
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
synchronized (locker1) {
System.out.println("t1 加锁 locker1 完成");
// 这里的 sleep 是为了确保, t1 和 t2 都先分别拿到 locker1 和 locker2 然后在分别拿对方的锁.
// 如果没有 sleep 执行顺序就不可控, 可能出现某个线程一口气拿到两把锁, 另一个线程还没执行呢, 无法构造出死锁.
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
synchronized (locker2) {
System.out.println("t1 加锁 locker2 完成");
}
}
});
Thread t2 = new Thread(() -> {
synchronized (locker1) {
System.out.println("t2 加锁 locker1 完成");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
synchronized (locker2) {
System.out.println("t2 加锁 locker2 完成");
}
}
});
t1.start();
t2.start();
}
}
运行这段代码后，程序会陷入死锁
死锁原因
线程1 先获取了
lock1，然后试图获取lock2。线程2 先获取了
lock2，然后试图获取lock1。此时，线程1和线程2都在等待对方释放锁，但它们又都持有对方需要的锁，导致死锁。
如何避免死锁
经典案例：哲学家吃面条问题；
避免死锁问题只需要打破上述四点的其中一点即可，对于第一点和第二点对于Java中是打破不了的，他们都是synchronized的基本特性
从第三点来看，不要让锁嵌套获取即可（但是有的时候必须嵌套，那就破除循环等待）
第四点破除循环等待：约定好加锁的顺序，让所有的线程都按照约定要的顺序来获取锁。
避免死锁问题只需要打破上述四点的其中一点即可，对于第一点和第二点对于Java中是打破不了的，他们都是synchronized的基本特性
从第三点来看，不要让锁嵌套获取即可（但是有的时候必须嵌套，那就破除循环等待）
第四点破除循环等待：约定好加锁的顺序，让所有的线程都按照约定要的顺序来获取锁。
这个时候5号哲学家要拿1号筷子，但是一号筷子被1号哲学家拿着，所以5号哲学家只能等着，等1号哲学家用完。这样就不会有死锁了