一 、多线程：

售票窗口简单实例：

public class SaleTicket {

    public static class Sale implements Runnable{
        private int ticket=10;
//        @Override
//        public void run() {
//            while(true){
//                synchronized(this){         //同步代码块   synchronized(this)锁着的是对象 
//                    if(ticket>0){
//                        try {
//                            Thread.sleep(500);
//                        } catch (InterruptedException e) {
//                            // TODO Auto-generated catch block
//                            e.printStackTrace();
//                        }
//                        System.out.println(Thread.currentThread().getName()+"卖完一张，车票剩余："+ticket--);
//                    }else break;
//                }
//            }
//            
//        }

        @Override
        public void run() {
            for(int i=0;i<20;i++){
                tell();
            }
        }
        
        public synchronized void tell(){    //同步方法
            if(ticket>0){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"卖完一张，车票剩余："+ticket--);
            }
        }
        
    }
    public static void main(String[] args) {
        Sale s = new Sale();
        Thread t1 = new Thread(s, "售票员1");
        Thread t2 = new Thread(s, "售票员2");
        Thread t3 = new Thread(s, "售票员3");
        t1.start();
        t2.start();
        t3.start();
    }

}

运用结果：

售票员1卖完一张，车票剩余：10
售票员1卖完一张，车票剩余：9
售票员1卖完一张，车票剩余：8
售票员1卖完一张，车票剩余：7
售票员3卖完一张，车票剩余：6
售票员1卖完一张，车票剩余：5
售票员2卖完一张，车票剩余：4
售票员2卖完一张，车票剩余：3
售票员3卖完一张，车票剩余：2
售票员3卖完一张，车票剩余：1

二、线程死锁：

线程的同步化可能会造成死锁，死锁发生在两个线程相互持有对方正在等待的东西（实际是两个线程共享的东西）。只要有两个线程和两个对象就可能产生死锁

/** 
*  
* 一个简单的死锁类 
* 当DeadLock类的对象flag==1时（td1），先锁定o1,睡眠500毫秒 
* 而td1在睡眠的时候另一个flag==0的对象（td2）线程启动，先锁定o2,睡眠500毫秒 
* td1睡眠结束后需要锁定o2才能继续执行，而此时o2已被td2锁定； 
* td2睡眠结束后需要锁定o1才能继续执行，而此时o1已被td1锁定； 
* td1、td2相互等待，都需要得到对方锁定的资源才能继续执行，从而死锁。 
*/ 
public class DeadLock implements Runnable{
    public int flag = 1;
    //静态对象是类的所有对象共享的  
    private static Object o1 = new Object(),o2 = new Object();
    
    @Override
    public void run() {
        System.out.println("flag=" + flag);  
        if(flag == 1){
            synchronized (o1) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
                synchronized(o2){
                    System.out.println("1");
                }
            }
            
        }
        
        if(flag == 0){
            synchronized(o2){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
                synchronized(o1){
                    System.out.println("0");
                }
            }
            
        }
    }

    public static void main(String[] args) {
        DeadLock td1 = new DeadLock();
        DeadLock td2 = new DeadLock();
        td1.flag = 1;
        td2.flag = 0;
        new Thread(td1,"td1").start();
        new Thread(td2,"td2").start();
    }

    
}

运行结果：

flag=1
flag=0

结果产生了死锁