多线程----同步和死锁

同步的例子----以卖火车票为例

       所谓同步就是指多个操作在同一个时间段只能有一个线程运行，其他线程必须等这个线程完成后才能继续执行。

      代码块分为四种：普通代码快，构造代码块，静态代码块，同步代码块。今天的实例就涉及到同步代码块，所谓“同步代码块”就是使用“synchronized”关键字声明的代码块

        同步代码块的格式：

 

                             synchronized（同步对象）{

                                       需要同步的代码

                       }

 

 

class MyThread implements Runnable {
   private int ticket =15; // 假定有20张票需要在不同地方同步售出

  @Override
   public void run() {
     for ( int i = 0; i < this.ticket; i++) {
       synchronized ( this) {
         if ( this.ticket > 0) {
           try {
            Thread.sleep(1000);
          } catch (InterruptedException e) {
             // TODO Auto-generated catch block
            e.printStackTrace();
          }
          System.out.println( "售票进行中，ticket=" + this.ticket--);
        }    
      }
        
    }

  }

}
public class ThreadDemo {

   /**
    * 多次运行，观察运行结果
    */
   public static void main(String[] args) {
    MyThread t = new MyThread();
    Thread thread = new Thread(t);
    thread.start();
    Thread thread1 = new Thread(t);
    thread1.start();
    Thread thread2 = new Thread(t);
    thread2.start();
    Thread thread3 = new Thread(t);
    thread3.start();

  }

}

      同步方法的定义格式：

     synchronized 方法返回值 方法名称（参数列表）{

 

}

class MyThread implements Runnable{
  private int ticket = 5 ;  // 假设一共有5张票
  public void run(){
    for(int i=0;i<100;i++){
      this.sale() ;  // 调用同步方法
    }
  }
  public synchronized void sale(){  // 声明同步方法
    if(ticket>0){  // 还有票
      try{
        Thread.sleep(300) ;  // 加入延迟
      }catch(InterruptedException e){
        e.printStackTrace() ;
      }
      System.out.println("卖票：ticket = " + ticket-- );
    }

  }
};
public class SyncDemo03{
  public static void main(String args[]){
    MyThread mt = new MyThread() ;  // 定义线程对象
    Thread t1 = new Thread(mt) ;  // 定义Thread对象
    Thread t2 = new Thread(mt) ;  // 定义Thread对象
    Thread t3 = new Thread(mt) ;  // 定义Thread对象
    t1.start() ;
    t2.start() ;
    t3.start() ;
  }
};

加上同步代码块叫做 同步操作，不佳同步代码块叫做 异步操作

 

资源共享时需要同步操作，过多的同步会产生死锁

死锁一般表示情况下就是表示在相互等待，是在程序运行时出现的一种问题。

class Zhangsan{   // 定义张三类
   public void say(){
    System.out.println( "张三对李四说：“你给我画，我就把书给你。”") ;
  }
   public void get(){
    System.out.println( "张三得到画了。") ;
  }
};
class Lisi{   // 定义李四类
   public void say(){
    System.out.println( "李四对张三说：“你给我书，我就把画给你”") ;
  }
   public void get(){
    System.out.println( "李四得到书了。") ;
  }
};
public class ThreadDeadLock implements Runnable{
   private static Zhangsan zs = new Zhangsan() ;     // 实例化static型对象
   private static Lisi ls = new Lisi() ;     // 实例化static型对象
   private boolean flag = false ;   // 声明标志位，判断那个先说话
   public void run(){   // 覆写run()方法
     if(flag){
       synchronized(zs){   // 同步张三
        zs.say() ;
         try{
          Thread.sleep(500) ;
        } catch(InterruptedException e){
          e.printStackTrace() ;
        }
         synchronized(ls){
          zs.get() ;
        }
      }
    } else{
       synchronized(ls){
        ls.say() ;
         try{
          Thread.sleep(500) ;
        } catch(InterruptedException e){
          e.printStackTrace() ;
        }
         synchronized(zs){
          ls.get() ;
        }
      }
    }
  }
   public static void main(String args[]){
    ThreadDeadLock t1 = new ThreadDeadLock() ;     // 控制张三
    ThreadDeadLock t2 = new ThreadDeadLock() ;     // 控制李四
    t1.flag = true ;
    t2.flag = false ;
    Thread thA = new Thread(t1) ;
    Thread thB = new Thread(t2) ;
    thA.start() ;
    thB.start() ;
  }
};