1.?synchronized的介绍
synchronized属于Java关键字，属于JVM层次，特别说明它不是一个类，也不是一个接口
2. synchronized修饰代码块
synchronized修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象。
2.1同步代码块中的锁对象是字符串常量
import java.util.Date;
public class Demo {
String s1 = "hello";
String s2 = "hello";
void m1(){
synchronized (s1){
System.out.println("线程"+Thread.currentThread().getName()+"开始运行时间："+new Date());
try{
Thread.sleep(3000);
}catch (Exception e){
}
System.out.println("线程"+Thread.currentThread().getName()+"结束运行时间："+new Date());
}
}
void m2(){
synchronized (s2){
System.out.println("线程"+Thread.currentThread().getName()+"开始运行时间："+new Date());
try{
Thread.sleep(3000);
}catch (Exception e){
}
System.out.println("线程"+Thread.currentThread().getName()+"结束运行时间："+new Date());
}
}
public static void main(String[] args){
Demo demo = new Demo();
System.out.println(demo.s1.equals(demo.s2));
System.out.println(demo.s1==demo.s2);
Thread t1=new Thread(()->{demo.m1();},"t1");
Thread t2=new Thread(()->{demo.m2();},"t2");
t1.start();
t2.start();
}
}
执行上述代码，其输出结果为：
true
true
线程t1开始运行时间：Tue Mar 22 11:07:08 CST 2022
线程t1结束运行时间：Tue Mar 22 11:07:11 CST 2022
线程t2开始运行时间：Tue Mar 22 11:07:11 CST 2022
线程t2结束运行时间：Tue Mar 22 11:07:14 CST 2022
上述s1变量和s2变量指向的是同一下引用地址，因此线程t1和t2在获取锁的时候获取的是同一把锁，两个线程的执行顺序是同步执行。另外当s1和s2变量指向的不是同一个引用地址的时候（共三种情况），如下所示：?
// 第一种情况：
String s1 = new String("hello");
String s2 = "hello";
// 第二种情况：
String s1 = "hello";
String s2 = new String("hello");
// 第三种情况：
String s1 = new String("hello");
String s2 = new String("hello");
再次运行上述代码，其输出结果如下，可以看到此时t1和t2两个线程的执行顺序不是同步执行，而是异步执行：?
true
false
线程t1开始运行时间：Tue Mar 22 11:19:02 CST 2022
线程t2开始运行时间：Tue Mar 22 11:19:02 CST 2022
线程t2结束运行时间：Tue Mar 22 11:19:05 CST 2022
线程t1结束运行时间：Tue Mar 22 11:19:05 CST 2022
特别提示：不要以字符串常量作为锁定对象，在下面的例子中，m1和m2其实锁定的是同一个对象，这种情况下会发生比较诡异的现象，比如你用到了一个类库，在该类库中代码锁定了字符串“hello“，但是你读不到源码，所以你也在代码中锁定了“hello”，这时候就有可能发生特别诡异的死锁阻塞，因为你的程序和引用类库不经意间使用到了同一把锁。
3.使用Synchronized实现死锁
死锁形成的原理就是线程A需要线程B所占用的锁来执行程序，而线程B同时也需要线程A锁占用的锁来执行程序，这就导致了两个线程无休止的等待，等待对方释放占用的锁。?
public class DeadLock {
public static void main(String[] args) {
A a = new A();
B b = new B();
new Thread(() -> a.m1(b), "t1").start();
new Thread(() -> b.m1(a), "t2").start();
}
}
class A {
public synchronized void m1(B b) {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
b.print();
}
public synchronized void print() {
System.out.println("执行A的打印方法");
}
}
class B {
public synchronized void m1(A a) {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
a.print();
}
public synchronized void print() {
System.out.println("执行B的打印方法");
}
}
?执行上述代码，可以看到两个线程在输出下述内容后，一直处于阻塞状态：
t2
t1
可见线程1和线程2都在等待对方释放锁，而自己需要等待对方释放锁之后才释放自己的锁，这就导致了死锁的产生。?
可以参考：
https://blog.csdn.net/qq_41410799/article/details/102928313
|