synchronized的使用

实例1：

 

public   class  TestSync  implements  Runnable  ... {
  Timer timer = new Timer();
  public static void main(String[] args) ...{
    TestSync test = new TestSync();
    Thread t1 = new Thread(test);
    Thread t2 = new Thread(test);
    t1.setName("t1"); //设置线程的名字！
    t2.setName("t2");
    t1.start(); //线程开始运行
    t2.start();
    
  }
  public void run()...{
    timer.add(Thread.currentThread().getName());
  }
}

class  Timer ... {
  private static int num = 0;
  public synchronized void add(String name)...{ //synchronized锁定这个方法，线程只有使用完这个方法后，才能使用另一个方法。若不使用synchronized，则不同的线程可以同时使用这个方法。
      //synchronized (this) {
      for(int i=0;i<2;i++)...{
          num ++;  //对于这种多个实例，要想实现同步即输出的数字是有序并且按线程先后顺序输出，我们可以增加一个静态变量，对它进行加锁。
            try ...{
                Thread.sleep(1000);
            } 
            catch (InterruptedException e)
            ...{}
            System.out.println(name+", 你是第"+num+"个使用timer的线程");
      }
       
      //}
  }
}

 

实例2：

 

public   class  TT  implements  Runnable  ... {
    int b = 100;
    
    public synchronized void m1() throws Exception...{
        //Thread.sleep(2000);
        b = 1000;
        Thread.sleep(5000);
        System.out.println("b = " + b);
    }
    
    public synchronized void m2() throws Exception ...{
        Thread.sleep(2500);
        b = 2000;
    }
    
    public void run() ...{
        try ...{
            m1();
        } catch(Exception e) ...{
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) throws Exception ...{
        TT tt = new TT();
        Thread t = new Thread(tt);//创建第一个线程，
        t.start();//第一个线程开始运行
        
        tt.m2();//第二个线程开始运行
        System.out.println(tt.b);
    }
}

 

实例3：

 

public   class  TestDeadLock  implements  Runnable  ... {
    public int flag = 1;
    static Object o1 = new Object(), o2 = new Object();
    public void run() ...{
        System.out.println("flag=" + flag);
        if(flag == 1) ...{
            synchronized(o1) ...{
                try ...{
                    Thread.sleep(1000);
                    System.out.println("进入了flag=1中");
                } catch (Exception e) ...{
                    e.printStackTrace();
                }
                synchronized(o2) ...{
                    System.out.println("1");    
                }
            }
        }
        if(flag == 0) ...{
            synchronized(o2) ...{
                try ...{
                    Thread.sleep(500);
                    System.out.println("进入了flag=0中");
                } catch (Exception e) ...{
                    e.printStackTrace();
                }
                synchronized(o1) ...{
                    System.out.println("0");
                }
            }
        }
    }    
    
    public static void main(String[] args) ...{
        TestDeadLock td1 = new TestDeadLock();
        TestDeadLock td2 = new TestDeadLock();
        td1.flag = 1;
        td2.flag = 0;
        Thread t1 = new Thread(td1);
        Thread t2 = new Thread(td2);
        t1.start();
        t2.start();
        
    }
}