Java多线程和死锁

一 、多线程：

售票窗口简单实例：

public class SaleTicket {

    public static class Sale implements Runnable{
        private int ticket=;
//        @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=;i<;i++){
                tell();
            }
        }

        public synchronized void tell(){    //同步方法
            if(ticket>){
                try {
                    Thread.sleep();
                } 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 = ;
    //静态对象是类的所有对象共享的
    private static Object o1 = new Object(),o2 = new Object();

    @Override
    public void run() {
        System.out.println("flag=" + flag);
        if(flag == ){
            synchronized (o1) {
                try {
                    Thread.sleep();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

                synchronized(o2){
                    System.out.println("");
                }
            }

        }

        if(flag == ){
            synchronized(o2){
                try {
                    Thread.sleep();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

                synchronized(o1){
                    System.out.println("");
                }
            }

        }
    }

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

}

运行结果：

flag=1
flag=0

结果产生了死锁