如题

1. public class Piao implements Runnable {
   
2.     boolean flag;
   
3.     int piao=100;
   
4. public void run(){
   
5.   if(flag){
   
6.    synchronized(this){
   
7.     tt();
   
8.    }
   
9.   }else{
   
10.    tt();
    
11.   }
    
12.    }
    
13. synchronized void tt(){
    
14.   while(piao>0)
    
15.    System.out.println(Thread.currentThread().getName()+"-------"+piao--);
    
16. }
    
17. }
    
18. class Demo2{
    
19. public static void main(String[] args) {
    
20.   Piao p=new Piao();
    
21.   Thread t=new Thread(p);
    
22.   p.flag=true;
    
23.   t.start();
    
24. }
    
25. }

复制代码

简单谈谈我的理解，因为楼主新建的只有一个线程，如果是多个线程，
当一个线程访问当前类的一个synhronized(this)同步代码块时，其他线程对当前类中所有其它synchronized(this)同步代码块的访问将被阻塞，
加锁的时候确实this默认的这个锁
所以当前情况下只会阻塞，阻塞完成的话还是会执行的，但是如果是死循环的话，那么可能就彻底死锁了

为什么会死锁 你都没上锁,你只是同步代码了
在同步代码中可以使用锁对象的wait()方法让当前线程等待
使用锁对象的notify()方法可以将正在等待的线程唤醒
如果多个线程都在等待，notify()唤醒随机1个
notifyAll()方法可以唤醒所有在等待的线程

当运行线程A需要线程B解锁,而运行B要需要A解锁时,就是死锁

synchronized void tt(){

  while(piao>0)

   System.out.println(Thread.currentThread().getName()+"-------"+piao--);

同步函数默认使用的锁就是this,而你同步代码块的锁也是this,

同步函数和同步代码块的锁一样都是this,当然不会死锁;

如果想要死锁,可以把同步代码块中的锁改掉,只要不是this就可以;

当一个线程访问当前类的一个synhronized(this)同步代码块时，其他线程对当前类中所有其它synchronized(this)同步代码块的访问将被阻塞，
加锁的时候确实this默认的这个锁

死锁条件是：两个锁都想要对方的资源，但却又互不谦让才会出现死锁。
代码体现是

1. if(flag)
   
2. {
   
3.         synchronized(锁1)
   
4.         {
   
5.                 synchronized(锁2)
   
6.                 {}
   
7.         }
   
8. }else
   
9. {
   
10.         synchronized(锁2)
    
11.         {
    
12.                 synchronized(锁1)
    
13.                 {}
    
14.         }
    
15. }

复制代码

以上代码块，当有两个以上的线程来访问它所在的函数之类的时候，就会死锁

首先你开启的是单线程、其实这就没必要加锁。
出现死锁的情况：
死锁的四个必要条件

互斥条件（Mutual exclusion）：资源不能被共享，只能由一个进程使用。
请求与保持条件（Hold and wait）：已经得到资源的进程可以再次申请新的资源。
非剥夺条件（No pre-emption）：已经分配的资源不能从相应的进程中被强制地剥夺。
循环等待条件（Circular wait）：系统中若干进程组成环路，改环路中每个进程都在等待相邻进程正占用的资源。